add data models

model/session.go

@@ -0,0 +1,128 @@
+package model
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"time"
+
+	"github.com/parkan/go-hauk/store"
+)
+
+const (
+	PrefixSession = "session-"
+	SessionIDSize = 32
+)
+
+type SessionData struct {
+	Expire    int64    `json:"expire"`
+	Interval  float64  `json:"interval"`
+	Targets   []string `json:"targets"`
+	Points    [][]any  `json:"points"`
+	Encrypted bool     `json:"encrypted"`
+	Salt      string   `json:"salt,omitempty"`
+}
+
+type Session struct {
+	store store.Store
+	id    string
+	data  SessionData
+	maxPts int
+}
+
+func NewSession(s store.Store, maxPts int) (*Session, error) {
+	id, err := generateSessionID()
+	if err != nil {
+		return nil, err
+	}
+	return &Session{
+		store:  s,
+		id:     id,
+		maxPts: maxPts,
+		data: SessionData{
+			Targets: []string{},
+			Points:  [][]any{},
+		},
+	}, nil
+}
+
+func LoadSession(ctx context.Context, s store.Store, id string, maxPts int) (*Session, error) {
+	sess := &Session{store: s, id: id, maxPts: maxPts}
+	err := s.Get(ctx, PrefixSession+id, &sess.data)
+	if err != nil {
+		return nil, err
+	}
+	return sess, nil
+}
+
+func (s *Session) ID() string               { return s.id }
+func (s *Session) Expire() time.Time        { return time.Unix(s.data.Expire, 0) }
+func (s *Session) Interval() float64        { return s.data.Interval }
+func (s *Session) Targets() []string        { return s.data.Targets }
+func (s *Session) Points() [][]any          { return s.data.Points }
+func (s *Session) Encrypted() bool          { return s.data.Encrypted }
+func (s *Session) Salt() string             { return s.data.Salt }
+func (s *Session) HasExpired() bool         { return time.Now().Unix() >= s.data.Expire }
+
+func (s *Session) SetExpire(t time.Time)    { s.data.Expire = t.Unix() }
+func (s *Session) SetInterval(i float64)    { s.data.Interval = i }
+func (s *Session) SetEncrypted(e bool, salt string) {
+	s.data.Encrypted = e
+	s.data.Salt = salt
+}
+
+func (s *Session) AddTarget(shareID string) {
+	s.data.Targets = append(s.data.Targets, shareID)
+}
+
+func (s *Session) RemoveTarget(shareID string) {
+	for i, t := range s.data.Targets {
+		if t == shareID {
+			s.data.Targets = append(s.data.Targets[:i], s.data.Targets[i+1:]...)
+			return
+		}
+	}
+}
+
+func (s *Session) AddPoint(p []any) {
+	s.data.Points = append(s.data.Points, p)
+	if len(s.data.Points) > s.maxPts {
+		s.data.Points = s.data.Points[len(s.data.Points)-s.maxPts:]
+	}
+}
+
+func (s *Session) GetPoints(since float64) [][]any {
+	if since <= 0 {
+		return s.data.Points
+	}
+	timeIdx := 2
+	if s.data.Encrypted {
+		timeIdx = 3
+	}
+	var pts [][]any
+	for _, p := range s.data.Points {
+		if len(p) > timeIdx {
+			if t, ok := p[timeIdx].(float64); ok && t > since {
+				pts = append(pts, p)
+			}
+		}
+	}
+	return pts
+}
+
+func (s *Session) Save(ctx context.Context) error {
+	return s.store.Set(ctx, PrefixSession+s.id, s.data, s.Expire())
+}
+
+func (s *Session) Delete(ctx context.Context) error {
+	return s.store.Delete(ctx, PrefixSession+s.id)
+}
+
+func generateSessionID() (string, error) {
+	b := make([]byte, SessionIDSize)
+	_, err := rand.Read(b)
+	if err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(b), nil
+}