]> git.r.bdr.sh - rbdr/mobius/blobdiff - hotline/news.go
git.r.bdr.sh / rbdr / mobius / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Account for the root
[rbdr/mobius] / hotline / news.go
diff --git a/hotline/news.go b/hotline/news.go
index e6b756779886bf8e6c2fabe4bc4cba31b1d03e45..a490a89c39529c2e82e0bacc1da34463f52d1faa 100644 (file)
--- a/hotline/news.go
+++ b/hotline/news.go
@@ -1,36 +1,44 @@
 package hotline
 
 import (
 package hotline
 
 import (
-       "bytes"
-       "crypto/rand"
+       "cmp"
        "encoding/binary"
        "encoding/binary"
+       "github.com/stretchr/testify/mock"
        "io"
        "slices"
        "io"
        "slices"
-       "sort"
 )
 
 )
 
-const defaultNewsDateFormat = "Jan02 15:04" // Jun23 20:49
-
-const defaultNewsTemplate = `From %s (%s):
-
-%s
+var (
+       NewsBundle   = [2]byte{0, 2}
+       NewsCategory = [2]byte{0, 3}
+)
 
 
-__________________________________________________________`
+type ThreadedNewsMgr interface {
+       ListArticles(newsPath []string) NewsArtListData
+       GetArticle(newsPath []string, articleID uint32) *NewsArtData
+       DeleteArticle(newsPath []string, articleID uint32, recursive bool) error
+       PostArticle(newsPath []string, parentArticleID uint32, article NewsArtData) error
+       CreateGrouping(newsPath []string, name string, t [2]byte) error
+       GetCategories(paths []string) []NewsCategoryListData15
+       NewsItem(newsPath []string) NewsCategoryListData15
+       DeleteNewsItem(newsPath []string) error
+}
 
 
+// ThreadedNews contains the top level of threaded news categories, bundles, and articles.
 type ThreadedNews struct {
        Categories map[string]NewsCategoryListData15 `yaml:"Categories"`
 }
 
 type NewsCategoryListData15 struct {
 type ThreadedNews struct {
        Categories map[string]NewsCategoryListData15 `yaml:"Categories"`
 }
 
 type NewsCategoryListData15 struct {
-       Type     [2]byte `yaml:"Type"` // Size 2 ; Bundle (2) or category (3)
-       Count    []byte  // Article or SubCategory count Size 2
-       NameSize byte
-       Name     string                            `yaml:"Name"`     //
+       Type     [2]byte                           `yaml:"Type,flow"` // Bundle (2) or category (3)
+       Name     string                            `yaml:"Name"`
        Articles map[uint32]*NewsArtData           `yaml:"Articles"` // Optional, if Type is Category
        SubCats  map[string]NewsCategoryListData15 `yaml:"SubCats"`
        Articles map[uint32]*NewsArtData           `yaml:"Articles"` // Optional, if Type is Category
        SubCats  map[string]NewsCategoryListData15 `yaml:"SubCats"`
-       GUID     []byte                            // Size 16
-       AddSN    []byte                            // Size 4
-       DeleteSN []byte                            // Size 4
+       GUID     [16]byte                          `yaml:"-"` // What does this do?  Undocumented and seeming unused.
+       AddSN    [4]byte                           `yaml:"-"` // What does this do?  Undocumented and seeming unused.
+       DeleteSN [4]byte                           `yaml:"-"` // What does this do?  Undocumented and seeming unused.
+
+       readOffset int // Internal offset to track read progress
 }
 
 func (newscat *NewsCategoryListData15) GetNewsArtListData() NewsArtListData {
 }
 
 func (newscat *NewsCategoryListData15) GetNewsArtListData() NewsArtListData {
@@ -41,94 +49,101 @@ func (newscat *NewsCategoryListData15) GetNewsArtListData() NewsArtListData {
                id := make([]byte, 4)
                binary.BigEndian.PutUint32(id, i)
 
                id := make([]byte, 4)
                binary.BigEndian.PutUint32(id, i)
 
-               newArt := NewsArtList{
-                       ID:          id,
-                       TimeStamp:   art.Date[:],
-                       ParentID:    art.ParentArt[:],
-                       Flags:       []byte{0, 0, 0, 0},
-                       FlavorCount: []byte{0, 0},
+               newsArts = append(newsArts, NewsArtList{
+                       ID:          [4]byte(id),
+                       TimeStamp:   art.Date,
+                       ParentID:    art.ParentArt,
                        Title:       []byte(art.Title),
                        Poster:      []byte(art.Poster),
                        ArticleSize: art.DataSize(),
                        Title:       []byte(art.Title),
                        Poster:      []byte(art.Poster),
                        ArticleSize: art.DataSize(),
-               }
-               newsArts = append(newsArts, newArt)
+               })
        }
 
        }
 
-       sort.Sort(byID(newsArts))
+       // Sort the articles by ID.  This is important for displaying the message threading correctly on the client side.
+       slices.SortFunc(newsArts, func(a, b NewsArtList) int {
+               return cmp.Compare(
+                       binary.BigEndian.Uint32(a.ID[:]),
+                       binary.BigEndian.Uint32(b.ID[:]),
+               )
+       })
 
        for _, v := range newsArts {
                b, err := io.ReadAll(&v)
                if err != nil {
                        // TODO
 
        for _, v := range newsArts {
                b, err := io.ReadAll(&v)
                if err != nil {
                        // TODO
+                       panic(err)
                }
                newsArtsPayload = append(newsArtsPayload, b...)
        }
 
                }
                newsArtsPayload = append(newsArtsPayload, b...)
        }
 
-       nald := NewsArtListData{
-               ID:          [4]byte{0, 0, 0, 0},
+       return NewsArtListData{
                Count:       len(newsArts),
                Name:        []byte{},
                Description: []byte{},
                NewsArtList: newsArtsPayload,
        }
                Count:       len(newsArts),
                Name:        []byte{},
                Description: []byte{},
                NewsArtList: newsArtsPayload,
        }
-
-       return nald
 }
 
 }
 
