city_chips/internal/handler/illuminating.go

package handler

import (
	"city_chips/internal/model"
	"city_chips/internal/service"
	"city_chips/pkg/helper/resp"
	"encoding/json"
	"fmt"
	"go.uber.org/zap"
	"math/rand"
	"strconv"
	"time"

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

type IlluminatingHandler struct {
	*Handler
	illuminatingService service.IlluminatingService
	conf                *viper.Viper
}

func NewIlluminatingHandler(
	handler *Handler,
	illuminatingService service.IlluminatingService,
	conf *viper.Viper,
) *IlluminatingHandler {
	return &IlluminatingHandler{
		Handler:             handler,
		illuminatingService: illuminatingService,
		conf:                conf,
	}
}

// 照明系统
func (h *IlluminatingHandler) GetIlluminating(ctx *gin.Context) {
	m := make(map[string]any)
	runAnaly := make(map[string]any)
	var illuminatingDevice []model.IlluminatingDevice
	var eventList []model.EventList
	var runAnalyse model.RunAnalyse
	for i := 0; i < 20; i++ {
		device := model.IlluminatingDevice{
			Id:             i + 1,
			DeviceName:     model.GetRandomItem(model.IlluminatingDeviceNames),
			SwitchStatus:   rand.Intn(2),
			OnlinePresence: rand.Intn(2),
		}
		list := model.EventList{
			Id:           i + 1,
			DeviceName:   model.GetRandomItem(model.LightingEvents),
			DeviceStatus: rand.Intn(2),
			EventDate:    time.Now().Format("2006-01-02 15:04:05"),
		}
		eventList = append(eventList, list)
		illuminatingDevice = append(illuminatingDevice, device)
	}
	for i := 0; i < 7; i++ {
		date := fmt.Sprintf("2025-5-%v", i+1)
		runAnalyse.FaultCount = rand.Intn(100)
		runAnalyse.OpenCount = rand.Intn(100)
		runAnalyse.OffCount = rand.Intn(100)
		runAnaly[date] = runAnalyse
	}
	m["IlluminatingDevice"] = illuminatingDevice //设备列表
	m["DeviceCount"] = rand.Intn(100)            //设备总数
	m["OpenCount"] = rand.Intn(100)              //开启数量
	m["OffCount"] = rand.Intn(100)               //关闭数量
	m["FaultCount"] = rand.Intn(100)             //故障数量
	m["RunAnalyse"] = runAnaly                   //运行分析
	m["EventList"] = eventList                   //事件列表
	resp.HandleSuccess(ctx, m)
}

// 获取灯光状态
func (h *IlluminatingHandler) GetLightingstatus(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()
	type Response struct {
		RequestId string `protobuf:"bytes,1,opt,name=requestId,proto3" json:"requestId,omitempty"`
		Code      int32  `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"`
		Msg       string `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
		Data      any    `json:"data"`
	}
	stationNo := ctx.Query("id")
	if len(stationNo) == 0 {
		resp.HandleError(ctx, 1201, "缺少必要参数", nil)
		return
	}
	var response Response
	for conn {
		select {
		case <-notify:
			conn = false
			fmt.Println("断开连接")
			return
		default:
			// 模拟数据
			data := make(map[string]any)
			response.Code = 200
			response.RequestId = strconv.Itoa(rand.Intn(1000))
			response.Msg = "success"
			data["设备名称"] = model.GetRandomItem(model.IlluminatingDeviceNames)
			data["state"] = rand.Intn(2) // 1开  0关  2故障
			response.Data = data
			res, _ := json.Marshal(&response)
			fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
			ctx.Writer.Flush()
			time.Sleep(10 * time.Second)
		}
	}
}

// 修改灯光状态
func (h *IlluminatingHandler) UpdataLightingStatus(ctx *gin.Context) {
	id := ctx.PostForm("id")
	state := ctx.PostForm("state")

	if len(id) == 0 || len(state) == 0 {
		resp.HandleError(ctx, 1201, "缺少必要参数", nil)
		return
	}
	resp.HandleSuccess(ctx, id)
}

// GetStatistics 获取灯光统计数据
func (h *IlluminatingHandler) GetStatistics(ctx *gin.Context) {
	var statis model.IlluminatingStatistics
	statistics, err := h.illuminatingService.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
	}
	resp.HandleSuccess(ctx, statis)
}
func (h *IlluminatingHandler) 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")
	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil {
		resp.HandleError(ctx, 1203, "参数错误", err)
		return
	}
	query := ctx.PostForm("query")

	baseecic, err := h.illuminatingService.GetBaseecic(currentPage, device_type_id, devices_enabled, pageSize, query)
	if err != nil {
		h.logger.Error("获取统计信息失败", zap.Any("err", err))
		resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
		return
	}

	resp.HandleSuccess(ctx, baseecic)
}