city_chips/internal/handler/temperature.go

package handler

import (
	"city_chips/internal/model"
	"city_chips/internal/service"
	"city_chips/pkg/helper/resp"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/spf13/viper"
	"github.com/tidwall/gjson"
	"go.uber.org/zap"
	"strconv"
	"time"
)

type TemperatureHandler struct {
	*Handler
	temperatureService service.TemperatureService
	conf               *viper.Viper
}

func NewTemperatureHandler(
	handler *Handler,
	temperatureService service.TemperatureService,
	conf *viper.Viper,
) *TemperatureHandler {
	return &TemperatureHandler{
		Handler:            handler,
		temperatureService: temperatureService,
		conf:               conf,
	}
}

func (h *TemperatureHandler) GetTemperature(ctx *gin.Context) {
	m := make(map[string]any)
	var alarmstatistics model.AlarmStatistics
	var alarmCount model.AlarmCount
	var statis model.IlluminatingStatistics

	now := time.Now()
	sevenDaysAgo := now.AddDate(0, 0, -30).Format("2006-01-02")
	format := now.Format("2006-01-02")
	alarmStatistics, err := h.temperatureService.GetAlarmStatistics(sevenDaysAgo, format)
	if err != nil {
		h.logger.Error("获取告警信息统计失败", zap.Any("err", err))
		resp.HandleError(ctx, 1204, "获取告警信息统计失败", nil)
		return
	}
	err = json.Unmarshal(alarmStatistics, &alarmstatistics)
	if err != nil {
		h.logger.Error("json反序列化失败")
		resp.HandleError(ctx, 1205, "json序列化失败", nil)
		return
	}
	alarm, err := h.temperatureService.GetAlarm(1, 100)
	if err != nil {
		h.logger.Error("获取告警信息失败", zap.Any("err", err))
		resp.HandleError(ctx, 1203, "获取告警信息失败", nil)
		return
	}
	err = json.Unmarshal(alarm, &alarmCount)
	if err != nil {
		h.logger.Error("json反序列化失败")
		resp.HandleError(ctx, 1205, "json序列化失败", nil)
		return
	}
	statistics, err := h.temperatureService.GetStatistics()
	if err != nil {
		h.logger.Error("获取统计信息失败", zap.Any("err", err))
		resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
		return
	}
	err = json.Unmarshal(statistics, &statis)
	if err != nil {
		h.logger.Error("json反序列化失败")
		resp.HandleError(ctx, 1202, "json反序列化失败", nil)
		return
	}
	for i, _ := range alarmstatistics.TimeStatistics {
		s := alarmstatistics.TimeStatistics[i].TimeDay.Format("2006-01-02 15:04:05")
		alarmstatistics.TimeStatistics[i].Time = s
	}
	baseecic, err := h.temperatureService.GetBaseecic(1, 0, -1, 0, statis.DeviceCount, "", "")
	if err != nil {
		h.logger.Error("获取 basement_ecic 列表失败", zap.Any("err", err))
		resp.HandleError(ctx, 1202, "获取 basement_ecic 列表失败", nil)
		return
	}
	deviceStatistics, err := h.temperatureService.GetGatewayStatistics()
	if err != nil {
		h.logger.Error("获取设备统计失败", zap.Any("err", err))
		resp.HandleError(ctx, 1202, "获取设备统计失败", nil)
		return
	}

	m["temperatureDevice"] = baseecic.Devices             //设备列表
	m["DeviceCount"] = statis.DeviceCount                 //设备总数
	m["GatewayCount"] = statis.GatewayCount               //网关数量
	m["GatewayOnline"] = deviceStatistics.GatewayOnline   //网关在线数量
	m["GatewayOffline"] = deviceStatistics.GatewayOffline //网关离线数量
	m["DeviceOnLine"] = deviceStatistics.DeviceOnline     //设备在线数量
	m["DeviceOffLine"] = deviceStatistics.DeviceOffline   //设备离线数量
	m["AlarmCount"] = statis.AlarmCount                   //报警数量
	m["RunAnalyse"] = alarmstatistics.TimeStatistics      //报警统计分析
	m["EventList"] = alarmCount                           //报警事件
	resp.HandleSuccess(ctx, m)
}

// GetBaseecic 获取设备列表
func (h *TemperatureHandler) GetBaseecic(ctx *gin.Context) {
	currentPageStr := ctx.PostForm("currentPage")
	currentPage, err := strconv.Atoi(currentPageStr)
	device_type_idStr := ctx.PostForm("device_type_id")
	device_type_id, err := strconv.Atoi(device_type_idStr)
	devices_enabledStr := ctx.PostForm("devices_enabled")
	devices_enabled, err := strconv.Atoi(devices_enabledStr)
	pageSizeStr := ctx.PostForm("pageSize")
	gatewayStr := ctx.PostForm("gateway_id")
	gateway_id, err := strconv.Atoi(gatewayStr)
	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil {
		resp.HandleError(ctx, 1203, "参数错误", err)
		return
	}
	query := ctx.PostForm("query")
	baseecic, err := h.temperatureService.GetBaseecic(currentPage, device_type_id, devices_enabled, gateway_id, pageSize, query, "")
	if err != nil {
		h.logger.Error("获取统计信息失败", zap.Any("err", err))
		resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
		return
	}

	resp.HandleSuccess(ctx, baseecic)
}

// GetgatewayFind 获取网关信息
func (h *TemperatureHandler) GetgatewayFind(ctx *gin.Context) {
	gateway, err := h.temperatureService.GetgatewayFind()
	if err != nil {
		h.logger.Error("获取统计信息失败", zap.Any("err", err))
		resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
		return
	}
	resp.HandleSuccess(ctx, gateway)
	h.logger.Info("获取统计信息成功", zap.Any("control", gateway))
}

// GetTemperatureInfo  获取温度详情
func (h *TemperatureHandler) GetTemperatureInfo(ctx *gin.Context) {
	// 设置响应头
	ctx.Header("Content-Type", "text/event-stream")
	ctx.Header("Cache-Control", "no-cache")
	ctx.Header("Connection", "keep-alive")
	// 监听客户端断开连接
	conn := true
	notify := ctx.Writer.CloseNotify()
	var response model.Response
	m := make(map[string]any)
	devices_udid := ctx.Query("id")
	for conn {
		select {
		case <-notify:
			conn = false
			fmt.Println("断开连接")
			return
		default:
			baseecic, err := h.temperatureService.GetBaseecic(1, 0, -1, 0, 1, "", devices_udid)
			if err != nil {
				h.logger.Error("获取设备信息详情失败")
				response.Code = 1203
				response.Msg = "获取设备信息详情失败"
				response.Data = nil
				res, _ := json.Marshal(&response)
				fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
				ctx.Writer.Flush()
				conn = false
				return
			}
			m["设备名称"] = baseecic.Devices[0].DevicesName
			m["温度设定上限"] = gjson.Get(baseecic.Devices[0].DevicesJsonObject, "temp_max").Num
			m["温度设定下限"] = gjson.Get(baseecic.Devices[0].DevicesJsonObject, "temp_min").Num
			m["当前温度"] = gjson.Get(baseecic.Devices[0].DevicesJsonObject, "dis_temp").Num
			response.Code = 200
			response.Msg = "获取设备信息成功"
			response.Data = m
			res, _ := json.Marshal(&response)
			fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
			ctx.Writer.Flush()
			time.Sleep(10 * time.Second)
		}
	}
}