Merge branch 'refactor/clean-up'

Author: NeedleInAJayStack

apiModels.go

@@ -1,39 +1,5 @@
 package main
 
-import (
-	"time"
-
-	"github.com/google/uuid"
-	"gorm.io/datatypes"
-)
-
-type apiHis struct {
-	PointId uuid.UUID  `json:"pointId"`
-	Ts      *time.Time `json:"ts"`
-	Value   *float64   `json:"value"`
-}
-
-type apiHisItem struct {
-	Ts    *time.Time `json:"ts"`
-	Value *float64   `json:"value"`
-}
-
-type apiRec struct {
-	ID   uuid.UUID      `json:"id"`
-	Tags datatypes.JSON `json:"tags"`
-	Dis  *string        `json:"dis"`
-	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

@@ -53,7 +53,7 @@ func (h currentController) postCurrent(writer http.ResponseWriter, request *http
 		return
 	}
 	decoder := json.NewDecoder(request.Body)
-	var currentItem apiCurrentInput
+	var currentItem currentInput
 	err = decoder.Decode(&currentItem)
 	if err != nil {
 		log.Printf("Cannot decode request JSON: %s", err)

currentStore.go

@@ -1,34 +1,52 @@
 package main
 
 import (
+	"sync"
 	"time"
 
 	"github.com/google/uuid"
 )
 
 // currentStore is able to store point current values
 type currentStore interface {
-	getCurrent(uuid.UUID) apiCurrent
-	setCurrent(uuid.UUID, apiCurrentInput)
+	getCurrent(uuid.UUID) current
+	setCurrent(uuid.UUID, currentInput)
+}
+
+type currentInput struct {
+	Value *float64 `json:"value"`
+}
+
+type current struct {
+	Ts    *time.Time `json:"ts"`
+	Value *float64   `json:"value"`
 }
 
 // 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
+	mux   *sync.Mutex
+	cache map[uuid.UUID]current
 }
 
 func newInMemoryCurrentStore() inMemoryCurrentStore {
-	return inMemoryCurrentStore{cache: map[uuid.UUID]apiCurrent{}}
+	return inMemoryCurrentStore{
+		mux:   &sync.Mutex{},
+		cache: map[uuid.UUID]current{},
+	}
 }
 
-func (s inMemoryCurrentStore) getCurrent(id uuid.UUID) apiCurrent {
+func (s inMemoryCurrentStore) getCurrent(id uuid.UUID) current {
+	s.mux.Lock()
+	defer s.mux.Unlock()
 	return s.cache[id]
 }
 
-func (s inMemoryCurrentStore) setCurrent(id uuid.UUID, input apiCurrentInput) {
+func (s inMemoryCurrentStore) setCurrent(id uuid.UUID, input currentInput) {
 	timestamp := time.Now()
-	s.cache[id] = apiCurrent{
+	s.mux.Lock()
+	defer s.mux.Unlock()
+	s.cache[id] = current{
 		Ts:    &timestamp,
 		Value: input.Value,
 	}

dbModels.go

@@ -86,7 +86,7 @@ func (h hisController) postHis(writer http.ResponseWriter, request *http.Request
 		return
 	}
 	decoder := json.NewDecoder(request.Body)
-	var hisItem apiHisItem
+	var hisItem hisItem
 	err = decoder.Decode(&hisItem)
 	if err != nil {
 		log.Printf("Cannot decode request JSON: %s", err)

hisController.go

@@ -10,11 +10,16 @@ import (
 
 // 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
+	readHistory(uuid.UUID, *time.Time, *time.Time) ([]hisItem, error)
+	writeHistory(uuid.UUID, hisItem) error
 	deleteHistory(uuid.UUID, *time.Time, *time.Time) error
 }
 
+type hisItem struct {
+	Ts    *time.Time `json:"ts"`
+	Value *float64   `json:"value"`
+}
+
 // gormHistoryStore stores point historical values in a GORM database.
 type gormHistoryStore struct {
 	db *gorm.DB
@@ -28,11 +33,11 @@ func (s gormHistoryStore) readHistory(
 	pointId uuid.UUID,
 	start *time.Time,
 	end *time.Time,
-) ([]apiHisItem, error) {
-	result := []apiHisItem{}
+) ([]hisItem, error) {
+	result := []hisItem{}
 
-	var sqlResult []his
-	query := s.db.Where(&his{PointId: pointId})
+	var sqlResult []gormHis
+	query := s.db.Where(&gormHis{PointId: pointId})
 	if start != nil {
 		query.Where("ts >= ?", start)
 	}
@@ -44,16 +49,16 @@ func (s gormHistoryStore) readHistory(
 		return result, err
 	}
 	for _, sqlRow := range sqlResult {
-		result = append(result, apiHisItem{Ts: sqlRow.Ts, Value: sqlRow.Value})
+		result = append(result, hisItem{Ts: sqlRow.Ts, Value: sqlRow.Value})
 	}
 	return result, nil
 }
 
 func (s gormHistoryStore) writeHistory(
 	pointId uuid.UUID,
-	hisItem apiHisItem,
+	hisItem hisItem,
 ) error {
-	his := his{
+	gormHis := gormHis{
 		PointId: pointId,
 		Ts:      hisItem.Ts,
 		Value:   hisItem.Value,
@@ -62,16 +67,16 @@ func (s gormHistoryStore) writeHistory(
 	return s.db.Clauses(clause.OnConflict{
 		Columns:   []clause.Column{{Name: "pointId"}, {Name: "ts"}},
 		DoUpdates: clause.AssignmentColumns([]string{"value"}),
-	}).Create(&his).Error
+	}).Create(&gormHis).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})
+	var sqlResult []gormHis
+	query := s.db.Where(&gormHis{PointId: pointId})
 	if start != nil {
 		query.Where("ts >= ?", start)
 	}
@@ -80,3 +85,9 @@ func (s gormHistoryStore) deleteHistory(
 	}
 	return query.Delete(&sqlResult).Error
 }
+
+type gormHis struct {
+	PointId uuid.UUID  `gorm:"column:pointId;type:uuid;primaryKey;index:his_pointId_ts_idx"`
+	Ts      *time.Time `gorm:"primaryKey:pk_his;index:his_pointId_ts_idx,sort:desc;index:his_ts_idx,sort:desc"`
+	Value   *float64   `gorm:"type:double precision"`
+}

historyStore.go

@@ -35,22 +35,22 @@ func (recController recController) getRecs(w http.ResponseWriter, r *http.Reques
 // POST /recs
 func (recController recController) postRecs(w http.ResponseWriter, r *http.Request) {
 	decoder := json.NewDecoder(r.Body)
-	var apiRec apiRec
-	err := decoder.Decode(&apiRec)
+	var rec rec
+	err := decoder.Decode(&rec)
 	if err != nil {
 		log.Printf("Cannot decode request JSON: %s", err)
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
 
-	err = recController.store.createRec(apiRec)
+	err = recController.store.createRec(rec)
 	if err != nil {
 		log.Printf("Storage Error: %s", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	recJSON, err := json.Marshal(apiRec)
+	recJSON, err := json.Marshal(rec)
 	if err != nil {
 		log.Printf("Cannot encode response JSON")
 		w.WriteHeader(http.StatusBadRequest)
@@ -63,14 +63,14 @@ func (recController recController) postRecs(w http.ResponseWriter, r *http.Reque
 
 // GET /recs/tag/:tag
 func (recController recController) getRecsByTag(w http.ResponseWriter, r *http.Request) {
-	apiRecs, err := recController.store.readRecs("siteMeter")
+	recs, err := recController.store.readRecs("siteMeter")
 	if err != nil {
 		log.Printf("Storage Error: %s", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	httpJson, err := json.Marshal(apiRecs)
+	httpJson, err := json.Marshal(recs)
 	if err != nil {
 		log.Printf("Cannot encode response JSON")
 		w.WriteHeader(http.StatusBadRequest)
@@ -90,14 +90,14 @@ func (recController recController) getRec(w http.ResponseWriter, r *http.Request
 		w.WriteHeader(http.StatusNotFound)
 		return
 	}
-	apiRec, err := recController.store.readRec(id)
+	rec, err := recController.store.readRec(id)
 	if err != nil {
 		log.Printf("Storage Error: %s", err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}
 
-	httpJson, err := json.Marshal(apiRec)
+	httpJson, err := json.Marshal(rec)
 	if err != nil {
 		log.Printf("Cannot encode response JSON")
 		w.WriteHeader(http.StatusBadRequest)
@@ -119,14 +119,14 @@ func (recController recController) putRec(w http.ResponseWriter, r *http.Request
 	}
 
 	decoder := json.NewDecoder(r.Body)
-	var apiRec apiRec
-	err = decoder.Decode(&apiRec)
+	var rec rec
+	err = decoder.Decode(&rec)
 	if err != nil {
 		log.Printf("Cannot decode request JSON: %s", err)
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
-	err = recController.store.updateRec(id, apiRec)
+	err = recController.store.updateRec(id, rec)
 	if err != nil {
 		log.Printf("Storage Error: %s", id)
 		w.WriteHeader(http.StatusBadRequest)