v0.7.0 (#6)v0.7.0

feat: like button with persistent storage and like count
feat: show like count on blog search
feat: update galleries on resize (with smooth animations)
feat: add decor for night & ram themes
feat: show search buttons in catalogue separately without overflow
feat: add overflow to search tags in catalogue in mobile mode
feat: update go (1.24.5 > 1.24.6)
feat: add favicon
refactor: shorten logs of blog search

6 files changed, 384 insertions, 26 deletions

diff --git a/internal/lightgallery/html_renderer.go b/internal/lightgallery/html_renderer.go
index e20e9ec..17a6f2b 100644
--- a/internal/lightgallery/html_renderer.go
+++ b/internal/lightgallery/html_renderer.go
@@ -92,32 +92,35 @@ func (r *LightGalleryHTMLRenderer) renderLightGallery(w util.BufWriter, source [
 		w.WriteString(fmt.Sprintf(`
 <script>
 function createLightGallery%s() {
-		const $lgContainer = document.getElementById('lg-%s');
-        const inlineGallery = lightGallery($lgContainer, {
-			container: $lgContainer,
-			dynamic: true,
-			dynamicEl: [%s],
-			width: "100%%",
-            height: "50vmin",
-			hash: false,
-			closable: false,
-			showMaximizeIcon: true,
-			appendSubHtmlTo: ".lg-sub-html",
-            isMobile: () => false,
-			slideDelay: 0,
-			plugins: [lgZoom, lgThumbnail],
-			thumbWidth: calculateVmin(10),
-			thumbHeight: "10vmin",
-			thumbMargin: 4
-        });
+	const $lgContainer = document.getElementById('lg-%s');
+	const config = {
+		container: $lgContainer,
+		dynamic: true,
+		dynamicEl: [%s],
+		width: "100%%",
+		height: "50vmin",
+		hash: false,
+		closable: false,
+		showMaximizeIcon: true,
+		appendSubHtmlTo: ".lg-sub-html",
+		isMobile: () => false,
+		slideDelay: 0,
+		plugins: [lgZoom, lgThumbnail],
+		thumbWidth: calculateVmin(10),
+		thumbHeight: "10vmin",
+		thumbMargin: 4
+	};
+	const inlineGallery = lightGallery($lgContainer, config);
 
-		setTimeout(() => {
-			inlineGallery.openGallery();
-		}, 200);
+	setTimeout(() => {
+		inlineGallery.openGallery();
+	}, 200);
+
+	galleryMap.set(inlineGallery, createLightGallery%s);
 }
 
 document.addEventListener('DOMContentLoaded', createLightGallery%s);
-</script>`, galleryID, galleryID, strings.Join(dynamicElements, ","), galleryID))
+</script>`, galleryID, galleryID, strings.Join(dynamicElements, ","), galleryID, galleryID))
 	}
 
 	return ast.WalkContinue, nil
diff --git a/internal/router/api-v1-blog-search.go b/internal/router/api-v1-blog-search.go
index 51ace85..e22fabe 100644
--- a/internal/router/api-v1-blog-search.go
+++ b/internal/router/api-v1-blog-search.go
@@ -48,7 +48,7 @@ func Api_V1_BlogSearch(l map[string]*locale.LocaleConfig, langs []string, b2Clie
 			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))
+		decodedQuery, _ := url.QueryUnescape(string(encodedQuery))
 		matches := re.FindAllStringSubmatch(decodedQuery, -1)
 
 		tags := make([]string, 0, len(matches))
@@ -69,6 +69,7 @@ func Api_V1_BlogSearch(l map[string]*locale.LocaleConfig, langs []string, b2Clie
 						"ShortDescription": page.Metadata.ShortDescription,
 						"Thumbnail":        page.Metadata.Thumbnail,
 						"Tags":             page.Metadata.Tags,
+						"LikeCount":        CCache.GetLikeCount(page.FileName),
 					})
 					break
 				}
diff --git a/internal/router/api-v1-like.go b/internal/router/api-v1-like.go
new file mode 100644
index 0000000..327dafa
--- /dev/null
+++ b/internal/router/api-v1-like.go
@@ -0,0 +1,122 @@
+package router
+
+import (
+	"fmt"
+	"log/slog"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+)
+
+func init() {
+	tm.Add("blog-page-like-button", "views/partials/blog-page-like-button.html")
+}
+
+func Api_V1_Like_Put(l map[string]*locale.LocaleConfig, b2 *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+
+		referer := c.Get("Referer", "")
+		if referer == "" {
+			return c.Status(fiber.ErrBadRequest.Code).SendString("'Referer' header is empty")
+		}
+		urlStruct, err := url.ParseRequestURI(referer)
+		if err != nil {
+			return c.Status(fiber.ErrBadRequest.Code).SendString(fmt.Sprintf("'Referer' header is invalid: %s", err.Error()))
+		}
+
+		path := urlStruct.EscapedPath()
+		pathParts := strings.Split(strings.Trim(path, "/"), "/")
+		if len(pathParts) != 3 {
+			return c.Status(fiber.ErrBadRequest.Code).SendString("'Referer' header is invalid: expect format '/{lang}/blog/{page}'")
+		}
+
+		lang, page := pathParts[0], pathParts[2]
+
+		pageLink := lang + "/" + page + ".md"
+		if pages, _ := b2.Scan(pageLink); len(pages) == 0 {
+			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server did not find '%s' article", pageLink))
+		}
+
+		newLikeStatus, err := strconv.ParseBool(c.FormValue("like", "true"))
+		if err != nil {
+			return c.Status(fiber.ErrBadRequest.Code).SendString("invalid 'like' value")
+		}
+
+		ip := c.IP()
+		if newLikeStatus {
+			CCache.LikeOn(ip, page)
+		} else {
+			CCache.LikeOff(ip, page)
+		}
+
+		slog.Debug("someone pressed the like button!", slog.String("ip", ip), slog.String("page", page), slog.String("new_like_status", fmt.Sprint(newLikeStatus)))
+		if c.Get("HX-Request", "false") == "true" {
+			content, err := tm.Render("blog-page-like-button", fiber.Map{
+				"L":          l[lang],
+				"Liked":      newLikeStatus,
+				"LikedCount": CCache.GetLikeCount(page),
+			})
+			if err != nil {
+				slog.Warn("failed to generate div", slog.String("path", path), slog.String("error", err.Error()))
+				return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate div")
+			}
+			c.Set(fiber.HeaderContentType, fiber.MIMETextHTMLCharsetUTF8)
+			return c.Status(fiber.StatusOK).Send(content)
+		}
+
+		return c.Status(fiber.StatusOK).SendString(fmt.Sprint(newLikeStatus))
+	}
+}
+
+func Api_V1_Like_Get(l map[string]*locale.LocaleConfig, b2 *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
+
+		referer := c.Get("Referer", "")
+		if referer == "" {
+			return c.Status(fiber.ErrBadRequest.Code).SendString("'Referer' header is empty")
+		}
+		urlStruct, err := url.ParseRequestURI(referer)
+		if err != nil {
+			return c.Status(fiber.ErrBadRequest.Code).SendString(fmt.Sprintf("'Referer' header is invalid: %s", err.Error()))
+		}
+
+		path := urlStruct.EscapedPath()
+		pathParts := strings.Split(strings.Trim(path, "/"), "/")
+		if len(pathParts) != 3 {
+			return c.Status(fiber.ErrBadRequest.Code).SendString("'Referer' header is invalid: expect format '/{lang}/blog/{page}'")
+		}
+
+		lang, page := pathParts[0], pathParts[2]
+
+		pageLink := lang + "/" + page + ".md"
+		if pages, _ := b2.Scan(pageLink); len(pages) == 0 {
+			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server did not find '%s' article", pageLink))
+		}
+
+		ip := c.IP()
+		likeStatus := CCache.GetLikeStatus(ip, page)
+
+		slog.Debug("someone requested the like status!", slog.String("ip", ip), slog.String("page", page), slog.Bool("like_status", likeStatus))
+		if c.Get("HX-Request", "false") == "true" {
+			content, err := tm.Render("blog-page-like-button", fiber.Map{
+				"L":          l[lang],
+				"Liked":      likeStatus,
+				"LikedCount": CCache.GetLikeCount(page),
+			})
+			if err != nil {
+				slog.Warn("failed to generate div", slog.String("path", path), slog.String("error", err.Error()))
+				return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate div")
+			}
+			c.Set(fiber.HeaderContentType, fiber.MIMETextHTMLCharsetUTF8)
+			return c.Status(fiber.StatusOK).Send(content)
+		}
+
+		return c.Status(fiber.StatusOK).SendString(fmt.Sprint(likeStatus))
+	}
+}
diff --git a/internal/router/client-cache.go b/internal/router/client-cache.go
new file mode 100644
index 0000000..81d7641
--- /dev/null
+++ b/internal/router/client-cache.go
@@ -0,0 +1,229 @@
+package router
+
+import (
+	"database/sql"
+	"encoding/base64"
+	"fmt"
+	"log/slog"
+	"strings"
+	"sync"
+
+	"golang.org/x/crypto/argon2"
+)
+
+type PageLike struct {
+	PageRef string
+	UserId  string
+}
+
+type ClientCache struct {
+	hashMap      map[string]string
+	hashMapMutex sync.RWMutex
+
+	likePageMap       map[string]map[string]struct{}
+	pageMutexMap      map[string]*sync.RWMutex
+	pageMutexMapMutex sync.Mutex
+
+	salt []byte
+	db   *sql.DB
+}
+
+var CCache *ClientCache
+
+func NewClientCache(db *sql.DB, salt []byte) (*ClientCache, error) {
+	tx, err := db.Begin()
+	if err != nil {
+		return nil, fmt.Errorf("fail to init transaction with db to fill cache: %w", err)
+	}
+
+	rows, err := tx.Query("select * from blog_likes;")
+	if err != nil {
+		tx.Rollback()
+		return nil, fmt.Errorf("fail to query db for blog_likes to fill cache: %w", err)
+	}
+
+	likePageMap := make(map[string]map[string]struct{})
+	pageMutexMap := make(map[string]*sync.RWMutex)
+
+	for rows.Next() {
+		var pageRef string
+		var userId []byte
+		if err = rows.Scan(&pageRef, &userId); err != nil {
+			tx.Rollback()
+			return nil, fmt.Errorf("fail scanning blog_likes to fill cache: %w", err)
+		}
+		userIdString := base64.RawStdEncoding.EncodeToString(userId)
+		if _, ok := likePageMap[pageRef]; !ok {
+			likePageMap[pageRef] = make(map[string]struct{})
+			pageMutexMap[pageRef] = &sync.RWMutex{}
+		}
+		likePageMap[pageRef][userIdString] = struct{}{}
+	}
+
+	if err = tx.Commit(); err != nil {
+		return nil, fmt.Errorf("fail to commit transaction in db: %w", err)
+	}
+
+	return &ClientCache{
+		hashMap:      make(map[string]string),
+		likePageMap:  likePageMap,
+		pageMutexMap: pageMutexMap,
+		salt:         salt,
+		db:           db,
+	}, nil
+}
+
+func (c *ClientCache) Close() error {
+	tx, err := c.db.Begin()
+	if err != nil {
+		return fmt.Errorf("fail to init transaction with db to dump cache: %w", err)
+	}
+
+	if _, err = tx.Exec("delete from blog_likes;"); err != nil {
+		tx.Rollback()
+		return fmt.Errorf("fail to truncate table blog_likes: %w", err)
+	}
+
+	userIdBytes := make(map[string][]byte)
+
+	sqlStatement := fmt.Sprintf(`
+    INSERT OR IGNORE INTO blog_likes (page_ref, user_id)
+    VALUES %s(?, ?);
+    `, strings.Repeat("(?, ?), ", 99))
+	sqlStatementVars := make([]any, 0, 200)
+
+	for pageRef, userSet := range c.likePageMap {
+		for userId := range userSet {
+			if _, ok := userIdBytes[userId]; !ok {
+				userIdBytes[userId], err = base64.RawStdEncoding.DecodeString(userId)
+				if err != nil {
+					slog.Warn("couldn't parse one of user hashes into bytes back", slog.String("hash", userId), slog.String("error", err.Error()))
+					continue
+				}
+			}
+
+			sqlStatementVars = append(sqlStatementVars, any(pageRef), any(userIdBytes[userId]))
+			if len(sqlStatementVars) < 200 {
+				continue
+			}
+
+			if _, err := tx.Exec(sqlStatement, sqlStatementVars...); err != nil {
+				slog.Warn("couldn't insert blog like pairs into db", slog.String("error", err.Error()))
+			}
+
+			sqlStatementVars = make([]any, 0, 200)
+		}
+	}
+
+	if len(sqlStatementVars) > 0 {
+		sqlStatement = fmt.Sprintf(`
+		INSERT OR IGNORE INTO blog_likes (page_ref, user_id)
+		VALUES %s(?, ?);
+		`, strings.Repeat("(?, ?), ", len(sqlStatementVars)/2-1))
+
+		if _, err := tx.Exec(sqlStatement, sqlStatementVars...); err != nil {
+			slog.Warn("couldn't insert blog like pairs into db", slog.String("error", err.Error()))
+		}
+	}
+
+	return tx.Commit()
+}
+
+func (c *ClientCache) GetHash(id string) string {
+	c.hashMapMutex.RLock()
+	if val, ok := c.hashMap[id]; ok {
+		c.hashMapMutex.RUnlock()
+		slog.Debug("gave an old hash", slog.String("hash", val))
+		return val
+	}
+	c.hashMapMutex.RUnlock()
+
+	c.hashMapMutex.Lock()
+	defer c.hashMapMutex.Unlock()
+
+	if val, ok := c.hashMap[id]; ok {
+		slog.Debug("gave a newly generated hash", slog.String("hash", val))
+		return val
+	}
+
+	c.hashMap[id] = base64.RawStdEncoding.EncodeToString(argon2.IDKey([]byte(id), c.salt, 1, 64*1024, 4, 32))
+	slog.Debug("generated hash", slog.String("hash", c.hashMap[id]))
+	return c.hashMap[id]
+}
+
+func (c *ClientCache) getPageMutex(page string) *sync.RWMutex {
+	c.pageMutexMapMutex.Lock()
+	defer c.pageMutexMapMutex.Unlock()
+
+	if mutex, ok := c.pageMutexMap[page]; ok {
+		return mutex
+	}
+
+	c.pageMutexMap[page] = &sync.RWMutex{}
+	return c.pageMutexMap[page]
+}
+
+func (c *ClientCache) GetLikeStatus(id string, page string) bool {
+	page = strings.Clone(page)
+
+	mutex := c.getPageMutex(page)
+	mutex.RLock()
+	defer mutex.RUnlock()
+
+	if _, ok := c.likePageMap[page]; !ok {
+		return false
+	}
+	_, ok := c.likePageMap[page][c.GetHash(id)]
+	return ok
+}
+
+func (c *ClientCache) GetLikeCount(page string) int {
+	page = strings.Clone(page)
+
+	mutex := c.getPageMutex(page)
+	mutex.RLock()
+	defer mutex.RUnlock()
+
+	if userSet, ok := c.likePageMap[page]; ok {
+		return len(userSet)
+	}
+	return 0
+}
+
+func (c *ClientCache) LikeOn(id string, page string) (alreadyLiked bool) {
+	page = strings.Clone(page)
+	hash := c.GetHash(id)
+
+	mutex := c.getPageMutex(page)
+	mutex.Lock()
+	defer mutex.Unlock()
+
+	if userSet, ok := c.likePageMap[page]; ok {
+		_, alreadyLiked = userSet[hash]
+		c.likePageMap[page][hash] = struct{}{}
+		return
+	}
+
+	c.likePageMap[page] = make(map[string]struct{})
+	c.likePageMap[page][hash] = struct{}{}
+	return
+}
+
+func (c *ClientCache) LikeOff(id string, page string) (alreadyUnliked bool) {
+	page = strings.Clone(page)
+	hash := c.GetHash(id)
+
+	mutex := c.getPageMutex(page)
+	mutex.Lock()
+	defer mutex.Unlock()
+
+	if _, ok := c.likePageMap[page]; !ok {
+		return true
+	}
+	if _, ok := c.likePageMap[page][hash]; !ok {
+		return true
+	}
+
+	delete(c.likePageMap[page], hash)
+	return false
+}
diff --git a/internal/router/lang-blog-title.go b/internal/router/lang-blog-title.go
index b7b5d7e..bafb0d2 100644
--- a/internal/router/lang-blog-title.go
+++ b/internal/router/lang-blog-title.go
@@ -22,6 +22,9 @@ func init() {
 
 func Lang_Blog_Title(l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client, md goldmark.Markdown) func(c *fiber.Ctx) error {
 	return func(c *fiber.Ctx) error {
+		ip := c.IP()
+		slog.Debug("client entering blog page", slog.String("ip", ip), slog.String("page", c.Path()))
+
 		lang := c.Params("lang")
 		if !slices.Contains(langs, lang) {
 			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
diff --git a/internal/router/lang-blog.go b/internal/router/lang-blog.go
index 650c4b1..dd3f079 100644
--- a/internal/router/lang-blog.go
+++ b/internal/router/lang-blog.go
@@ -37,7 +37,7 @@ func Lang_Blog(l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B
 			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))
+		decodedQuery, _ := url.QueryUnescape(string(encodedQuery))
 		matches := re.FindAllStringSubmatch(decodedQuery, -1)
 
 		queryTags := make([]string, 0, len(matches))
@@ -54,11 +54,11 @@ func Lang_Blog(l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B
 
 		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]++
 			}
 		}
+		slog.Debug("enlist pages for catalogue", slog.Int("tag_count", len(tagsMap)), slog.Int("page_count", len(pages)), slog.String("path", c.Path()))
 
 		type Tag struct {
 			Name  string `json:"Name" yaml:"name"`
@@ -83,7 +83,7 @@ func Lang_Blog(l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B
 			"Title":         l[lang].BlogSearch.Header,
 		})
 		if err != nil {
-			slog.Warn("failed to generate page", slog.String("page", "/"+lang+"/blog"), slog.String("error", err.Error()))
+			slog.Warn("failed to generate page", slog.String("path", c.Path()), slog.String("error", err.Error()))
 			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
 			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
 		}