GtDataStore/common/envitem/func.go

package envitem

import (
	"GtDataStore/common/httplib"
	"context"
	"database/sql/driver"
	"encoding/json"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"
)

func SetOptions(options Options) {
	snapUrl = fmt.Sprintf("http://%s/api/v1/plc-current", options.GtServerIp)
	ctlUrl = fmt.Sprintf("http://%s/api/v1/plc/set-var-values", options.GtServerIp)

	if options.Cache != nil {
		cache = options.Cache
	}
}

func (m MultiEnvItem) GetProjectId() int64 {
	for _, item := range m {
		return item.ProjectId
	}
	return 0
}

func (m MultiEnvItem) GetItemNames() []string {
	items := make([]string, 0)
	for _, item := range m {
		items = append(items, item.Item)
	}
	return items
}

func (m MultiEnvItem) FillCurrentValue() error {
	datas, err := m.getCurrentData()
	if err != nil {
		return err
	}
	// 先做一个item -> key的映射
	ikm := make(map[string]string)
	for s, item := range m {
		ikm[item.Item] = s
	}

	for _, data := range datas {
		if k, ok := ikm[data.ItemName]; ok {
			m[k].Value = data.Val
			m[k].Htime = data.HTime
			_ = m[k].setPrevValue()
		}
	}
	return nil
}

func (m MultiEnvItem) GetItemFloat64Value(key string) float64 {
	if envItem, ok := m[key]; ok {
		return envItem.GetItemFloat64Val()
	}
	return 0
}

func (m MultiEnvItem) GetItemInt64Value(key string) int64 {
	if envItem, ok := m[key]; ok {
		return envItem.GetItemInt64Val()
	}
	return 0
}

func (m MultiEnvItem) GetItemStringValue(key string) string {
	if envItem, ok := m[key]; ok {
		return envItem.GetItemStringVal()
	}
	return ""
}

func (m MultiEnvItem) GetCurrentValue(key string) (string, string, error) {
	if envItem, ok := m[key]; ok {
		return envItem.getCurrentValue()
	}
	return "", "", errors.New(key + " not exists")
}

func (m MultiEnvItem) getCurrentData() ([]*ItemValueResp, error) {
	req := httplib.Post(snapUrl)
	data := make([]*ItemValueReq, 1)

	data[0] = &ItemValueReq{
		DeviceItems: strings.Join(m.GetItemNames(), ","),
		ProjectId:   m.GetProjectId(),
	}

	jsonBytes, err := json.Marshal(data)
	if err != nil {
		return nil, err
	}
	req.Body(jsonBytes)
	req.SetTimeout(time.Millisecond * 2000)

	r, err := req.Response()
	if err != nil {
		return nil, err
	}
	defer r.Body.Close()

	if r.StatusCode == 200 {
		resp, err := req.Bytes()
		if err != nil {
			return nil, err
		}

		res := &ItemValueResps{}
		err = json.Unmarshal(resp, res)
		if err != nil {
			return nil, err
		}

		if len(res.Data) == 0 {
			return nil, errors.New("not found envitem's value")
		}

		return res.Data, nil
	}

	return nil, errors.New(fmt.Sprintf("request statusCode: %d", r.StatusCode))
}

func (e *EnvItem) getCurrentData() (*ItemValueResp, error) {
	req := httplib.Post(snapUrl)
	data := make([]*ItemValueReq, 1)

	data[0] = &ItemValueReq{
		DeviceItems: e.Item,
		ProjectId:   e.ProjectId,
	}

	jsonBytes, err := json.Marshal(data)
	if err != nil {
		return nil, err
	}
	req.Body(jsonBytes)
	req.SetTimeout(time.Millisecond * 2000)

	r, err := req.Response()
	if err != nil {
		return nil, err
	}
	defer r.Body.Close()

	if r.StatusCode == 200 {
		resp, err := req.Bytes()
		if err != nil {
			return nil, err
		}

		res := &ItemValueResps{}
		err = json.Unmarshal(resp, res)
		if err != nil {
			return nil, err
		}

		if len(res.Data) == 0 {
			return nil, errors.New("not found envitem's value")
		}

		return res.Data[0], nil
	}

	return nil, errors.New(fmt.Sprintf("request statusCode: %d", r.StatusCode))
}

