timeseries_process.go

package handler

import (
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/USACE/instrumentation-api/api/internal/db"
	"github.com/USACE/instrumentation-api/api/internal/httperr"
	"github.com/USACE/instrumentation-api/api/internal/util"
	"github.com/google/uuid"
	"github.com/labstack/echo/v4"
)

type processTimeseriesType int

const (
	byTimeseriesRequest processTimeseriesType = iota
	byInstrumentRequest
	byInstrumentGroupRequest
	explorerRequest
)

// ListTimeseriesMeasurementsForTimeseries godoc
//
//	@Summary lists timeseries by timeseries uuid
//	@Tags timeseries
//	@Produce json
//	@Param instrument_id path string true "instrument uuid" Format(uuid)
//	@Param timeseries_id path string true "timeseries uuid" Format(uuid)
//	@Param after query string false "after time" Format(date-time)
//	@param before query string false "before time" Format(date-time)
//	@Param threshold query number false "downsample threshold"
//	@Success 200 {array} db.MeasurementCollection
//	@Failure 400 {object} echo.HTTPError
//	@Failure 404 {object} echo.HTTPError
//	@Failure 500 {object} echo.HTTPError
//	@Router /timeseries/{timeseries_id}/measurements [get]
//	@Router /instruments/{instrument_id}/timeseries/{timeseries_id}/measurements [get]
func (h *ApiHandler) ListTimeseriesMeasurementsForTimeseries(c echo.Context) error {
	tsID, err := uuid.Parse(c.Param("timeseries_id"))
	if err != nil {
		return httperr.MalformedID(err)
	}

	isStored, err := h.DBService.TimeseriesGetExistsStored(c.Request().Context(), tsID)
	if err != nil {
		return httperr.InternalServerError(err)
	}

	if isStored {
		var tw util.TimeWindow
		a, b := c.QueryParam("after"), c.QueryParam("before")
		if err := tw.SetWindow(a, b, time.Now().AddDate(0, 0, -7), time.Now()); err != nil {
			return httperr.MalformedDateRFC3339(err)
		}

		experimental := strings.ToLower(c.QueryParam("experimental")) == "true"
		trs := c.QueryParam("threshold")

		var threshold int
		if trs != "" {
			tr, err := strconv.Atoi(trs)
			if err != nil {
				return httperr.Message(http.StatusBadRequest, "threshold parameter must be an int")
			}
			threshold = tr
		}

		if experimental {
			mc, err := h.DBService.TimeseriesMeasurementCollectionGetForRangeEXPERIMENTAL(c.Request().Context(), db.TimeseriesMeasurementCollectionGetForRangeParams{
				TimeseriesID: tsID,
				After:        tw.After,
				Before:       tw.Before,
				Threshold:    threshold,
			})
			if err != nil {
				return httperr.InternalServerError(err)
			}
			return c.JSON(http.StatusOK, mc)
		}

		mc, err := h.DBService.TimeseriesMeasurementCollectionGetForRange(c.Request().Context(), db.TimeseriesMeasurementCollectionGetForRangeParams{
			TimeseriesID: tsID,
			After:        tw.After,
			Before:       tw.Before,
			Threshold:    threshold,
		})
		if err != nil {
			return httperr.InternalServerError(err)
		}
		return c.JSON(http.StatusOK, mc)
	}

	f := db.ProcessMeasurementFilter{TimeseriesID: &tsID}

	selectMeasurements := selectMeasurementsHandler(h, f, byTimeseriesRequest)
	return selectMeasurements(c)
}

// ListTimeseriesMeasurementsByInstrument godoc
//
//	@Summary lists timeseries measurements by instrument id
//	@Tags timeseries
//	@Produce json
//	@Param instrument_id path string true "instrument uuid" Format(uuid)
//	@Param after query string false "after time" Format(date-time)
//	@Param before query string false "before time" Format(date-time)
//	@Param threshold query number false "downsample threshold"
//	@Success 200 {object} map[uuid.UUID][]db.MeasurementCollectionLean
//	@Failure 400 {object} echo.HTTPError
//	@Failure 404 {object} echo.HTTPError
//	@Failure 500 {object} echo.HTTPError
//	@Router /instruments/{instrument_id}/timeseries_measurements [get]
func (h *ApiHandler) ListTimeseriesMeasurementsByInstrument(c echo.Context) error {
	iID, err := uuid.Parse(c.Param("instrument_id"))
	if err != nil {
		return httperr.MalformedID(err)
	}
	f := db.ProcessMeasurementFilter{InstrumentID: &iID}

	selectMeasurements := selectMeasurementsHandler(h, f, byInstrumentRequest)
	return selectMeasurements(c)
}

