v0.6.0v0.6.0

- feat: add map page
- feat: use webp of various sizes (320/560/800/1200/1600w) as thumbnails
- feat: fixate gallery divs to viewport measures
- feat: make thumbnails square
- feat: remove recreating gallery on window resize
- refactor: replace gap with margins
- refactor: more line height in gallery captions
- refactor: have routes in separate files

6 files changed, 418 insertions, 0 deletions

diff --git a/internal/router/api-v1-blog-search.go b/internal/router/api-v1-blog-search.go
new file mode 100644
index 0000000..2997407
--- /dev/null
+++ b/internal/router/api-v1-blog-search.go
@@ -0,0 +1,109 @@
+package router
+
+import (
+	"fmt"
+	"log/slog"
+	"net/url"
+	"regexp"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Api_V1_BlogSearch(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		sort := c.Query("sort")
+		lang := c.Query("lang")
+		tz := c.Query("tz")
+
+		if !slices.Contains(langs, lang) {
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language", lang))
+		}
+
+		loc, err := time.LoadLocation(tz)
+		if err != nil {
+			loc = time.UTC
+			slog.Warn("unable to parse a client timezone, defaulting to UTC", slog.String("error", err.Error()), slog.String("tz", tz))
+		}
+
+		pages, err := b2Client.Scan(lang + "/")
+		if err != nil {
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString(fmt.Sprintf("failed to scan pages for '%s' lang: %v", lang, err))
+		}
+
+		encodedQuery := c.Request().URI().QueryString()
+		re, err := regexp.Compile(`tags\[\]=([\w]+)`)
+		if err != nil {
+			slog.Warn("failed to generate regex for tags gathering", slog.String("error", err.Error()))
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate regex for tags gathering")
+		}
+		decodedQuery, err := url.QueryUnescape(string(encodedQuery))
+		matches := re.FindAllStringSubmatch(decodedQuery, -1)
+
+		tags := make([]string, 0, len(matches))
+		for _, match := range matches {
+			tags = append(tags, string(match[1]))
+		}
+
+		pageMeta := make([]fiber.Map, 0, len(pages))
+		for _, page := range pages {
+			for _, tag := range page.Metadata.Tags {
+				if len(tags) == 0 || slices.Contains(tags, tag) {
+					pageMeta = append(pageMeta, fiber.Map{
+						"Link":             page.Link,
+						"ArticleLink":      "/" + lang + "/blog/" + page.FileName,
+						"Title":            page.Metadata.Title,
+						"PublishedTime":    page.Metadata.PublishedTime.In(loc).Format("2006-01-02 15:04:05 -07:00"),
+						"ActionDate":       page.Metadata.ActionDate,
+						"ShortDescription": page.Metadata.ShortDescription,
+						"Thumbnail":        page.Metadata.Thumbnail,
+						"Tags":             page.Metadata.Tags,
+					})
+					break
+				}
+			}
+		}
+
+		slices.SortFunc(pageMeta, func(a, b fiber.Map) int {
+			switch sort {
+			case "titleAsc":
+				return strings.Compare(a["Title"].(string), b["Title"].(string))
+			case "titleDesc":
+				return strings.Compare(b["Title"].(string), a["Title"].(string))
+			case "actionDateAsc":
+				return strings.Compare(a["ActionDate"].(string), b["ActionDate"].(string))
+			case "actionDateDesc":
+				return strings.Compare(b["ActionDate"].(string), a["ActionDate"].(string))
+			case "publicationDateAsc":
+				publishedTimeA, _ := time.Parse("2006-01-02 15:04:05 -07:00", a["PublishedTime"].(string))
+				publishedTimeB, _ := time.Parse("2006-01-02 15:04:05 -07:00", b["PublishedTime"].(string))
+				return publishedTimeA.Compare(publishedTimeB)
+			case "publicationDateDesc":
+				publishedTimeA, _ := time.Parse("2006-01-02 15:04:05 -07:00", a["PublishedTime"].(string))
+				publishedTimeB, _ := time.Parse("2006-01-02 15:04:05 -07:00", b["PublishedTime"].(string))
+				return publishedTimeB.Compare(publishedTimeA)
+			}
+			return 0
+		})
+
+		content, err := tm.Render("catalogue-blog-cards", fiber.Map{
+			"BlogPages": pageMeta,
+			"L":         l[lang],
+		})
+		if err != nil {
+			slog.Warn("failed to generate div", slog.String("page", "/"+lang+"/blog"), slog.String("error", err.Error()))
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate div")
+		}
+
+		return c.Type("html").Send(content)
+	}
+}
diff --git a/internal/router/api-v1-tz.go b/internal/router/api-v1-tz.go
new file mode 100644
index 0000000..4e4e462
--- /dev/null
+++ b/internal/router/api-v1-tz.go
@@ -0,0 +1,37 @@
+package router
+
+import (
+	"log/slog"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func Api_V1_TZ() func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		timestampString := c.Query("timestamp")
+		tz := c.Query("tz")
+
+		loc, err := time.LoadLocation(tz)
+		if err != nil {
+			loc = time.UTC
+			slog.Warn("unable to parse a client timezone, defaulting to UTC", slog.String("error", err.Error()), slog.String("tz", tz))
+		}
+
+		var format string
+		var timestamp time.Time
+		for _, format = range []string{"2006-01-02 15:04:05 -07:00", time.RFC3339} {
+			if timestamp, err = time.Parse(format, timestampString); err == nil {
+				break
+			}
+		}
+
+		c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+
+		if err != nil {
+			return c.Status(fiber.StatusBadRequest).SendString("invalid timestamp format")
+		}
+
+		return c.Status(fiber.StatusOK).SendString(timestamp.In(loc).Format(format))
+	}
+}
diff --git a/internal/router/lang-blog-title.go b/internal/router/lang-blog-title.go
new file mode 100644
index 0000000..39d4252
--- /dev/null
+++ b/internal/router/lang-blog-title.go
@@ -0,0 +1,76 @@
+package router
+
+import (
+	"bytes"
+	"fmt"
+	"html/template"
+	"log/slog"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/frontmatter"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+	"github.com/yuin/goldmark"
+)
+
+func Lang_Blog_Title(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client, md goldmark.Markdown) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		lang := c.Params("lang")
+		if !slices.Contains(langs, lang) {
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language... yet??", lang))
+		}
+
+		metadata, parsedMarkdown, err := readBlogPost(md, b2Client, lang+"/"+c.Params("title"))
+		if err != nil {
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("failed to find '%s' post", c.Params("title")))
+		}
+
+		geolocationParts := strings.Split(metadata.Geolocation, " ")
+		var x, y, areaError string
+		if len(geolocationParts) >= 2 {
+			x = geolocationParts[0]
+			y = geolocationParts[1]
+		}
+		if len(geolocationParts) >= 3 {
+			areaError = geolocationParts[2]
+		}
+
+		content, err := tm.Render("blog-page", fiber.Map{
+			"Title":                 metadata.Title,
+			"PublishedDate":         metadata.PublishedTime.Format("2006-01-02 15:04:05 -07:00"),
+			"PublishedYear":         strconv.Itoa(metadata.PublishedTime.Year()),
+			"ParsedMarkdown":        template.HTML(parsedMarkdown),
+			"MapLocationX":          x,
+			"MapLocationY":          y,
+			"MapLocationAreaMeters": areaError,
+			"Lang":                  lang,
+		})
+		if err != nil {
+			slog.Warn("failed to generate page", slog.String("page", "/"+lang+"/blog/"+c.Params("title")), slog.String("error", err.Error()))
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
+		}
+
+		return c.Type("html").Send(content)
+	}
+}
+
+func readBlogPost(md goldmark.Markdown, b2Client *b2.B2Client, sourceName string) (metadata *frontmatter.Metadata, html string, err error) {
+	metadata, markdown, err := b2Client.ReadFrontmatter(sourceName + ".md")
+	if err != nil {
+		return nil, "", fmt.Errorf("failed to read a frontmatter file: %w", err)
+	}
+
+	var buf bytes.Buffer
+	if err := md.Convert(markdown, &buf); err != nil {
+		return nil, "", fmt.Errorf("convert source context from md to html: %w", err)
+	}
+
+	return metadata, buf.String(), nil
+}
diff --git a/internal/router/lang-blog.go b/internal/router/lang-blog.go
new file mode 100644
index 0000000..1a7cbca
--- /dev/null
+++ b/internal/router/lang-blog.go
@@ -0,0 +1,90 @@
+package router
+
+import (
+	"fmt"
+	"log/slog"
+	"net/url"
+	"regexp"
+	"slices"
+	"strings"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Lang_Blog(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		lang := c.Params("lang")
+		if !slices.Contains(langs, lang) {
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language... yet??", lang))
+		}
+
+		querySort := c.Query("sort")
+		if querySort == "" {
+			querySort = "publicationDateDesc"
+		}
+
+		encodedQuery := c.Request().URI().QueryString()
+		re, err := regexp.Compile(`tags\[\]=([\w]+)`)
+		if err != nil {
+			slog.Warn("failed to generate regex for tags gathering", slog.String("error", err.Error()))
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate regex for tags gathering")
+		}
+		decodedQuery, err := url.QueryUnescape(string(encodedQuery))
+		matches := re.FindAllStringSubmatch(decodedQuery, -1)
+
+		queryTags := make([]string, 0, len(matches))
+		for _, match := range matches {
+			queryTags = append(queryTags, string(match[1]))
+		}
+
+		pages, err := b2Client.Scan(lang + "/")
+		status := fiber.StatusOK
+		if err != nil {
+			status = fiber.StatusPartialContent
+			pages = []*b2.BlogPage{}
+		}
+
+		tagsMap := make(map[string]int)
+		for _, page := range pages {
+			slog.Debug("enlist page for catalogue", slog.Any("page", page), slog.String("endpoint", "/"+lang+"/blog"))
+			for _, tag := range page.Metadata.Tags {
+				tagsMap[tag]++
+			}
+		}
+
+		type Tag struct {
+			Name  string `json:"Name" yaml:"name"`
+			Count int    `json:"Count" yaml:"count"`
+		}
+
+		tagsArray := make([]Tag, 0, len(tagsMap))
+		for tag, count := range tagsMap {
+			tagsArray = append(tagsArray, Tag{tag, count})
+		}
+		slices.SortFunc(tagsArray, func(a Tag, b Tag) int {
+			return strings.Compare(a.Name, b.Name)
+		})
+
+		content, err := tm.Render("blog-catalogue", fiber.Map{
+			"QuerySort":     querySort,
+			"QueryTags":     strings.Join(queryTags, ","),
+			"Tags":          tagsArray,
+			"Lang":          lang,
+			"L":             l[lang],
+			"PublishedYear": "2025",
+			"Title":         l[lang].BlogSearch.Header,
+		})
+		if err != nil {
+			slog.Warn("failed to generate page", slog.String("page", "/"+lang+"/blog"), slog.String("error", err.Error()))
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
+		}
+
+		return c.Type("html").Status(status).Send(content)
+	}
+}
diff --git a/internal/router/lang-map.go b/internal/router/lang-map.go
new file mode 100644
index 0000000..8cc070a
--- /dev/null
+++ b/internal/router/lang-map.go
@@ -0,0 +1,82 @@
+package router
+
+import (
+	"fmt"
+	"log/slog"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Lang_Map(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		lang := c.Params("lang")
+		if !slices.Contains(langs, lang) {
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language... yet??", lang))
+		}
+
+		pages, err := b2Client.Scan(lang + "/")
+		status := fiber.StatusOK
+		if err != nil {
+			status = fiber.StatusPartialContent
+			pages = []*b2.BlogPage{}
+		}
+
+		type MapMarker struct {
+			Title          string  `json:"Title"`
+			PageLink       string  `json:"PageLink"`
+			Lat            float64 `json:"Lat"`
+			Long           float64 `json:"Long"`
+			AccuracyMeters int64   `json:"AccuracyMeters"`
+			Thumbnail      string  `json:"Thumbnail"`
+		}
+
+		mapMarkers := make([]*MapMarker, 0, len(pages))
+		for _, page := range pages {
+			geolocationParts := strings.Split(page.Metadata.Geolocation, " ")
+			if len(geolocationParts) < 2 {
+				continue
+			}
+
+			var x, y float64
+			var areaError int64
+			if len(geolocationParts) >= 2 {
+				x, _ = strconv.ParseFloat(geolocationParts[0], 64)
+				y, _ = strconv.ParseFloat(geolocationParts[1], 64)
+			}
+			if len(geolocationParts) >= 3 {
+				areaError, _ = strconv.ParseInt(geolocationParts[2], 10, 64)
+			}
+
+			mapMarkers = append(mapMarkers, &MapMarker{
+				Title:          page.Metadata.Title,
+				PageLink:       fmt.Sprintf("/%s/blog/%s", lang, page.FileName),
+				Lat:            x,
+				Long:           y,
+				AccuracyMeters: areaError,
+				Thumbnail:      page.Metadata.Thumbnail,
+			})
+		}
+
+		content, err := tm.Render("global-map", fiber.Map{
+			"Lang":            lang,
+			"L":               l[lang],
+			"MapLocationLat":  45.4507,
+			"MapLocationLong": 68.8319,
+			"MapMarkers":      mapMarkers,
+		})
+		if err != nil {
+			slog.Warn("failed to generate page", slog.String("page", "/"+lang+"/map"), slog.String("error", err.Error()))
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
+		}
+
+		return c.Type("html").Status(status).Send(content)
+	}
+}
diff --git a/internal/router/root.go b/internal/router/root.go
new file mode 100644
index 0000000..f5be6cb
--- /dev/null
+++ b/internal/router/root.go
@@ -0,0 +1,24 @@
+package router
+
+import (
+	"log/slog"
+
+	"github.com/SayaAndy/saya-today-web/config"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Root(tm *templatemanager.TemplateManager, localeCfg []config.AvailableLanguageConfig) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		content, err := tm.Render("index", fiber.Map{
+			"AvailableLanguages": localeCfg,
+		})
+		if err != nil {
+			slog.Warn("failed to generate page", slog.String("page", "/"), slog.String("error", err.Error()))
+			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
+		}
+
+		return c.Type("html").Send(content)
+	}
+}