go-scopes/storage/tracking/tracking.go

// Package `tracking` defines a generic track (sort of record) type
// and a container type that allows storing of tracks in a SQL database.
package tracking

import (
	sqllib "database/sql"
	"encoding/json"
	"fmt"
	"time"

	lib "git.sr.ht/~cco/go-scopes"
	"git.sr.ht/~cco/go-scopes/logging/log"
	"git.sr.ht/~cco/go-scopes/storage"
	sql "git.sr.ht/~cco/go-scopes/storage"
)

type ItemFactory func(*Container, ...string) *Track

// basic track implementation

type Track struct {
	trackId   lib.Ident
	Head      lib.StrMap
	TimeStamp *time.Time
	Data      lib.Map
	container *Container
}

func (tr *Track) TrackId() lib.Ident {
	return tr.trackId
}

func (tr *Track) Container() *Container {
	return tr.container
}

func MakeTrack(cont *Container, h ...string) *Track {
	tr := Track{
		Head:      lib.StrMap{},
		container: cont,
	}
	tr.SetHead(h...)
	return &tr
}

func (tr *Track) SetHead(h ...string) {
	for i, k := range tr.container.HeadFields {
		if i >= len(h) {
			break
		}
		if h[i] != "" {
			tr.Head[k] = h[i]
		}
	}
}

func (tr *Track) ScanP(rows *sql.Rows) error {
	tr.Head = lib.StrMap{}
	var d []any
	for range tr.container.HeadFields {
		var hv string
		d = append(d, &hv)
	}
	var ts, rd string
	d = append(d, &ts, &rd, &tr.trackId)
	err := rows.Scan(d...)
	for i, k := range tr.container.HeadFields {
		tr.Head[k] = *d[i].(*string)
	}
	tr.TimeStamp = ParseDateTime(ts)
	err = json.Unmarshal([]byte(rd), &tr.Data)
	if err != nil {
		log.Error(err).Msg("storage.tracking.ScanP")
	}
	return err
}

// basic container implementation

type ContDef struct {
	ItemFactory ItemFactory
	TableName   string
	HeadFields  []string
	Indexes     [][]string
}

type Container struct {
	*ContDef
	Storage *sql.Storage
}

func Tracks(db *sql.Storage) *Container {
	return &Container{container_definition, db}
}

func (cont *Container) setupQuerySpec(spec *querySpec) *querySpec {
	if cont.Storage.Schema == "" {
		spec.Table = cont.TableName
	} else {
		spec.Table = fmt.Sprintf("%s.%s", cont.Storage.Schema, cont.TableName)
	}
	spec.Scols = append(cont.HeadFields, "timestamp", "data", "trackid")
	for i, v := range spec.Headvals {
		if v != "" {
			spec.Qucols = append(spec.Qucols, cont.HeadFields[i])
			spec.Quvals = append(spec.Quvals, v)
		}
	}
	return spec
}

type querySpec struct {
	Table           string
	Headvals        lib.StrSlice
	Scols           lib.StrSlice
	Qucols, Ordcols lib.StrSlice
	Quspecs         []struct{ col, op string }
	Ordspecs        []struct {
		Col  string
		Desc bool
	}
	Limit  int
	Quvals []any
}

func (cont *Container) Get(id lib.Ident) *Track {
	db := cont.Storage
	var tr *Track
	proc := func(r *sql.Rows) error {
		tr = cont.ItemFactory(cont)
		return tr.ScanP(r)
	}
	quSpec := &querySpec{
		Qucols: lib.StrSlice{"trackid"},
		Quvals: []any{id},
	}
	cont.setupQuerySpec(quSpec)
	sql := storage.BuildSql(SqlSelect, quSpec)
	db.Query(proc, sql, id)
	return tr
}

func (cont *Container) QueryLast(hv ...string) *Track {
	db := cont.Storage
	var tr *Track
	proc := func(r *sql.Rows) error {
		tr = cont.ItemFactory(cont)
		return tr.ScanP(r)
	}
	quSpec := &querySpec{
		Headvals: hv,
		Ordcols:  lib.StrSlice{"timestamp"},
	}
	cont.setupQuerySpec(quSpec)
	sql := storage.BuildSql(SqlSelect, quSpec)
	println(sql)
	db.Query(proc, sql, quSpec.Quvals...)
	return tr
}

func (cont *Container) NewTrack(h []string, data lib.Map) *Track {
	tr := cont.ItemFactory(cont, h...)
	//tr.SetData(data)
	cont.Insert(tr)
	return tr
}

func (cont *Container) Save(t *Track) lib.Ident {
	return 0
}

func (cont *Container) Insert(tr *Track) lib.Ident {
	var columns []string
	var values []any
	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
	data := lib.Map{
		"schema":    db.Schema,
		"tablename": cont.TableName,
		"columns":   columns,
	}
	sql := storage.BuildSql(SqlInsert, data)
	var trid lib.Ident
	var ts *time.Time
	var tsstr string
	proc := func(r *sqllib.Rows) error {
		err := r.Scan(&trid, &ts)
		if err != nil {
			err = r.Scan(&trid, &tsstr)
			ts = ParseDateTime(tsstr)
		}
		return err
	}
	if err := db.Query(proc, sql, values...); err == nil {
		tr.trackId = trid
		tr.TimeStamp = ts
		return trid
	}
	return 0
}

func ParseDateTime(inp string) *time.Time {
	ts, err := time.Parse("2006-01-02 15:04:05", inp)
	if err == nil {
		return &ts
	}
	ts, err = time.Parse("2006-01-02T15:04:05-07:00", inp)
	if err == nil {
		return &ts
	}
	log.Error(err).Msg("storage.tracking.ParseDateTime")
	return nil
}

func (cont *Container) CreateTable() {
	db := cont.Storage
	data := lib.Map{
		"schema":     db.Schema,
		"tablename":  cont.TableName,
		"headFields": cont.HeadFields,
		"indexes":    cont.Indexes,
		"params":     db.Params,
	}
	sql := storage.BuildSql(SqlCreate, data)
	if _, err := db.Exec(sql); err != nil {
		panic(err)
	}
}

// container definition

var container_definition *ContDef

func init() {
	container_definition = &ContDef{
		ItemFactory: MakeTrack,
		TableName:   "tracks",
		HeadFields:  []string{"taskId", "userName"},
		Indexes: [][]string{
			[]string{"taskId", "userName"},
			[]string{"userName"},
		},
	}
}