// ListTimeseriesMeasurementsByInstrumentGroup godoc
//
//	@Summary lists timeseries measurements by instrument group id
//	@Tags timeseries
//	@Produce json
//	@Param instrument_group_id path string true "instrument group uuid" Format(uuid)
//	@Success 200 {object} map[uuid.UUID][]db.MeasurementCollectionLean
//	@Failure 400 {object} echo.HTTPError
//	@Failure 404 {object} echo.HTTPError
//	@Failure 500 {object} echo.HTTPError
//	@Router /instrument_groups/{instrument_group_id}/timeseries_measurements [get]
func (h *ApiHandler) ListTimeseriesMeasurementsByInstrumentGroup(c echo.Context) error {
	igID, err := uuid.Parse(c.Param("instrument_group_id"))
	if err != nil {
		return httperr.MalformedID(err)
	}
	f := db.ProcessMeasurementFilter{InstrumentGroupID: &igID}

	selectMeasurements := selectMeasurementsHandler(h, f, byInstrumentGroupRequest)
	return selectMeasurements(c)
}

// ListTimeseriesMeasurementsExplorer godoc
//
//	@Summary list timeseries measurements for explorer page
//	@Tags explorer
//	@Accept json
//	@Produce json
//	@Param instrument_ids body []uuid.UUID true "array of instrument uuids"
//	@Success 200 {array} map[uuid.UUID][]db.MeasurementCollectionLean
//	@Failure 400 {object} echo.HTTPError
//	@Failure 404 {object} echo.HTTPError
//	@Failure 500 {object} echo.HTTPError
//	@Router /explorer [post]
func (h *ApiHandler) ListTimeseriesMeasurementsExplorer(c echo.Context) error {
	var iIDs []uuid.UUID
	if err := (&echo.DefaultBinder{}).BindBody(c, &iIDs); err != nil {
		return httperr.MalformedBody(err)
	}
	f := db.ProcessMeasurementFilter{InstrumentIDs: iIDs}

	selectMeasurements := selectMeasurementsHandler(h, f, explorerRequest)
	return selectMeasurements(c)
}

func selectMeasurementsHandler(h *ApiHandler, f db.ProcessMeasurementFilter, requestType processTimeseriesType) echo.HandlerFunc {
	return func(c echo.Context) error {
		var tw util.TimeWindow
		a, b := c.QueryParam("after"), c.QueryParam("before")
		if err := tw.SetWindow(a, b, time.Now().AddDate(0, 0, -7), time.Now()); err != nil {
			return httperr.MalformedDateRFC3339(err)
		}

		f.After = tw.After
		f.Before = tw.Before

		experimental := strings.ToLower(c.QueryParam("experimental")) == "true"
		trs := c.QueryParam("threshold")

		var threshold int
		if trs != "" {
			tr, err := strconv.Atoi(trs)
			if err != nil {
				return httperr.Message(http.StatusBadRequest, "query parameter `threshold` must be non-negative int")
			}
			threshold = tr
		}

		var mrc db.ProcessTimeseriesResponseCollection
		var err error
		if experimental {
			mrc, err = h.DBService.ProcessMeasurementListDynamicEXPERIMENTAL(c.Request().Context(), f, threshold)
			if err != nil {
				return httperr.InternalServerError(err)
			}
		} else {
			mrc, err = h.DBService.ProcessMeasurementListDynamic(c.Request().Context(), f)
			if err != nil {
				return httperr.InternalServerError(err)
			}
		}

		if requestType == byTimeseriesRequest && f.TimeseriesID != nil {
			resBody, err := mrc.CollectSingleTimeseries(threshold, *f.TimeseriesID)
			if err != nil {
				return httperr.InternalServerError(err)
			}
			return c.JSON(http.StatusOK, resBody)

		} else {
			resBody, err := mrc.GroupByInstrument(threshold)
			if err != nil {
				return httperr.InternalServerError(err)
			}
			return c.JSON(http.StatusOK, resBody)
		}
	}
}