Merge branch 'feat/currentValue'

Author: NeedleInAJayStack

apiModels.go

@@ -25,6 +25,15 @@ type apiRec struct {
 	Unit *string        `json:"unit"`
 }
 
+type apiCurrentInput struct {
+	Value *float64 `json:"value"`
+}
+
+type apiCurrent struct {
+	Ts    *time.Time `json:"ts"`
+	Value *float64   `json:"value"`
+}
+
 type clientToken struct {
 	Token string `json:"token"`
 }

currentController.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+
+	"github.com/google/uuid"
+)
+
+type currentController struct {
+	store currentStore
+}
+
+// GET /recs/:pointId/current
+// Note that start and end are in seconds since epoch (1970-01-01T00:00:00Z)
+func (h currentController) getCurrent(w http.ResponseWriter, request *http.Request) {
+	pointIdString := request.PathValue("pointId")
+	pointId, err := uuid.Parse(pointIdString)
+	if err != nil {
+		log.Printf("Invalid UUID: %s", pointIdString)
+		w.WriteHeader(http.StatusNotFound)
+		return
+	}
+	err = request.ParseForm()
+	if err != nil {
+		log.Printf("Cannot parse form: %s", err)
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	httpResult := h.store.getCurrent(pointId)
+
+	httpJson, err := json.Marshal(httpResult)
+	if err != nil {
+		log.Printf("Cannot encode response JSON")
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Write(httpJson)
+}
+
+// POST /recs/:pointId/current
+// Note that start and end are in seconds since epoch (1970-01-01T00:00:00Z)
+func (h currentController) postCurrent(writer http.ResponseWriter, request *http.Request) {
+	pointIdString := request.PathValue("pointId")
+	pointId, err := uuid.Parse(pointIdString)
+	if err != nil {
+		log.Printf("Invalid UUID: %s", pointIdString)
+		writer.WriteHeader(http.StatusNotFound)
+		return
+	}
+	decoder := json.NewDecoder(request.Body)
+	var currentItem apiCurrentInput
+	err = decoder.Decode(&currentItem)
+	if err != nil {
+		log.Printf("Cannot decode request JSON: %s", err)
+		writer.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	h.store.setCurrent(pointId, currentItem)
+
+	writer.WriteHeader(http.StatusOK)
+}

currentStore.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// currentStore is able to store point current values
+type currentStore interface {
+	getCurrent(uuid.UUID) apiCurrent
+	setCurrent(uuid.UUID, apiCurrentInput)
+}
+
+// inMemoryCurrentStore stores point current values in a local in-memory cache.
+// These are not shared between instances.
+type inMemoryCurrentStore struct {
+	cache map[uuid.UUID]apiCurrent
+}
+
+func newInMemoryCurrentStore() inMemoryCurrentStore {
+	return inMemoryCurrentStore{cache: map[uuid.UUID]apiCurrent{}}
+}
+
+func (s inMemoryCurrentStore) getCurrent(id uuid.UUID) apiCurrent {
+	return s.cache[id]
+}
+
+func (s inMemoryCurrentStore) setCurrent(id uuid.UUID, input apiCurrentInput) {
+	timestamp := time.Now()
+	s.cache[id] = apiCurrent{
+		Ts:    &timestamp,
+		Value: input.Value,
+	}
+}

hisController.go

@@ -8,15 +8,13 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
 )
 
 type hisController struct {
-	db *gorm.DB
+	store historyStore
 }
 
-// GET /his/:pointId?start=...&end=...
+// GET /recs/:pointId/history?start=...&end=...
 // Note that start and end are in seconds since epoch (1970-01-01T00:00:00Z)
 func (h hisController) getHis(w http.ResponseWriter, request *http.Request) {
 	pointIdString := request.PathValue("pointId")
@@ -34,41 +32,38 @@ func (h hisController) getHis(w http.ResponseWriter, request *http.Request) {
 	}
 	params := request.Form
 
-	var sqlResult []his
-	query := h.db.Where(&his{PointId: pointId})
 	// TODO: Change start/end to ISO8601
+	var start *time.Time
 	if params["start"] != nil {
 		startStr := params["start"][0]
-		start, err := strconv.ParseInt(startStr, 0, 64)
+		startUnix, err := strconv.ParseInt(startStr, 0, 64)
 		if err != nil {
 			log.Printf("Cannot parse time: %s", startStr)
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
-		query.Where("ts >= ?", time.Unix(start, 0))
+		startTime := time.Unix(startUnix, 0)
+		start = &startTime
 	}
+	var end *time.Time
 	if params["end"] != nil {
 		endStr := params["end"][0]
-		end, err := strconv.ParseInt(endStr, 0, 64)
+		endUnix, err := strconv.ParseInt(endStr, 0, 64)
 		if err != nil {
 			log.Printf("Cannot parse time: %s", endStr)
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
-		query.Where("ts < ?", time.Unix(end, 0))
+		endTime := time.Unix(endUnix, 0)
+		end = &endTime
 	}
-	err = query.Order("ts asc").Find(&sqlResult).Error
+	httpResult, err := h.store.readHistory(pointId, start, end)
 	if err != nil {
-		log.Printf("SQL Error: %s", err)
+		log.Printf("Storage Error: %s", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	httpResult := []apiHis{}
-	for _, sqlRow := range sqlResult {
-		httpResult = append(httpResult, apiHis(sqlRow))
-	}
-
 	httpJson, err := json.Marshal(httpResult)
 	if err != nil {
 		log.Printf("Cannot encode response JSON")
@@ -80,7 +75,7 @@ func (h hisController) getHis(w http.ResponseWriter, request *http.Request) {
 	w.Write(httpJson)
 }
 
-// POST /his/:pointId
+// POST /recs/:pointId/history
 // Note that start and end are in seconds since epoch (1970-01-01T00:00:00Z)
 func (h hisController) postHis(writer http.ResponseWriter, request *http.Request) {
 	pointIdString := request.PathValue("pointId")
@@ -98,27 +93,16 @@ func (h hisController) postHis(writer http.ResponseWriter, request *http.Request
 		writer.WriteHeader(http.StatusBadRequest)
 		return
 	}
-
-	his := his{
-		PointId: pointId,
-		Ts:      hisItem.Ts,
-		Value:   hisItem.Value,
-	}
-
-	err = h.db.Clauses(clause.OnConflict{
-		Columns:   []clause.Column{{Name: "pointId"}, {Name: "ts"}},
-		DoUpdates: clause.AssignmentColumns([]string{"value"}),
-	}).Create(&his).Error
+	err = h.store.writeHistory(pointId, hisItem)
 	if err != nil {
-		log.Printf("SQL Error: %s", err)
+		log.Printf("Storage Error: %s", err)
 		writer.WriteHeader(http.StatusInternalServerError)
 		return
 	}
-
 	writer.WriteHeader(http.StatusOK)
 }
 
-// DELETE /his/:pointId?start=...&end=...
+// DELETE /recs/:pointId/history?start=...&end=...
 // Note that start and end are in seconds since epoch (1970-01-01T00:00:00Z)
 func (h hisController) deleteHis(writer http.ResponseWriter, request *http.Request) {
 	pointIdString := request.PathValue("pointId")
@@ -136,30 +120,32 @@ func (h hisController) deleteHis(writer http.ResponseWriter, request *http.Reque
 	}
 	params := request.Form
 
-	var sqlResult []his
-	query := h.db.Where(&his{PointId: pointId})
 	// TODO: Change start/end to ISO8601
+	var start *time.Time
 	if params["start"] != nil {
 		startStr := params["start"][0]
-		start, err := strconv.ParseInt(startStr, 0, 64)
+		startUnix, err := strconv.ParseInt(startStr, 0, 64)
 		if err != nil {
 			log.Printf("Cannot parse time: %s", startStr)
 			writer.WriteHeader(http.StatusBadRequest)
 			return
 		}
-		query.Where("ts >= ?", time.Unix(start, 0))
+		startTime := time.Unix(startUnix, 0)
+		start = &startTime
 	}
+	var end *time.Time
 	if params["end"] != nil {
 		endStr := params["end"][0]
-		end, err := strconv.ParseInt(endStr, 0, 64)
+		endUnix, err := strconv.ParseInt(endStr, 0, 64)
 		if err != nil {
 			log.Printf("Cannot parse time: %s", endStr)
 			writer.WriteHeader(http.StatusBadRequest)
 			return
 		}
-		query.Where("ts < ?", time.Unix(end, 0))
+		endTime := time.Unix(endUnix, 0)
+		end = &endTime
 	}
-	err = query.Delete(&sqlResult).Error
+	err = h.store.deleteHistory(pointId, start, end)
 	if err != nil {
 		log.Printf("SQL Error: %s", err)
 		writer.WriteHeader(http.StatusInternalServerError)

historyStore.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// historyStore is able to store point historical values
+type historyStore interface {
+	readHistory(uuid.UUID, *time.Time, *time.Time) ([]apiHisItem, error)
+	writeHistory(uuid.UUID, apiHisItem) error
+	deleteHistory(uuid.UUID, *time.Time, *time.Time) error
+}
+
+// gormHistoryStore stores point historical values in a GORM database.
+type gormHistoryStore struct {
+	db *gorm.DB
+}
+
+func newGormHistoryStore(db *gorm.DB) gormHistoryStore {
+	return gormHistoryStore{db: db}
+}
+
+func (s gormHistoryStore) readHistory(
+	pointId uuid.UUID,
+	start *time.Time,
+	end *time.Time,
+) ([]apiHisItem, error) {
+	result := []apiHisItem{}
+
+	var sqlResult []his
+	query := s.db.Where(&his{PointId: pointId})
+	if start != nil {
+		query.Where("ts >= ?", start)
+	}
+	if end != nil {
+		query.Where("ts < ?", end)
+	}
+	err := query.Order("ts asc").Find(&sqlResult).Error
+	if err != nil {
+		return result, err
+	}
+	for _, sqlRow := range sqlResult {
+		result = append(result, apiHisItem{Ts: sqlRow.Ts, Value: sqlRow.Value})
+	}
+	return result, nil
+}
+
+func (s gormHistoryStore) writeHistory(
+	pointId uuid.UUID,
+	hisItem apiHisItem,
+) error {
+	his := his{
+		PointId: pointId,
+		Ts:      hisItem.Ts,
+		Value:   hisItem.Value,
+	}
+
+	return s.db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "pointId"}, {Name: "ts"}},
+		DoUpdates: clause.AssignmentColumns([]string{"value"}),
+	}).Create(&his).Error
+}
+
+func (s gormHistoryStore) deleteHistory(
+	pointId uuid.UUID,
+	start *time.Time,
+	end *time.Time,
+) error {
+	var sqlResult []his
+	query := s.db.Where(&his{PointId: pointId})
+	if start != nil {
+		query.Where("ts >= ?", start)
+	}
+	if end != nil {
+		query.Where("ts < ?", end)
+	}
+	return query.Delete(&sqlResult).Error
+}