feat: Adds currentValue endpoints and store

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,
+	}
+}

server.go

@@ -58,6 +58,10 @@ func NewServer(serverConfig ServerConfig) (*http.ServeMux, error) {
 	tokenAuth.HandleFunc("GET /recs/{pointId}/history", hisController.getHis)
 	tokenAuth.HandleFunc("POST /recs/{pointId}/history", hisController.postHis)
 	tokenAuth.HandleFunc("DELETE /recs/{pointId}/history", hisController.getHis)
+
+	currentController := currentController{store: newInMemoryCurrentStore()}
+	tokenAuth.HandleFunc("GET /recs/{pointId}/current", currentController.getCurrent)
+	tokenAuth.HandleFunc("POST /recs/{pointId}/current", currentController.postCurrent)
 	server.Handle("/recs/", tokenAuthMiddleware(serverConfig.jwtSecret, tokenAuth))
 
 	// Catch all others with public files. Not found fallback is app index for browser router.

server_test.go

@@ -456,6 +456,41 @@ func (suite *ServerTestSuite) TestDeleteRec() {
 	assert.Equal(suite.T(), recCount, int64(0))
 }
 
+func (suite *ServerTestSuite) TestCurrent() {
+	id, _ := uuid.Parse("1b4e32c7-61b5-4b38-a1cd-023c25f9965c")
+	recs := []rec{
+		{
+			ID:   id,
+			Dis:  s("rec"),
+			Tags: datatypes.JSON([]byte(`{"tag":"value"}`)),
+			Unit: s("kW"),
+		},
+	}
+	suite.db.Create(&recs)
+
+	value := 123.456
+	currentInput := apiCurrentInput{
+		Value: &value,
+	}
+	body, err := json.Marshal(currentInput)
+	assert.Nil(suite.T(), err)
+	setRequest, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("/recs/%s/current", id), bytes.NewReader(body))
+	setRequest.Header.Add("Authorization", fmt.Sprintf("Bearer %s", suite.getAuthToken()))
+	setResponse := httptest.NewRecorder()
+	suite.server.ServeHTTP(setResponse, setRequest)
+	assert.Equal(suite.T(), setResponse.Code, http.StatusOK)
+
+	getRequest, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/recs/%s/current", id), nil)
+	getRequest.Header.Add("Authorization", fmt.Sprintf("Bearer %s", suite.getAuthToken()))
+	getResponse := httptest.NewRecorder()
+	suite.server.ServeHTTP(getResponse, getRequest)
+	assert.Equal(suite.T(), getResponse.Code, http.StatusOK)
+	decoder := json.NewDecoder(getResponse.Result().Body)
+	var apiCurrent apiCurrent
+	assert.Nil(suite.T(), decoder.Decode(&apiCurrent))
+	assert.Equal(suite.T(), 123.456, *apiCurrent.Value)
+}
+
 // These functions just take literals and return a pointer to them. For easier DB/JSON construction
 func s(s string) *string   { return &s }
 func f(f float64) *float64 { return &f }