-// NewsArtData represents single news article
+// NewsArtData represents an individual news article.
 type NewsArtData struct {
        Title         string  `yaml:"Title"`
        Poster        string  `yaml:"Poster"`
 type NewsArtData struct {
        Title         string  `yaml:"Title"`
        Poster        string  `yaml:"Poster"`
-       Date          [8]byte `yaml:"Date"`             // size 8
-       PrevArt       [4]byte `yaml:"PrevArt"`          // size 4
-       NextArt       [4]byte `yaml:"NextArt"`          // size 4
-       ParentArt     [4]byte `yaml:"ParentArt"`        // size 4
-       FirstChildArt [4]byte `yaml:"FirstChildArtArt"` // size 4
-       DataFlav      []byte  `yaml:"DataFlav"`         // "text/plain"
+       Date          [8]byte `yaml:"Date,flow"`
+       PrevArt       [4]byte `yaml:"PrevArt,flow"`
+       NextArt       [4]byte `yaml:"NextArt,flow"`
+       ParentArt     [4]byte `yaml:"ParentArt,flow"`
+       FirstChildArt [4]byte `yaml:"FirstChildArtArt,flow"`
+       DataFlav      []byte  `yaml:"-"` // MIME type string.  Always "text/plain".
        Data          string  `yaml:"Data"`
 }
 
        Data          string  `yaml:"Data"`
 }
 
