src

entry.go (3076B)

---

 package entry
 
 import (
 	"embed"
 	"encoding/json"
 	"fmt"
 	"html/template"
 	"io/fs"
 	"path/filepath"
 	"sort"
 	"time"
 
 	"code.dwrz.net/src/pkg/log"
 )
 
 //go:embed static/*
 var static embed.FS
 
 const (
 	YearFormat   = "2006"
 	DateFormat   = "2006-01-02"
 	metadataFile = "metadata.json"
 )
 
 type Entry struct {
 	Cover     string        `json:"cover"`
 	Content   template.HTML `json:"content"`
 	Date      time.Time     `json:"date"`
 	Link      string        `json:"link"`
 	Next      *Entry        `json:"next"`
 	Previous  *Entry        `json:"previous"`
 	Published bool          `json:"published"`
 	Title     string        `json:"title"`
 }
 
 type Year struct {
 	Entries []*Entry
 	Text    string
 }
 
 type LoadParams struct {
 	Log *log.Logger
 }
 
 func Load(p LoadParams) ([]*Entry, error) {
 	var entries []*Entry
 
 	parseFS := func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
 		if !d.IsDir() || d.Name() == "static" {
 			return nil
 		}
 
 		// Open the entry metadata file.
 		data, err := static.ReadFile(
 			filepath.Join("static", d.Name(), metadataFile),
 		)
 		if err != nil {
 			p.Log.Error.Printf("ignoring %s: %v", d.Name(), err)
 			return nil
 		}
 
 		var entry = &Entry{}
 		if err := json.Unmarshal(data, entry); err != nil {
 			p.Log.Error.Printf("ignoring %s: %v", d.Name(), err)
 			return nil
 		}
 
 		// Ignore unpublished entries.
 		if !entry.Published {
 			p.Log.Debug.Printf(
 				"ignoring %s: not published", d.Name(),
 			)
 			return nil
 		}
 
 		// Get the entry content.
 		entryFile := d.Name() + ".html"
 		content, err := static.ReadFile(
 			filepath.Join("static", d.Name(), entryFile),
 		)
 		if err != nil {
 			p.Log.Error.Printf("ignoring %s: %v", d.Name(), err)
 			return nil
 		}
 
 		// Set entry values.
 		entry.Content = template.HTML(string(content))
 		entry.Link = fmt.Sprintf("%s", entry.Date.Format(DateFormat))
 
 		entries = append(entries, entry)
 
 		return nil
 	}
 
 	if err := fs.WalkDir(static, "static", parseFS); err != nil {
 		return nil, fmt.Errorf("failed to parse templates: %v", err)
 	}
 
 	// Sort the entries.
 	sort.Slice(entries, func(i, j int) bool {
 		return entries[i].Date.Before(entries[j].Date)
 	})
 
 	// Set the previous and next entry.
 	for i, e := range entries {
 		if i-1 >= 0 {
 			e.Previous = entries[i-1]
 		}
 		if i+1 < len(entries) {
 			e.Next = entries[i+1]
 		}
 	}
 
 	return entries, nil
 }
 
 func SortYear(entries []*Entry) []Year {
 	var yearEntries = map[string]*Year{}
 	for _, e := range entries {
 		year := e.Date.Format(YearFormat)
 		if _, exists := yearEntries[year]; !exists {
 			yearEntries[year] = &Year{
 				Entries: []*Entry{e},
 				Text:    year,
 			}
 			continue
 		}
 
 		yearEntries[year].Entries = append(yearEntries[year].Entries, e)
 	}
 
 	// Sort each year's entries, then sort the years.
 	var years = []Year{}
 	for _, year := range yearEntries {
 		sort.Slice(year.Entries, func(i, j int) bool {
 			return year.Entries[i].Date.After(year.Entries[j].Date)
 		})
 
 		years = append(years, *year)
 	}
 	sort.Slice(years, func(i, j int) bool {
 		return years[i].Text > years[j].Text
 	})
 
 	return years
 }