work in progress: storage: Messages

storage/message/message.go

@@ -3,18 +3,32 @@ package message
 import (
 	lib "git.sr.ht/~cco/go-scopes"
 	sql "git.sr.ht/~cco/go-scopes/storage"
+	"git.sr.ht/~cco/go-scopes/storage/tracking"
 )
 
+func Messages(db *sql.Storage) *tracking.Container {
+	return &tracking.Container{
+		TableName:  "messages",
+		HeadFields: []string{"domain", "action", "class", "item"},
+		Indexes: [][]string{
+			[]string{"domain", "action", "class", "item"},
+			[]string{"domain", "class", "item"},
+		},
+		Storage: db,
+	}
+}
+
+// message store action handler
+
 func Store(act lib.Action) bool {
 	db := lib.GetState[*sql.Storage](act.Context())
 	StoreDB(db, act.Message())
 	return true
 }
 
-// var Store = func(db *sql.Storage, msg lib.Message) {
 func StoreDB(db *sql.Storage, msg lib.Message) {
-	q := db.BuildQuery("insert_msg", "messages")
+	//q := db.BuildQuery("insert_msg", "messages")
-	db.Exec(q, msg.Domain(), msg.Action(), msg.Class(), msg.Item(), msg.Payload())
+	//db.Exec(q, msg.Domain(), msg.Action(), msg.Class(), msg.Item(), msg.Payload())
 }
 
 func init() {

storage/tracking/tracking.go

@@ -13,20 +13,25 @@ import (
 	sql "git.sr.ht/~cco/go-scopes/storage"
 )
 
-type ItemFactory func() Track
+type ItemFactory func(TrackTemplate) Track
 
 type Track interface {
 	TrackId() lib.Ident
+	Head() lib.StrMap
+	Data() lib.Map
 	TimeStamp() *time.Time
-}
+	//Update(TrackTemplate)
-
-type Container interface {
-	New(lib.StrSlice, lib.Map)
-	CreateTable()
 }
 
 type BaseTrack = track
-type BaseContainer = container
+
+type TrackTemplate struct {
+	TrackId   lib.Ident
+	Head      lib.StrMap
+	TimeStamp *time.Time
+	Data      lib.Map
+	Container *Container
+}
 
 // basic track implementation
 
@@ -35,38 +40,46 @@ type track struct {
 	head      lib.StrMap
 	timeStamp *time.Time
 	data      lib.Map
-	container *container
+	container *Container
 }
 
 func (tr *track) TrackId() lib.Ident {
 	return tr.trackId
 }
 
+func (tr *track) Head() lib.StrMap {
+	return tr.head
+}
+
+func (tr *track) Data() lib.Map {
+	return tr.data
+}
+
 func (tr *track) TimeStamp() *time.Time {
 	return tr.timeStamp
 }
 
 // basic container implementation
 
-type container struct {
+type Container struct {
-	tableName  string
+	TableName  string
-	headFields []string
+	HeadFields []string
-	indexes    [][]string
+	Indexes    [][]string
-	storage    *sql.Storage
+	Storage    *sql.Storage
 }
 
-func Tracks(db *sql.Storage) *container {
+func Tracks(db *sql.Storage) *Container {
-	return &container{
+	return &Container{
-		tableName:  "tracks",
+		TableName:  "tracks",
-		headFields: []string{"taskId", "userName"},
+		HeadFields: []string{"taskId", "userName"},
-		indexes:    [][]string{[]string{"taskId", "userName"}, []string{"userName"}},
+		Indexes:    [][]string{[]string{"taskId", "userName"}, []string{"userName"}},
-		storage:    db,
+		Storage:    db,
 	}
 }
 
-func (cont *container) New(headValues lib.StrSlice, data lib.Map) Track {
+func (cont *Container) New(headValues lib.StrSlice, data lib.Map) Track {
 	head := lib.StrMap{}
-	for i, k := range cont.headFields {
+	for i, k := range cont.HeadFields {
 		head[k] = headValues[i]
 	}
 	tr := &track{head: head, data: data}
@@ -74,20 +87,20 @@ func (cont *container) New(headValues lib.StrSlice, data lib.Map) Track {
 	return tr
 }
 
-func (cont *container) insert(tr *track) lib.Ident {
+func (cont *Container) insert(tr *track) lib.Ident {
 	var columns []string
 	var values []any
-	for _, k := range cont.headFields {
+	for _, k := range cont.HeadFields {
 		columns = append(columns, k)
 		values = append(values, tr.head[k])
 	}
 	columns = append(columns, "Data")
 	b, _ := json.Marshal(tr.data)
 	values = append(values, b)
-	db := cont.storage
+	db := cont.Storage
 	data := lib.Map{
 		"schema":    db.Schema,
-		"tablename": cont.tableName,
+		"tablename": cont.TableName,
 		"columns":   columns,
 	}
 	sql := storage.BuildSql(SqlInsert, data)
@@ -121,13 +134,13 @@ func ParseDateTime(inp string) *time.Time {
 	return nil
 }
 
-func (cont *container) CreateTable() {
+func (cont *Container) CreateTable() {
-	db := cont.storage
+	db := cont.Storage
 	data := lib.Map{
 		"schema":     db.Schema,
-		"tablename":  cont.tableName,
+		"tablename":  cont.TableName,
-		"headFields": cont.headFields,
+		"headFields": cont.HeadFields,
-		"indexes":    cont.indexes,
+		"indexes":    cont.Indexes,
 		"params":     db.Params,
 	}
 	sql := storage.BuildSql(SqlCreate, data)

tests/storage_test.go

@@ -1,16 +1,15 @@
 package scopes
 
 import (
-	"fmt"
 	tbase "testing"
+	"time"
 
 	lib "git.sr.ht/~cco/go-scopes"
 	"git.sr.ht/~cco/go-scopes/common/testing"
-	"git.sr.ht/~cco/go-scopes/core/message"
 	sql "git.sr.ht/~cco/go-scopes/storage"
 	"git.sr.ht/~cco/go-scopes/storage/db/pgsql"
 	_ "git.sr.ht/~cco/go-scopes/storage/db/sqlite"
-	msgstore "git.sr.ht/~cco/go-scopes/storage/message"
+	"git.sr.ht/~cco/go-scopes/storage/message"
 	"git.sr.ht/~cco/go-scopes/storage/tracking"
 	"git.sr.ht/~cco/go-scopes/tests/etc"
 )
@@ -71,23 +70,30 @@ func TrackingTest(t *testing.T, cfg *sql.Cfg, db *sql.Storage) {
 	cont.CreateTable()
 	track := cont.New(lib.StrSlice{"t01", "john"}, lib.Map{})
 	t.AssertEqual(track.TrackId(), lib.Ident(1))
-	fmt.Printf("%+v\n", track.TimeStamp())
+	t.AssertEqual(track.TimeStamp().Year(), time.Now().Year())
+	//fmt.Printf("%+v\n", track.TimeStamp())
 }
 
 func MessageTest(t *testing.T, cfg *sql.Cfg, db *sql.Storage) {
-	msg := message.SimpleMessage("data")
+	//msg := message.SimpleMessage("data")
-	msgstore.StoreDB(db, msg)
+	//msgstore.StoreDB(db, msg)
+	cont := message.Messages(db)
+	cont.CreateTable()
+	//msg := cont.New(lib.StrSlice("", "data"), lib.Map{})
+	//t.AssertEqual(msg.TrackId(), lib.Ident(1))
 }
 
 func resetSqlite(db *sql.Storage) {
 	db.DropTable("test")
 	db.DropTable("tracks")
+	db.DropTable("messages")
 	db.Exec(sqlite_create_table)
 }
 
 func resetPgsql(db *sql.Storage) {
 	db.DropTable("test")
 	db.DropTable("testing.tracks")
+	db.DropTable("testing.messages")
 	db.Exec(pgsql_create_table)
 }