-func (art *NewsArtData) DataSize() []byte {
+func (art *NewsArtData) DataSize() [2]byte {
        dataLen := make([]byte, 2)
        binary.BigEndian.PutUint16(dataLen, uint16(len(art.Data)))
 
        dataLen := make([]byte, 2)
        binary.BigEndian.PutUint16(dataLen, uint16(len(art.Data)))
 
-       return dataLen
+       return [2]byte(dataLen)
 }
 
 type NewsArtListData struct {
 }
 
 type NewsArtListData struct {
-       ID          [4]byte `yaml:"ID"` // Size 4
+       ID          [4]byte `yaml:"Type"`
        Name        []byte  `yaml:"Name"`
        Description []byte  `yaml:"Description"` // not used?
        NewsArtList []byte  // List of articles                 Optional (if article count > 0)
        Count       int
        Name        []byte  `yaml:"Name"`
        Description []byte  `yaml:"Description"` // not used?
        NewsArtList []byte  // List of articles                 Optional (if article count > 0)
        Count       int
+
+       readOffset int // Internal offset to track read progress
 }
 
 func (nald *NewsArtListData) Read(p []byte) (int, error) {
        count := make([]byte, 4)
        binary.BigEndian.PutUint32(count, uint32(nald.Count))
 
 }
 
 func (nald *NewsArtListData) Read(p []byte) (int, error) {
        count := make([]byte, 4)
        binary.BigEndian.PutUint32(count, uint32(nald.Count))
 
-       return copy(
-                       p,
-                       slices.Concat(
-                               nald.ID[:],
-                               count,
-                               []byte{uint8(len(nald.Name))},
-                               nald.Name,
-                               []byte{uint8(len(nald.Description))},
-                               nald.Description,
-                               nald.NewsArtList,
-                       ),
-               ),
-               io.EOF
+       buf := slices.Concat(
+               nald.ID[:],
+               count,
+               []byte{uint8(len(nald.Name))},
+               nald.Name,
+               []byte{uint8(len(nald.Description))},
+               nald.Description,
+               nald.NewsArtList,
+       )
+
+       if nald.readOffset >= len(buf) {
+               return 0, io.EOF // All bytes have been read
+       }
+       n := copy(p, buf[nald.readOffset:])
+       nald.readOffset += n
+
+       return n, nil
 }
 
 // NewsArtList is a summarized version of a NewArtData record for display in list view
 type NewsArtList struct {
 }
 
 // NewsArtList is a summarized version of a NewArtData record for display in list view
 type NewsArtList struct {
-       ID          []byte // Size 4
-       TimeStamp   []byte // Year (2 bytes), milliseconds (2 bytes) and seconds (4 bytes)
-       ParentID    []byte // Size 4
-       Flags       []byte // Size 4
-       FlavorCount []byte // Size 2
+       ID          [4]byte
+       TimeStamp   [8]byte // Year (2 bytes), milliseconds (2 bytes) and seconds (4 bytes)
+       ParentID    [4]byte
+       Flags       [4]byte
+       FlavorCount [2]byte
        // Title size   1
        Title []byte // string
        // Poster size  1
        // Title size   1
        Title []byte // string
        // Poster size  1
@@ -136,36 +151,30 @@ type NewsArtList struct {
        Poster     []byte
        FlavorList []NewsFlavorList
        // Flavor list…                       Optional (if flavor count > 0)
        Poster     []byte
        FlavorList []NewsFlavorList
        // Flavor list…                       Optional (if flavor count > 0)
-       ArticleSize []byte // Size 2
+       ArticleSize [2]byte // Size 2
 
        readOffset int // Internal offset to track read progress
 }
 
 
        readOffset int // Internal offset to track read progress
 }
 
-type byID []NewsArtList
-
-func (s byID) Len() int {
-       return len(s)
-}
-func (s byID) Swap(i, j int) {
-       s[i], s[j] = s[j], s[i]
-}
-func (s byID) Less(i, j int) bool {
-       return binary.BigEndian.Uint32(s[i].ID) < binary.BigEndian.Uint32(s[j].ID)
-}
+var (
+       NewsFlavorLen = []byte{0x0a}
+       NewsFlavor    = []byte("text/plain")
+)
 
 func (nal *NewsArtList) Read(p []byte) (int, error) {
        out := slices.Concat(
 
 func (nal *NewsArtList) Read(p []byte) (int, error) {
        out := slices.Concat(
-               nal.ID,
-               nal.TimeStamp,
-               nal.ParentID,
-               nal.Flags,
-               []byte{0, 1},
+               nal.ID[:],
+               nal.TimeStamp[:],
+               nal.ParentID[:],
+               nal.Flags[:],
+               []byte{0, 1}, // Flavor Count TODO: make this not hardcoded
                []byte{uint8(len(nal.Title))},
                nal.Title,
                []byte{uint8(len(nal.Poster))},
                nal.Poster,
                []byte{uint8(len(nal.Title))},
                nal.Title,
                []byte{uint8(len(nal.Poster))},
                nal.Poster,
-               []byte{0x0a, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c, 0x61, 0x69, 0x6e},
-               nal.ArticleSize,
+               NewsFlavorLen,
+               NewsFlavor,
+               nal.ArticleSize[:],
        )
 
        if nal.readOffset >= len(out) {
        )
 
        if nal.readOffset >= len(out) {
@@ -184,59 +193,97 @@ type NewsFlavorList struct {
        // Article size 2
 }
 
        // Article size 2
 }
 
-func (newscat *NewsCategoryListData15) MarshalBinary() (data []byte, err error) {
+func (newscat *NewsCategoryListData15) Read(p []byte) (int, error) {
        count := make([]byte, 2)
        binary.BigEndian.PutUint16(count, uint16(len(newscat.Articles)+len(newscat.SubCats)))
 
        count := make([]byte, 2)
        binary.BigEndian.PutUint16(count, uint16(len(newscat.Articles)+len(newscat.SubCats)))
 
-       out := append(newscat.Type[:], count...)
-
-       if bytes.Equal(newscat.Type[:], []byte{0, 3}) {
-               // Generate a random GUID // TODO: does this need to be random?
-               b := make([]byte, 16)
-               _, err := rand.Read(b)
-               if err != nil {
-                       return data, err
-               }
+       out := slices.Concat(
+               newscat.Type[:],
+               count,
+       )
+       if newscat.Type == NewsCategory {
+               out = slices.Concat(out,
+                       newscat.GUID[:],
+                       newscat.AddSN[:],
+                       newscat.DeleteSN[:],
+               )
+       }
+       out = slices.Concat(out,
+               newscat.nameLen(),
+               []byte(newscat.Name),
+       )
 
 
-               out = append(out, b...)                  // GUID
-               out = append(out, []byte{0, 0, 0, 1}...) // Add SN (TODO: not sure what this is)
-               out = append(out, []byte{0, 0, 0, 2}...) // Delete SN (TODO: not sure what this is)
+       if newscat.readOffset >= len(out) {
+               return 0, io.EOF // All bytes have been read
        }
 
        }
 
-       out = append(out, newscat.nameLen()...)
-       out = append(out, []byte(newscat.Name)...)
+       n := copy(p, out)
+
+       newscat.readOffset = n
 
 
-       return out, err
+       return n, nil
 }
 
 func (newscat *NewsCategoryListData15) nameLen() []byte {
        return []byte{uint8(len(newscat.Name))}
 }
 
 }
 
 func (newscat *NewsCategoryListData15) nameLen() []byte {
        return []byte{uint8(len(newscat.Name))}
 }
 
-// TODO: re-implement as bufio.Scanner interface
-func ReadNewsPath(newsPath []byte) []string {
-       if len(newsPath) == 0 {
-               return []string{}
+// newsPathScanner implements bufio.SplitFunc for parsing incoming byte slices into complete tokens
+func newsPathScanner(data []byte, _ bool) (advance int, token []byte, err error) {
+       if len(data) < 3 {
+               return 0, nil, nil
        }
        }
-       pathCount := binary.BigEndian.Uint16(newsPath[0:2])
 
 
-       pathData := newsPath[2:]
-       var paths []string
+       advance = 3 + int(data[2])
+       return advance, data[3:advance], nil
+}
 
 
-       for i := uint16(0); i < pathCount; i++ {
-               pathLen := pathData[2]
-               paths = append(paths, string(pathData[3:3+pathLen]))
+type MockThreadNewsMgr struct {
+       mock.Mock
+}
 
 
-               pathData = pathData[pathLen+3:]
-       }
+func (m *MockThreadNewsMgr) ListArticles(newsPath []string) NewsArtListData {
+       args := m.Called(newsPath)
 
 
-       return paths
+       return args.Get(0).(NewsArtListData)
 }
 
 }
 
-func (s *Server) GetNewsCatByPath(paths []string) map[string]NewsCategoryListData15 {
-       cats := s.ThreadedNews.Categories
-       for _, path := range paths {
-               cats = cats[path].SubCats
-       }
-       return cats
+func (m *MockThreadNewsMgr) GetArticle(newsPath []string, articleID uint32) *NewsArtData {
+       args := m.Called(newsPath, articleID)
+
+       return args.Get(0).(*NewsArtData)
+}
+func (m *MockThreadNewsMgr) DeleteArticle(newsPath []string, articleID uint32, recursive bool) error {
+       args := m.Called(newsPath, articleID, recursive)
+
+       return args.Error(0)
+}
+
+func (m *MockThreadNewsMgr) PostArticle(newsPath []string, parentArticleID uint32, article NewsArtData) error {
+       args := m.Called(newsPath, parentArticleID, article)
+
+       return args.Error(0)
+}
+func (m *MockThreadNewsMgr) CreateGrouping(newsPath []string, name string, itemType [2]byte) error {
+       args := m.Called(newsPath, name, itemType)
+
+       return args.Error(0)
+}
+
+func (m *MockThreadNewsMgr) GetCategories(paths []string) []NewsCategoryListData15 {
+       args := m.Called(paths)
+
+       return args.Get(0).([]NewsCategoryListData15)
+}
+
+func (m *MockThreadNewsMgr) NewsItem(newsPath []string) NewsCategoryListData15 {
+       args := m.Called(newsPath)
+
+       return args.Get(0).(NewsCategoryListData15)
+}
+
+func (m *MockThreadNewsMgr) DeleteNewsItem(newsPath []string) error {
+       args := m.Called(newsPath)
+
+       return args.Error(0)
 }
 }
Friendship Quest remix of mobius, a hotline server in go #cli