Merge pull request 'Add multiple Page capability' (#19) from feat/multi-page into dev

Reviewed-on: #19

internal/database/database.go

@@ -25,6 +25,8 @@ func OpenSQLite(basepath string) error {
 func InitDB() {
 	_, err := database.Exec(TOKENTABLECREATE)
 	_, err = database.Exec(SVGTABLECREATE)
+	_, err = database.Exec(SVGPAGETABLECREATE)
+
 	if err != nil {
 		log.Fatal("Failed to init database:\n", err)
 	}

internal/database/svgdb.go

@@ -1,32 +1,24 @@
 package database
 
 import (
-	"encoding/json"
-	"log"
-
 	"tomatentum.net/svg-templater/pkg/svg"
 )
 
 const SVGTABLECREATE string = `
 	CREATE TABLE IF NOT EXISTS svg (
 		id varchar(16) PRIMARY KEY NOT NULL,
-		name varchar(32),
-		templatekeys longtext NOT NULL
+		name varchar(32)
 	);`
 
-const INSERTSVGSQL string = "INSERT INTO svg VALUES (?, ?, ?);"
+const INSERTSVGSQL string = "INSERT INTO svg VALUES (?, ?);"
 const GETSPECIFICSVGSQL string = "SELECT * FROM svg WHERE id = ?;"
 const GETSVGSQL string = "SELECT * FROM svg;"
 const DELETESVGSQL string = "DELETE FROM svg WHERE id = ?;"
 const RENAMESVGSQL string = "UPDATE svg SET name = ? WHERE id = ?;"
+const EXISTSSVGSQL string = "SELECT COUNT(*) FROM svg WHERE id = ?;"
 
 func InsertSVG(data *svg.TemplateData) error {
-	json, err := json.Marshal(data.TemplateKeys)
-	if err != nil {
-		return err
-	}
-
-	if _, err := database.Exec(INSERTSVGSQL, data.Id, data.Name, string(json)); err != nil {
+	if _, err := database.Exec(INSERTSVGSQL, data.Id, data.Name); err != nil {
 		return err
 	}
 
@@ -42,18 +34,19 @@ func GetSVG() ([]svg.TemplateData, error) {
 	templates := make([]svg.TemplateData, 0)
 	for result.Next() {
 		var (
-			id       string
-			name     string
-			keysjson []byte
-			keys     []string
+			id   string
+			name string
 		)
-		if err := result.Scan(&id, &name, &keysjson); err != nil {
+		if err := result.Scan(&id, &name); err != nil {
 			return nil, err
 		}
-		if err := json.Unmarshal(keysjson, &keys); err != nil {
+		pages, err := GetSVGPages(id)
+
+		if err != nil {
 			return nil, err
 		}
-		templates = append(templates, svg.TemplateData{Id: id, Name: name, TemplateKeys: keys})
+
+		templates = append(templates, svg.TemplateData{Id: id, Name: name, Pages: pages})
 	}
 
 	if err := result.Err(); err != nil {
@@ -65,18 +58,17 @@ func GetSVG() ([]svg.TemplateData, error) {
 func GetSpecificSVG(id string) (svg.TemplateData, error) {
 	result := database.QueryRow(GETSPECIFICSVGSQL, id)
 
-	var (
-		name     string
-		keysjson []byte
-		keys     []string
-	)
-	if err := result.Scan(&id, &name, &keysjson); err != nil {
+	var name string
+	if err := result.Scan(&id, &name); err != nil {
 		return svg.TemplateData{}, err
 	}
-	if err := json.Unmarshal(keysjson, &keys); err != nil {
+
+	pages, err := GetSVGPages(id)
+
+	if err != nil {
 		return svg.TemplateData{}, err
 	}
-	return svg.TemplateData{Id: id, Name: name, TemplateKeys: keys}, nil
+	return svg.TemplateData{Id: id, Name: name, Pages: pages}, nil
 }
 
 func DeleteSvg(id string) (bool, error) {
@@ -92,14 +84,25 @@ func DeleteSvg(id string) (bool, error) {
 	if num == 0 {
 		return false, nil
 	}
-	return true, nil
+	return DeleteAllSVGPages(id)
 }
 
 func RenameSvg(id string, name string) error {
-	res, err := database.Exec(RENAMESVGSQL, name, id)
-	log.Println(id, name, res)
+	_, err := database.Exec(RENAMESVGSQL, name, id)
 	if err != nil {
 		return err
 	}
 	return nil
 }
+
+func Exists(id string) (bool, error) {
+	res := database.QueryRow(EXISTSSVGSQL, id)
+
+	var count int
+
+	if err := res.Scan(&count); err != nil {
+		return false, err
+	}
+
+	return count > 0, nil
+}

internal/database/svgpagedb.go

@@ -0,0 +1,129 @@
+package database
+
+import (
+	"encoding/json"
+
+	"tomatentum.net/svg-templater/pkg/svg"
+)
+
+func AddPage(page svg.TemplatePage) {
+
+}
+
+func DeletePage(templateID string, page int) {
+
+}
+
+const SVGPAGETABLECREATE string = `
+	CREATE TABLE IF NOT EXISTS svgpage (
+		id varchar(16) NOT NULL,
+		page int NOT NULL,
+		templatekeys longtext NOT NULL,
+		PRIMARY KEY (id, page)
+	);`
+
+const INSERTSVGPAGESQL string = "INSERT INTO svgpage VALUES (?, ?, ?);"
+const GETSPECIFICSVGPAGESSQL string = "SELECT * FROM svgpage WHERE id = ?;"
+const DELETESVGPAGESQL string = "DELETE FROM svgpage WHERE id = ? AND page = ?;"
+const DELETEALLSVGPAGESQL string = "DELETE FROM svgpage WHERE id = ?;"
+const COUNTSVGPAGESQL string = "SELECT COUNT(*) FROM svgpage WHERE id = ?;"
+const UPDATEPAGESQL string = "UPDATE svgpage SET page = page - 1 WHERE page > ?;"
+
+func InsertSVGPage(data *svg.TemplatePage) (int, error) {
+	json, err := json.Marshal(data.TemplateKeys)
+	if err != nil {
+		return 0, err
+	}
+
+	count, err := GetPageCount(data.TemplateId)
+
+	if err != nil {
+		return 0, err
+	}
+
+	if _, err := database.Exec(INSERTSVGPAGESQL, data.TemplateId, count+1, string(json)); err != nil {
+		return 0, err
+	}
+
+	return count + 1, nil
+}
+
+func GetSVGPages(id string) ([]svg.TemplatePage, error) {
+	res, err := database.Query(GETSPECIFICSVGPAGESSQL, id)
+
+	if err != nil {
+		return nil, err
+	}
+	defer res.Close()
+	pages := make([]svg.TemplatePage, 0)
+	for res.Next() {
+		var (
+			id       string
+			page     int
+			keysjson []byte
+			keys     []string
+		)
+		if err := res.Scan(&id, &page, &keysjson); err != nil {
+			return nil, err
+		}
+		if err := json.Unmarshal(keysjson, &keys); err != nil {
+			return nil, err
+		}
+		pages = append(pages, svg.TemplatePage{TemplateId: id, Page: page, TemplateKeys: keys})
+	}
+	return pages, nil
+}
+
+func DeleteSVGPage(id string, page int) (bool, error) {
+	res, err := database.Exec(DELETESVGPAGESQL, id, page)
+	if err != nil {
+		return false, err
+	}
+	num, err := res.RowsAffected()
+	if err != nil {
+		return false, err
+	}
+
+	if num == 0 {
+		return false, nil
+	}
+
+	if err := movePages(id, page); err != nil {
+		return false, err
+	}
+
+	return true, nil
+}
+
+func DeleteAllSVGPages(id string) (bool, error) {
+	res, err := database.Exec(DELETEALLSVGPAGESQL, id)
+	if err != nil {
+		return false, err
+	}
+	num, err := res.RowsAffected()
+	if err != nil {
+		return false, err
+	}
+
+	if num == 0 {
+		return false, nil
+	}
+	return true, nil
+}
+
+func GetPageCount(id string) (int, error) {
+	res := database.QueryRow(COUNTSVGPAGESQL, id)
+
+	var count int
+
+	if err := res.Scan(&count); err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+func movePages(id string, deletedPage int) error {
+	_, err := database.Exec(UPDATEPAGESQL, deletedPage)
+	return err
+}

internal/routes/download.go

@@ -17,7 +17,7 @@ type downloadRequest struct {
 }
 
 type downloadResponse struct {
-	Url string
+	Urls []string
 }
 
 func DownloadSVG(w http.ResponseWriter, r *http.Request) {
@@ -73,16 +73,23 @@ func DownloadSVG(w http.ResponseWriter, r *http.Request) {
 		Keys: request.TemplateKeys,
 	}
 
-	filename, err := actions.ProvideFile(&templateParam, &convParam)
+	filenames, err := actions.ProvideFile(&templateParam, &convParam)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	urlparsed := getPublicUrl(r, filename)
-	log.Printf("Made %s available as %s\n", id, urlparsed)
-	response := downloadResponse{
-		Url: urlparsed,
+
+	urlsparsed := make([]string, len(filenames))
+	for i, filename := range filenames {
+		urlsparsed[i] = getPublicUrl(r, filename)
+		log.Printf("Made %s page %d available as %s\n", id, i, urlsparsed[i])
+
 	}
+
+	response := downloadResponse{
+		Urls: urlsparsed,
+	}
+
 	w.Header().Add("Content-Type", "application/json")
 	json, err := json.Marshal(response)
 	if err != nil {

internal/routes/pages.go

@@ -0,0 +1,80 @@
+package routes
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"strconv"
+
+	"tomatentum.net/svg-templater/pkg/svg"
+	"tomatentum.net/svg-templater/pkg/svg/actions"
+)
+
+func AddPage(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseMultipartForm(128000000); err != nil {
+		http.Error(w, "Couldn't parse form data.", http.StatusBadRequest)
+		return
+	}
+
+	fileheaders := r.MultipartForm.File["files"]
+
+	id := r.PathValue("id")
+
+	pages := make([]svg.TemplatePage, len(fileheaders))
+
+	for i, fileh := range fileheaders {
+		file, err := fileh.Open()
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		buf, err := io.ReadAll(file)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		page, err := actions.AddPage(id, buf)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		pages[i] = page
+	}
+
+	err := json.NewEncoder(w).Encode(pages)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func DeletePage(w http.ResponseWriter, r *http.Request) {
+
+	id, pagestring := r.PathValue("id"), r.PathValue("page")
+
+	page, err := strconv.Atoi(pagestring)
+
+	if err != nil {
+		http.Error(w, "Page must be a number", http.StatusBadRequest)
+		return
+	}
+
+	ok, err := actions.DeletePage(id, page)
+
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if !ok {
+		http.Error(w, "Could not delete page", http.StatusInternalServerError)
+		return
+	}
+}

internal/routes/upload.go

@@ -10,39 +10,53 @@ import (
 	"tomatentum.net/svg-templater/pkg/svg/actions"
 )
 
-func CreateSVG(writer http.ResponseWriter, r *http.Request) {
+func CreateSVG(w http.ResponseWriter, r *http.Request) {
 
-	contentType := r.Header.Get("Content-Type")
-	if contentType != "image/svg+xml" {
-		http.Error(writer, "Incorrect Content-Type. Needs image/svg+xml.", http.StatusUnsupportedMediaType)
+	if err := r.ParseMultipartForm(128000000); err != nil {
+		http.Error(w, "Couldn't parse form data.", http.StatusBadRequest)
 		return
 	}
 
-	readsvg, err := io.ReadAll(r.Body)
-	if err != nil {
-		http.Error(writer, err.Error(), http.StatusInternalServerError)
-		log.Println("Error while reading Body\n", err)
-		return
-	}
+	fileheaders := r.MultipartForm.File["files"]
 
-	if ok, err := validateSVG(readsvg); err != nil || !ok {
-		http.Error(writer, err.Error(), http.StatusUnsupportedMediaType)
-		log.Println("Wrong Media Type was uploaded\n", err)
-		return
+	files := make([][]byte, len(fileheaders))
+
+	for i, fileh := range fileheaders {
+		file, err := fileh.Open()
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		buf, err := io.ReadAll(file)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		if ok, err := validateSVG(buf); err != nil || !ok {
+			http.Error(w, err.Error(), http.StatusUnsupportedMediaType)
+			log.Println("Wrong Media Type was uploaded\n", err)
+			return
+		}
+
+		files[i] = buf
 	}
 
 	name := r.URL.Query().Get("name")
 
-	data, err := actions.Create(readsvg, name)
+	data, err := actions.Create(files, name)
 
 	if err != nil {
-		http.Error(writer, err.Error(), http.StatusInternalServerError)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		log.Println("Failed creating SVG template\n", err)
 		return
 	}
 
-	writer.Header().Add("Content-Type", "application/json")
-	json.NewEncoder(writer).Encode(data)
+	w.Header().Add("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(data)
 }
 
 func validateSVG(svgbuf []byte) (bool, error) {

internal/server/http.go

@@ -43,6 +43,22 @@ func PrepareHTTP() {
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 
 	})
+
+	registerAuthorizedFunc("/svg/{id}/page/", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "POST" {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+		routes.AddPage(w, r)
+	})
+
+	registerAuthorizedFunc("/svg/{id}/page/{page}", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "DELETE" {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+		routes.DeletePage(w, r)
+	})
 	registerAuthorizedFunc("/font/", func(w http.ResponseWriter, r *http.Request) {
 		switch r.Method {
 		case "GET":

pkg/format/formatconverter.go

@@ -55,10 +55,8 @@ func convertPNG(input string, param ConversionParameters) (io.ReadCloser, error)
 	var args []string
 	var outExt string
 
-	fontsdir, err := svg.Storage.GetFontsDir()
-	if err != nil {
-		return nil, err
-	}
+	fontsdir := svg.Storage.GetFontsDir()
+
 	args = append(args, "--skip-system-fonts")
 	args = append(args, "--use-fonts-dir", fontsdir)
 

pkg/svg/actions/delete.go

@@ -2,6 +2,7 @@ package actions
 
 import (
 	"log"
+	"strings"
 
 	"tomatentum.net/svg-templater/internal/database"
 	"tomatentum.net/svg-templater/pkg/svg"
@@ -12,9 +13,18 @@ func Delete(id string) (bool, error) {
 		return success, err
 	}
 
-	if err := svg.Storage.Delete(id); err != nil {
+	entries, err := svg.Storage.List()
+
+	if err != nil {
 		return false, err
 	}
+
+	for _, entry := range entries {
+		if strings.HasPrefix(entry.Name(), id) {
+			svg.Storage.Delete(entry.Name())
+		}
+	}
+
 	log.Println("Deleted SVG Template " + id)
 	return true, nil
 }

pkg/svg/actions/download.go

@@ -3,20 +3,32 @@ package actions
 import (
 	"bytes"
 	"log"
+	"strconv"
 
 	"tomatentum.net/svg-templater/pkg/format"
 	"tomatentum.net/svg-templater/pkg/svg"
 )
 
-func ProvideFile(r *TemplateParameters, conversion *format.ConversionParameters) (string, error) {
-	templatedSvgblob, err := Template(r)
+func ProvideFile(r *TemplateParameters, conversion *format.ConversionParameters) ([]string, error) {
+	templatedPages, err := Template(r)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 	log.Printf("Converting %s to format %s (w=%d,h=%d)", r.Id, conversion.Format, conversion.Width, conversion.Height)
-	result, err := format.ConvertByte(templatedSvgblob, *conversion)
-	if err != nil {
-		return "", err
+	filenames := make([]string, len(templatedPages))
+	for i, pagedata := range templatedPages {
+		result, err := format.ConvertByte(pagedata, *conversion)
+		if err != nil {
+			return nil, err
+		}
+		filenames[i], err = svg.Storage.CreatePublic(bytes.NewReader(result), strconv.Itoa(i+1), conversion.Format)
+
+		if err != nil {
+			return nil, err
+		}
+		log.Printf("Converted %s page %d to format %s (w=%d,h=%d)", r.Id, i, conversion.Format, conversion.Width, conversion.Height)
+
 	}
-	return svg.Storage.CreatePublic(bytes.NewReader(result), conversion.Format)
+
+	return filenames, nil
 }

pkg/svg/actions/page.go

@@ -0,0 +1,85 @@
+package actions
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"regexp"
+	"strconv"
+
+	"tomatentum.net/svg-templater/internal/database"
+	"tomatentum.net/svg-templater/pkg/svg"
+)
+
+const FILEFORMAT string = "%s-%d"
+
+func AddPage(id string, svgbuf []byte) (svg.TemplatePage, error) {
+
+	exists, err := database.Exists(id)
+
+	if err != nil {
+		return svg.TemplatePage{}, err
+	}
+
+	if !exists {
+		return svg.TemplatePage{}, errors.New("Template does not exist.")
+	}
+
+	data := svg.TemplatePage{TemplateId: id}
+	populateKeys(&data, svgbuf)
+
+	page, err := database.InsertSVGPage(&data)
+
+	data.Page = page
+
+	if err != nil {
+		return svg.TemplatePage{}, err
+	}
+
+	_, err = svg.Storage.Create(fmt.Sprintf(FILEFORMAT, id, page), bytes.NewReader(svgbuf))
+	if err != nil {
+		return svg.TemplatePage{}, err
+	}
+
+	log.Println("Created SVG Template " + data.TemplateId + " Page " + strconv.Itoa(page))
+	return data, nil
+}
+
+func GetPage(id string, page int) ([]byte, error) {
+	file, err := svg.Storage.Get(fmt.Sprintf(FILEFORMAT, id, page))
+
+	if err != nil {
+		return nil, err
+	}
+
+	defer file.Close()
+
+	return io.ReadAll(file)
+}
+
+func DeletePage(id string, page int) (bool, error) {
+	if success, err := database.DeleteSVGPage(id, page); err != nil || !success {
+		return success, err
+	}
+
+	if err := svg.Storage.Delete(fmt.Sprintf(FILEFORMAT, id, page)); err != nil {
+		return false, err
+	}
+	log.Println("Deleted SVG Template " + id + " page " + strconv.Itoa(page))
+	return true, nil
+}
+
+func populateKeys(data *svg.TemplatePage, svgblob []byte) {
+	regex := regexp.MustCompile(svg.KeyRegex)
+	result := regex.FindAllSubmatch(svgblob, -1)
+	templateKeys := make([]string, len(result))
+
+	for i, matches := range result {
+		varname := matches[1] // first capture group
+		templateKeys[i] = string(varname)
+	}
+	data.TemplateKeys = templateKeys
+	log.Println("Found keys:\n", templateKeys)
+}

pkg/svg/actions/template.go

@@ -2,7 +2,6 @@ package actions
 
 import (
 	"errors"
-	"io"
 	"log"
 	"maps"
 	"regexp"
@@ -18,29 +17,42 @@ type TemplateParameters struct {
 	Keys map[string]string
 }
 
-func Template(r *TemplateParameters) ([]byte, error) {
-	mapkeys := slices.Collect(maps.Keys(r.Keys))
-	ok, err := verifyTemplate(r.Id, mapkeys)
+func Template(r *TemplateParameters) ([][]byte, error) {
+
+	data, err := database.GetSpecificSVG(r.Id)
+
 	if err != nil {
 		return nil, err
 	}
+
+	mapkeys := slices.Collect(maps.Keys(r.Keys))
+	ok, err := verifyTemplate(data, mapkeys)
+
+	if err != nil {
+		return nil, err
+	}
+
 	if !ok {
 		return nil, errors.New("Template does not exist.")
 	}
 	log.Printf("Replacing keys of %s template\n", r.Id)
 
-	reader, err := svg.Storage.Get(r.Id)
-	if err != nil {
-		return nil, err
+	pagesdata := make([][]byte, len(data.Pages))
+
+	for _, page := range data.Pages {
+		pagedata, err := GetPage(page.TemplateId, page.Page)
+
+		if err != nil {
+			return nil, err
+		}
+
+		replaceAll(&pagedata, r.Keys)
+		pagesdata[page.Page-1] = pagedata
+		log.Printf("Finished replacing keys of %s page %d\n", r.Id, page.Page)
+
 	}
-	defer reader.Close()
-	svgblob, err := io.ReadAll(reader)
-	if err != nil {
-		return nil, err
-	}
-	replaceAll(&svgblob, r.Keys)
 	log.Printf("Finished replacing keys of %s template\n", r.Id)
-	return svgblob, nil
+	return pagesdata, nil
 }
 
 func replaceAll(svgblob *[]byte, keys map[string]string) {
@@ -51,13 +63,8 @@ func replaceAll(svgblob *[]byte, keys map[string]string) {
 	}))
 }
 
-func verifyTemplate(id string, keys []string) (bool, error) {
-	data, err := database.GetSpecificSVG(id)
-	if err != nil {
-		return false, err
-	}
-
-	for _, key := range data.TemplateKeys {
+func verifyTemplate(data svg.TemplateData, keys []string) (bool, error) {
+	for _, key := range data.AllKeys() {
 		if !slices.Contains(keys, key) {
 			return false, nil
 		}

pkg/svg/actions/upload.go

@@ -1,46 +1,38 @@
 package actions
 
 import (
-	"bytes"
 	"crypto/rand"
 	"encoding/hex"
 	"log"
-	"regexp"
 
 	"tomatentum.net/svg-templater/internal/database"
 	"tomatentum.net/svg-templater/pkg/svg"
 )
 
-func Create(svgbuf []byte, name string) (svg.TemplateData, error) {
-	data := svg.TemplateData{Id: generateId(), Name: name, TemplateKeys: nil}
-	populateKeys(&data, svgbuf)
-
-	_, err := svg.Storage.Create(data.Id, bytes.NewReader(svgbuf))
-	if err != nil {
-		return svg.TemplateData{}, err
-	}
+func Create(svgbufs [][]byte, name string) (svg.TemplateData, error) {
+	data := svg.TemplateData{Id: generateId(), Name: name}
 
 	if err := database.InsertSVG(&data); err != nil {
 		return svg.TemplateData{}, err
 	}
 
+	pages := make([]svg.TemplatePage, len(svgbufs))
+	for i, pagebuf := range svgbufs {
+		page, err := AddPage(data.Id, pagebuf)
+
+		if err != nil {
+			return svg.TemplateData{}, err
+		}
+
+		pages[i] = page
+	}
+
+	data.Pages = pages
+
 	log.Println("Created SVG Template " + data.Id)
 	return data, nil
 }
 
-func populateKeys(data *svg.TemplateData, svgblob []byte) {
-	regex := regexp.MustCompile(svg.KeyRegex)
-	result := regex.FindAllSubmatch(svgblob, -1)
-	templateKeys := make([]string, len(result))
-
-	for i, matches := range result {
-		varname := matches[1] // first capture group
-		templateKeys[i] = string(varname)
-	}
-	data.TemplateKeys = templateKeys
-	log.Println("Found keys:\n", templateKeys)
-}
-
 func generateId() string {
 	token := make([]byte, 16)
 	if _, err := rand.Read(token); err != nil {

pkg/svg/storage.go

@@ -2,6 +2,7 @@ package svg
 
 import (
 	"errors"
+	"fmt"
 	"io"
 	"log"
 	"net/http"
@@ -13,13 +14,14 @@ import (
 )
 
 type SvgStorage interface {
-	Create(id string, svg io.Reader) (string, error)
-	Get(id string) (io.ReadCloser, error)
-	Delete(id string) error
+	Create(name string, svg io.Reader) (string, error)
+	Get(name string) (io.ReadCloser, error)
+	Delete(name string) error
+	List() ([]os.DirEntry, error)
 	AddFont(reader io.Reader, format string) error
 	GetFonts() ([]string, error)
-	GetFontsDir() (string, error)
-	CreatePublic(data io.Reader, filetype string) (string, error)
+	GetFontsDir() string
+	CreatePublic(data io.Reader, suffix string, filetype string) (string, error)
 	GetPublic(path string) (io.ReadCloser, error)
 	GetPublicDir() http.Dir
 }
@@ -44,8 +46,8 @@ func NewFileStorage(path, publicSubPath, fontssubpath string) *FileSvgStorage {
 	return &FileSvgStorage{path, publicSubPath, fontssubpath}
 }
 
-func (f FileSvgStorage) Create(id string, svg io.Reader) (string, error) {
-	file, err := os.Create(filepath.Join(f.basepath, id+".svg"))
+func (f FileSvgStorage) Create(name string, svg io.Reader) (string, error) {
+	file, err := os.Create(filepath.Join(f.basepath, name+".svg"))
 
 	if err != nil {
 		return "", err
@@ -61,27 +63,37 @@ func (f FileSvgStorage) Create(id string, svg io.Reader) (string, error) {
 	return file.Name(), nil
 }
 
-func (f FileSvgStorage) Get(id string) (io.ReadCloser, error) {
-	file, err := os.Open(filepath.Join(f.basepath, id+".svg"))
+func (f FileSvgStorage) Get(name string) (io.ReadCloser, error) {
+	file, err := os.Open(filepath.Join(f.basepath, name+".svg"))
 	if err != nil {
 		return nil, err
 	}
 	return file, nil
 }
 
-func (f FileSvgStorage) Delete(id string) error {
-	path := filepath.Join(f.basepath, id+".svg")
+func (f FileSvgStorage) Delete(name string) error {
+	var path string
+	if strings.HasSuffix(name, ".svg") {
+		path = filepath.Join(f.basepath, name)
+	} else {
+		path = filepath.Join(f.basepath, name+".svg")
+
+	}
 	defer log.Println("Deleted File: " + path)
 	return os.Remove(path)
 }
 
-func (f FileSvgStorage) CreatePublic(data io.Reader, filetype string) (string, error) {
+func (f FileSvgStorage) List() ([]os.DirEntry, error) {
+	return os.ReadDir(f.basepath)
+}
+
+func (f FileSvgStorage) CreatePublic(data io.Reader, suffix string, filetype string) (string, error) {
 	path := filepath.Join(f.basepath, f.publicSubPath)
 	if err := os.MkdirAll(path, 0755); err != nil {
 		return "", err
 	}
 
-	file, err := os.CreateTemp(path, "*."+filetype)
+	file, err := os.CreateTemp(path, fmt.Sprintf("*-%s."+filetype, suffix))
 	if err != nil {
 		return "", err
 	}
@@ -164,8 +176,8 @@ func (f FileSvgStorage) GetFonts() ([]string, error) {
 	return fonts, nil
 }
 
-func (f FileSvgStorage) GetFontsDir() (string, error) {
-	return filepath.Join(f.basepath, f.fontssubpath), nil
+func (f FileSvgStorage) GetFontsDir() string {
+	return filepath.Join(f.basepath, f.fontssubpath)
 }
 
 func getFontName(svgblob []byte) (string, error) {

pkg/svg/templates.go

@@ -1,11 +1,33 @@
 package svg
 
+import "slices"
+
 const KeyRegex string = `\{\{\s*(.*?)\s*\}\}`
 
 type TemplateData struct {
-	Id           string
-	Name         string
+	Id    string
+	Name  string
+	Pages []TemplatePage
+}
+
+type TemplatePage struct {
+	TemplateId   string
+	Page         int
 	TemplateKeys []string
 }
 
 var Storage SvgStorage
+
+func (d TemplateData) AllKeys() []string {
+	keys := make([]string, 0)
+
+	for _, page := range d.Pages {
+		for _, key := range page.TemplateKeys {
+			if !slices.Contains(keys, key) {
+				keys = append(keys, key)
+			}
+		}
+	}
+
+	return keys
+}