func (e *EnvItem) getCurrentValue() (string, string, error) {
	resp, err := e.getCurrentData()
	if err != nil {
		return "", "", err
	}

	e.Value = resp.Val
	e.Htime = resp.HTime
	_ = e.setPrevValue()

	return resp.Val, resp.HTime, nil
}

func (e *EnvItem) getPrevValue() (string, string, error) {
	if cache == nil {
		return "", "", errors.New("not cache")
	}
	key := fmt.Sprintf(CACHE_PREV_VALUE_KEY, e.ProjectId, e.Item)
	if cmd := cache.Get(context.Background(), key); cmd != nil {
		n := strings.Split(cmd.Val(), "|")
		if len(n) != 2 {
			return "", "", errors.New("getPrevValue cache length error")
		}
		return n[0], n[1], nil
	} else {
		return "", "", cmd.Err()
	}
}

func (e *EnvItem) setPrevValue() error {
	if cache == nil {
		return errors.New("not cache")
	}
	key := fmt.Sprintf(CACHE_PREV_VALUE_KEY, e.ProjectId, e.Item)
	value := fmt.Sprintf("%s|%s", e.Value, e.Htime)
	if statusCmd := cache.Set(context.Background(), key, value, CACHE_PREV_VALUE_KEY_EXPIRE); statusCmd != nil {
		return nil
	} else {
		return errors.New("setPrevValue error")
	}
}

func (e *EnvItem) GetItemFloat64Val() float64 {
	if e.Value == nil {
		e.getCurrentValue()
	}

	if v, ok := e.Value.(float64); ok {
		return v
	}

	return 0
}

func (e *EnvItem) GetItemInt64Val() int64 {
	if e.Value == nil {
		e.getCurrentValue()
	}

	if v, ok := e.Value.(int64); ok {
		return v
	}

	return 0
}

func (e *EnvItem) GetItemStringVal() string {
	if e.Value == nil {
		e.getCurrentValue()
	}

	if v, ok := e.Value.(string); ok {
		return v
	}

	return ""
}

func (e *EnvItem) GetItemHtime() *time.Time {
	if e.Value == nil {
		e.getCurrentValue()
	}

	if ht, err := time.ParseInLocation("2006-01-02 15:04:05", e.Htime, time.Local); err == nil {
		return &ht
	}
	return nil
}

func (e *EnvItem) GetItemPrevFloat64Val() float64 {
	ov, _, err := e.getPrevValue()
	if err != nil {
		return 0
	}

	if v, err := strconv.ParseFloat(ov, 64); err == nil {
		return v
	}

	return 0
}

func (e *EnvItem) GetItemPrevInt64Val() int64 {
	ov, _, err := e.getPrevValue()
	if err != nil {
		return 0
	}

	if v, err := strconv.ParseInt(ov, 10, 64); err == nil {
		return v
	}

	return 0
}

func (e *EnvItem) GetItemPrevStringVal() string {
	ov, _, _ := e.getPrevValue()
	return ov
}

func (e *EnvItem) GetItemPrevHtime() *time.Time {
	_, ht, _ := e.getPrevValue()
	if t, err := time.ParseInLocation("2006-01-02 15:04:05", ht, time.Local); err == nil {
		return &t
	}
	return nil
}

// Scan 实现方法
func (d *MultiEnvItem) Scan(input interface{}) error {
	_ = json.Unmarshal(input.([]byte), &d)
	return nil
}

func (d MultiEnvItem) Value() (driver.Value, error) {
	return json.Marshal(d)
}