dataRT/route/api/point.go

package api

import (
	"datart/data"
	"datart/data/influx"
	"datart/data/postgres"
	"datart/log"
	"datart/util"
	"errors"
	"fmt"
	"strings"

	"github.com/gin-gonic/gin"
)

func (a *Api) GetPoints(ctx *gin.Context) {
	request, err := a.checkAndGenGetPointsRequest(ctx)
	if err != nil {

		log.Error(err)

		ctx.JSON(200, gin.H{
			"code": 1,
			"msg":  err.Error(),
		})
		return
	}

	var ftvs map[string][]influx.TV
	switch {
	case request.Begin > 0 && request.End > 0:
		ftvs, err = influx.GetSSUPointsDurationData(ctx.Request.Context(), request)

	case request.Begin > 0 && request.End < 0:
		ftvs, err = influx.GetSSUPointsAfterLimit(ctx.Request.Context(), request, 1)

	case request.Begin < 0 && request.End > 0:
		ftvs, err = influx.GetSSUPointsBeforeLimit(ctx.Request.Context(), request, 1)

	default:
		ftvs, err = influx.GetSSUPointsLastLimit(ctx.Request.Context(), request, 1)
	}

	if err != nil {

		log.Error(err, fmt.Sprintf(" params: %v", request))

		ctx.JSON(200, gin.H{
			"code": 2,
			"msg":  "query database error",
		})
		return
	}

	// handle key value
	v, _ := postgres.ChannelSizes.Load(request.Tags[len(request.Tags)-1])
	if channelSize, ok := v.(postgres.ChannelSize); ok {
		for f, tvs := range ftvs {
			for i := range tvs {
				tvs[i].Value = data.ToPrimary(f, tvs[i].Value,
					channelSize.IRatio, channelSize.URatio, channelSize.IPolar)
			}
		}
	}

	ctx.JSON(200, gin.H{
		"code": 0,
		"msg":  "success",
		"data": ftvs,
	})
}

func (a *Api) checkAndGenGetPointsRequest(ctx *gin.Context) (*influx.Request, error) {

	typeStr := ctx.DefaultQuery("type", "")
	if len(typeStr) <= 0 {
		return nil, errors.New("invalid type")
	}

	station, mainPos, subPos := "", "", ""

	tags := strings.Split(ctx.DefaultQuery("mtag", ""), ".")
	v, ok := postgres.ChannelSizes.Load(tags[len(tags)-1])
	if ok {
		if channelSize, ok := v.(postgres.ChannelSize); ok {
			fields := data.GenPhasorFields(channelSize.Channel)

			station = channelSize.Station
			mainPos = channelSize.Device
			subPos = strings.Join(fields, ",")
		}
	} else {
		return nil, errors.New("invalid mtag")
	}

	beginStr := ctx.DefaultQuery("begin", "")

	endStr := ctx.DefaultQuery("end", "")

	operate := ctx.DefaultQuery("operate", "")

	step := ctx.DefaultQuery("step", "")

	defaultV := ctx.DefaultQuery("default", "")

	begin := util.ConvertToInt64Default(beginStr, -1)

	end := util.ConvertToInt64Default(endStr, -1)

	bucket, err := influx.GetDB(typeStr)
	if err != nil {
		return nil, err
	}

	measure, err := influx.GetTable(typeStr, mainPos)
	if err != nil {
		return nil, err
	}

	return &influx.Request{
		DB:    bucket,
		Table: measure,
		Tags:  tags,

		Type:    typeStr,
		Station: station,
		MainPos: mainPos,
		SubPos:  subPos,
		Begin:   begin,
		End:     end,
		Operate: operate,
		Step:    step,
		Default: defaultV,
	}, nil
}