git.r.bdr.sh - rbdr/mobius/blob - internal/mobius/threaded_news.go

   1 package mobius
   2
   3 import (
   4         "cmp"
   5         "encoding/binary"
   6         "fmt"
   7         "github.com/jhalter/mobius/hotline"
   8         "gopkg.in/yaml.v3"
   9         "os"
  10         "slices"
  11         "sort"
  12         "sync"
  13 )
  14
  15 type ThreadedNewsYAML struct {
  16         ThreadedNews hotline.ThreadedNews
  17
  18         filePath string
  19
  20         mu sync.Mutex
  21 }
  22
  23 func NewThreadedNewsYAML(filePath string) (*ThreadedNewsYAML, error) {
  24         tn := &ThreadedNewsYAML{filePath: filePath}
  25
  26         err := tn.Load()
  27
  28         return tn, err
  29 }
  30
  31 func (n *ThreadedNewsYAML) CreateGrouping(newsPath []string, name string, t [2]byte) error {
  32         n.mu.Lock()
  33         defer n.mu.Unlock()
  34
  35         cats := n.getCatByPath(newsPath)
  36         cats[name] = hotline.NewsCategoryListData15{
  37                 Name:     name,
  38                 Type:     t,
  39                 Articles: map[uint32]*hotline.NewsArtData{},
  40                 SubCats:  make(map[string]hotline.NewsCategoryListData15),
  41         }
  42
  43         return n.writeFile()
  44 }
  45
  46 func (n *ThreadedNewsYAML) NewsItem(newsPath []string) hotline.NewsCategoryListData15 {
  47         n.mu.Lock()
  48         defer n.mu.Unlock()
  49
  50         cats := n.ThreadedNews.Categories
  51         delName := newsPath[len(newsPath)-1]
  52         if len(newsPath) > 1 {
  53                 for _, fp := range newsPath[0 : len(newsPath)-1] {
  54                         cats = cats[fp].SubCats
  55                 }
  56         }
  57
  58         return cats[delName]
  59 }
  60
  61 func (n *ThreadedNewsYAML) DeleteNewsItem(newsPath []string) error {
  62         n.mu.Lock()
  63         defer n.mu.Unlock()
  64
  65         cats := n.ThreadedNews.Categories
  66         delName := newsPath[len(newsPath)-1]
  67         if len(newsPath) > 1 {
  68                 for _, fp := range newsPath[0 : len(newsPath)-1] {
  69                         cats = cats[fp].SubCats
  70                 }
  71         }
  72
  73         delete(cats, delName)
  74
  75         return n.writeFile()
  76 }
  77
  78 func (n *ThreadedNewsYAML) GetArticle(newsPath []string, articleID uint32) *hotline.NewsArtData {
  79         n.mu.Lock()
  80         defer n.mu.Unlock()
  81
  82         var cat hotline.NewsCategoryListData15
  83         cats := n.ThreadedNews.Categories
  84
  85         for _, fp := range newsPath {
  86                 cat = cats[fp]
  87                 cats = cats[fp].SubCats
  88         }
  89
  90         art := cat.Articles[articleID]
  91         if art == nil {
  92                 return nil
  93         }
  94
  95         return art
  96 }
  97
  98 func (n *ThreadedNewsYAML) GetCategories(paths []string) []hotline.NewsCategoryListData15 {
  99         n.mu.Lock()
 100         defer n.mu.Unlock()
 101
 102         var categories []hotline.NewsCategoryListData15
 103         for _, c := range n.getCatByPath(paths) {
 104                 categories = append(categories, c)
 105         }
 106
 107         slices.SortFunc(categories, func(a, b hotline.NewsCategoryListData15) int {
 108                 return cmp.Compare(
 109                         a.Name,
 110                         b.Name,
 111                 )
 112         })
 113
 114         return categories
 115 }
 116
 117 func (n *ThreadedNewsYAML) getCatByPath(paths []string) map[string]hotline.NewsCategoryListData15 {
 118         cats := n.ThreadedNews.Categories
 119         for _, path := range paths {
 120                 cats = cats[path].SubCats
 121         }
 122
 123         return cats
 124 }
 125
 126 func (n *ThreadedNewsYAML) PostArticle(newsPath []string, parentArticleID uint32, article hotline.NewsArtData) error {
 127         n.mu.Lock()
 128         defer n.mu.Unlock()
 129
 130         binary.BigEndian.PutUint32(article.ParentArt[:], parentArticleID)
 131
 132         cats := n.getCatByPath(newsPath[:len(newsPath)-1])
 133
 134         catName := newsPath[len(newsPath)-1]
 135         cat := cats[catName]
 136
 137         var keys []int
 138         for k := range cat.Articles {
 139                 keys = append(keys, int(k))
 140         }
 141
 142         nextID := uint32(1)
 143         if len(keys) > 0 {
 144                 sort.Ints(keys)
 145                 prevID := uint32(keys[len(keys)-1])
 146                 nextID = prevID + 1
 147
 148                 binary.BigEndian.PutUint32(article.PrevArt[:], prevID)
 149
 150                 // Set next article Type
 151                 binary.BigEndian.PutUint32(cat.Articles[prevID].NextArt[:], nextID)
 152         }
 153
 154         // Update parent article with first child reply
 155         parentID := parentArticleID
 156         if parentID != 0 {
 157                 parentArt := cat.Articles[parentID]
 158
 159                 if parentArt.FirstChildArt == [4]byte{0, 0, 0, 0} {
 160                         binary.BigEndian.PutUint32(parentArt.FirstChildArt[:], nextID)
 161                 }
 162         }
 163
 164         cat.Articles[nextID] = &article
 165
 166         cats[catName] = cat
 167
 168         return n.writeFile()
 169 }
 170
 171 func (n *ThreadedNewsYAML) DeleteArticle(newsPath []string, articleID uint32, _ bool) error {
 172         n.mu.Lock()
 173         defer n.mu.Unlock()
 174
 175         //if recursive {
 176         //      // TODO: Handle delete recursive
 177         //}
 178
 179         cats := n.getCatByPath(newsPath[:len(newsPath)-1])
 180
 181         catName := newsPath[len(newsPath)-1]
 182
 183         cat := cats[catName]
 184         delete(cat.Articles, articleID)
 185         cats[catName] = cat
 186
 187         return n.writeFile()
 188 }
 189
 190 func (n *ThreadedNewsYAML) ListArticles(newsPath []string) hotline.NewsArtListData {
 191         n.mu.Lock()
 192         defer n.mu.Unlock()
 193
 194         var cat hotline.NewsCategoryListData15
 195         cats := n.ThreadedNews.Categories
 196
 197         for _, fp := range newsPath {
 198                 cat = cats[fp]
 199                 cats = cats[fp].SubCats
 200         }
 201
 202         return cat.GetNewsArtListData()
 203 }
 204
 205 func (n *ThreadedNewsYAML) Load() error {
 206         n.mu.Lock()
 207         defer n.mu.Unlock()
 208
 209         fh, err := os.Open(n.filePath)
 210         if err != nil {
 211                 return err
 212         }
 213         defer fh.Close()
 214
 215         n.ThreadedNews = hotline.ThreadedNews{}
 216
 217         return yaml.NewDecoder(fh).Decode(&n.ThreadedNews)
 218 }
 219
 220 func (n *ThreadedNewsYAML) writeFile() error {
 221         out, err := yaml.Marshal(&n.ThreadedNews)
 222         if err != nil {
 223                 return err
 224         }
 225
 226         // Define a temporary file path in the same directory.
 227         tempFilePath := n.filePath + ".tmp"
 228
 229         // Write the marshaled YAML to the temporary file.
 230         if err := os.WriteFile(tempFilePath, out, 0644); err != nil {
 231                 return fmt.Errorf("write to temporary file: %v", err)
 232         }
 233
 234         // Atomically rename the temporary file to the final file path.
 235         if err := os.Rename(tempFilePath, n.filePath); err != nil {
 236                 return fmt.Errorf("rename temporary file to final file: %v", err)
 237         }
 238
 239         return nil
 240 }