Implement updatings

go.mod

@@ -1,4 +1,4 @@
-module wails-template
+module wow-addon-manager
 
 go 1.21
 

main.go

@@ -1,18 +1,42 @@
 package main
 
 import (
+	"archive/zip"
+	"bytes"
 	"embed"
 	"fmt"
+	"io"
 	"log"
+	"net/http"
 	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
 
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/options"
 	"github.com/wailsapp/wails/v2/pkg/options/assetserver"
 )
 
+var Error *log.Logger
+var Warning *log.Logger
+
+func init() {
+	log.SetFlags(log.Lmicroseconds | log.Lshortfile)
+
+	Error = log.New(io.MultiWriter(os.Stderr, os.Stdout),
+		fmt.Sprintf("%sERROR:%s ", "\033[0;101m", "\033[0m"),
+		log.Lmicroseconds|log.Lshortfile)
+	Warning = log.New(io.MultiWriter(os.Stdout),
+		fmt.Sprintf("%sWarning:%s ", "\033[0;93m", "\033[0m"),
+		log.Lmicroseconds|log.Lshortfile)
+}
+
 //go:embed all:frontend/dist
 var assets embed.FS
+var gamePath string
+var versionRegex = regexp.MustCompile(`(\d+\.\d+\.\d+)`)
 
 type Addon struct {
 	Name string
@@ -24,7 +48,7 @@ func NewAddon(name, aurl string) *Addon {
 	var err error
 	a.URL, err = url.Parse(aurl)
 	if err != nil {
-		fmt.Errorf("invalid url: %s", aurl)
+		Error.Printf("invalid url: %s", aurl)
 		return nil
 	}
 	return a
@@ -34,20 +58,174 @@ var addons = []*Addon{
 	NewAddon("Channeler", "https://git.site.quack-lab.dev/dave/wow_channeler"),
 }
 
-func (a *Addon) GetToc() *url.URL {
+func (a *Addon) GetRemoteTocURL() *url.URL {
-	return a.URL.JoinPath(a.Name + ".toc")
+	return a.URL.JoinPath("raw", "branch", "master", a.Name+".toc")
+}
+func (a *Addon) GetRemoteReleaseURL() *url.URL {
+	return a.URL.JoinPath("media", "branch", "master", a.Name+".zip")
+}
+func (a *Addon) GetRemoteRelease() (body []byte, err error) {
+	url := a.GetRemoteReleaseURL()
+	response, err := http.Get(url.String())
+	if err != nil {
+		return nil, fmt.Errorf("error getting remote release: %w", err)
+	}
+	return io.ReadAll(response.Body)
+}
+func (a *Addon) HasBreakingChanges(lhsToc, rhsToc string) bool {
+	lhsLines := strings.Split(lhsToc, "\n")
+	rhsLines := strings.Split(rhsToc, "\n")
+	for i, lhsLine := range lhsLines {
+		rhsLine := rhsLines[i]
+		lhsLine = strings.TrimSpace(lhsLine)
+		rhsLine = strings.TrimSpace(rhsLine)
+		// We don't care about ## lines
+		if strings.HasPrefix(lhsLine, "#") && strings.HasPrefix(rhsLine, "#") {
+			continue
+		}
+		// Nor do we care about empty lines
+		if lhsLine == "" && rhsLine == "" {
+			continue
+		}
+
+		log.Printf("%s %s", lhsLine, rhsLine)
+		if i >= len(rhsLines) || rhsLine != lhsLine {
+			return true
+		}
+	}
+	return false
+}
+func UpdateFile(localPath string, data []byte) (err error) {
+	err = os.MkdirAll(filepath.Dir(localPath), 0755)
+	if err != nil {
+		return fmt.Errorf("error creating directory: %w", err)
+	}
+	fileHandle, err := os.OpenFile(localPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		return fmt.Errorf("error opening file: %w", err)
+	}
+	defer fileHandle.Close()
+	_, err = fileHandle.Write(data)
+	if err != nil {
+		return fmt.Errorf("error writing file: %w", err)
+	}
+
+	return nil
+}
+func (a *Addon) Update(body []byte) (err error) {
+	log.Printf("Updating %s", a.Name)
+	zipReader, err := zip.NewReader(bytes.NewReader(body), int64(len(body)))
+	if err != nil {
+		return fmt.Errorf("error creating zip reader: %w", err)
+	}
+	log.Printf("Found %d files", len(zipReader.File))
+	hasBreakingChanges := false
+	for _, file := range zipReader.File {
+		if file.FileInfo().IsDir() {
+			continue
+		}
+		log.Printf("Found file %s", file.Name)
+		fileHandle, err := file.Open()
+		if err != nil {
+			return fmt.Errorf("error opening file: %w", err)
+		}
+		fileData, err := io.ReadAll(fileHandle)
+		if err != nil {
+			return fmt.Errorf("error reading file: %w", err)
+		}
+
+		if strings.HasSuffix(file.Name, ".toc") {
+			localToc, err := os.ReadFile(a.GetLocalTocPath())
+			if err != nil {
+				if os.IsNotExist(err) {
+					localToc = []byte{}
+				} else {
+					return fmt.Errorf("error reading local toc: %w", err)
+				}
+			}
+			if a.HasBreakingChanges(string(localToc), string(fileData)) {
+				log.Printf("Has breaking changes")
+				hasBreakingChanges = true
+			}
+		}
+
+		localPath := filepath.Join(gamePath, "Interface", "AddOns", file.Name)
+		log.Printf("Updating file %s", localPath)
+		err = UpdateFile(localPath, fileData)
+		if err != nil {
+			return fmt.Errorf("error updating file: %w", err)
+		}
+	}
+	if hasBreakingChanges {
+		Warning.Printf("Has breaking changes")
+	}
+	return nil
+}
+func (a *Addon) GetLocalTocPath() string {
+	return filepath.Join(gamePath, "Interface", "AddOns", a.Name, a.Name+".toc")
+}
+func (a *Addon) GetRemoteVersion() (version string, err error) {
+	url := a.GetRemoteTocURL()
+	log.Printf("Fetching remote version from %s", url.String())
+	response, err := http.Get(url.String())
+	if err != nil {
+		return "", fmt.Errorf("error getting remote version: %w", err)
+	}
+	if response.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("error getting remote version with status: %s", response.Status)
+	}
+	defer response.Body.Close()
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return "", fmt.Errorf("error reading remote version: %w", err)
+	}
+	return GetVersion(string(body))
+}
+func (a *Addon) GetLocalVersion() (version string, err error) {
+	file, err := os.Open(a.GetLocalTocPath())
+	if err != nil {
+		return "", fmt.Errorf("error opening local toc: %w", err)
+	}
+	defer file.Close()
+	body, err := io.ReadAll(file)
+	if err != nil {
+		return "", fmt.Errorf("error reading local toc: %w", err)
+	}
+	return GetVersion(string(body))
+}
+func (a *Addon) IsUpToDate() bool {
+	remoteVersion, err := a.GetRemoteVersion()
+	if err != nil {
+		return false
+	}
+	localVersion, err := a.GetLocalVersion()
+	if err != nil {
+		return false
+	}
+	return remoteVersion == localVersion
 }
 
 func main() {
-	for _, addon := range addons {
+	gamePath = filepath.Join("C:\\", "Games", "WoWRuski")
-		log.Printf("%#v", addon.GetToc())
+	//	for _, addon := range addons {
+	//		log.Printf("%#v", addon.IsUpToDate())
+	//		log.Printf("%#v", addon.GetRemoteReleaseURL())
+	//	}
+	file, err := os.ReadFile("Heimdall.zip")
+	if err != nil {
+		log.Printf("error reading file: %s", err)
+		return
 	}
+	err = addons[0].Update(file)
+	if err != nil {
+		log.Printf("error updating addon: %s", err)
+		return
+	}
+	log.Printf("Addon updated")
 	return
-	// Create an instance of the app structure
 	app := NewApp()
 
-	// Create application with options
+	err = wails.Run(&options.App{
-	err := wails.Run(&options.App{
 		Title:  "wails-template",
 		Width:  1024,
 		Height: 768,

utils.go

@@ -0,0 +1,17 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func GetVersion(data string) (version string, err error) {
+	lines := strings.Split(data, "\n")
+	for _, line := range lines {
+		version = versionRegex.FindString(line)
+		if version != "" {
+			return version, nil
+		}
+	}
+	return "", fmt.Errorf("no version found")
+}

wails.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://wails.io/schemas/config.v2.json",
-  "name": "wails-template",
+  "name": "wow-addon-manager",
-  "outputfilename": "wails-template",
+  "outputfilename": "wow-addon-manager",
   "frontend:install": "pnpm install",
   "frontend:build": "pnpm build",
   "frontend:dev:watcher": "pnpm dev",