照明定时策略，控制api对接

cmd/server/wire/wire.go

@@ -68,7 +68,7 @@ var HandlerSet = wire.NewSet(
 )
 
 func provideHTTPClient() *http.Client {
-	return http.DefaultClient // 或者你可以自定义 client
+	return http.DefaultClient
 }
 func NewWire(*viper.Viper, *log.Logger) (*gin.Engine, func(), error) {
 	panic(wire.Build(

cmd/server/wire/wire_gen.go

@@ -54,7 +54,7 @@ func NewWire(viperViper *viper.Viper, logger *log.Logger) (*gin.Engine, func(),
 	illuminatingService := service.NewIlluminatingService(serviceService, illuminatingRepository, viperViper, client)
 	illuminatingHandler := handler.NewIlluminatingHandler(handlerHandler, illuminatingService, viperViper)
 	energyRepository := repository.NewEnergyRepository(repositoryRepository)
-	energyService := service.NewEnergyService(serviceService, energyRepository)
+	energyService := service.NewEnergyService(serviceService, energyRepository, viperViper, client)
 	energyHandler := handler.NewEnergyHandler(handlerHandler, energyService, viperViper)
 	intelligentBuildingControlRepository := repository.NewIntelligentBuildingControlRepository(repositoryRepository)
 	intelligentBuildingControlService := service.NewIntelligentBuildingControlService(serviceService, intelligentBuildingControlRepository)

config/local.yml

@@ -108,10 +108,37 @@ illuminating:
     statistics: "/baseecic/v1/baseecic/all/statistics" #统计
     baseecic: "/baseecic/v2/device/all"#所有设备
     alarm: "/maintain/v2/maintain/alarm/message/find" #报警
-    deviceStatistics: "/device/v2/base/device/category/statistics" #设备统计
+    deviceStatistics: "/device/v2/base/device/category/statistics" #设备类型统计
     alarmStatistics: "/maintain/v3/maintain/alarm/message/statistics" #报警统计
     gatewayFind: "/baseecic/v2/base/gateway/find/gateway" #网关
     devicesControl: "/device/v1/base/devices/control/one" #设备控制
     deviceOrgid: "/device/v1/cust/scene/timing/page/orgid"# 设备策略列表
+    getBuildingRegionRoomTree: "/baseecic/v1/base/region/getBuildingRegionRoomTree" #获取建筑区域树
+    categoryPart: "/device/v2/base/device/category/part" #设备类别部件
+    typeFind: "/device/v2/base/device/type/find" #设备类别
+    deviceAllMini: "/baseecic/v3/device/all/mini" #获取设备型号
+    timingSave: "/device/v1/cust/scene/timing/save" #保存定时任务
+    changeState: "/device/v2/cust/scene/timing/change/state" #修改定时任务状态
+    timingId: "/device/v1/cust/scene/timing/id" #定时任务详情
+
+energy:
+  authorization: "Basic ZWNpYzo1MzZmN2VkNGE1MTNiODMzMTI3N2IwMzVkZDE2ODExZg=="
+  clientId: 3
+  mobile: "admin"
+  password: "123456"
+  baseUrl: "http://182.43.247.65:8092"
+  api:
+    login: "/user/v1/user/user/login"
+    statistics: "/baseecic/v1/baseecic/all/statistics" #统计
+    baseecic: "/baseecic/v2/device/all"#所有设备
+    alarm: "/maintain/v2/maintain/alarm/message/find" #报警
+    deviceStatistics: "/device/v2/base/device/category/statistics" #设备类型统计
+    alarmStatistics: "/maintain/v3/maintain/alarm/message/statistics" #报警统计
+    gatewayFind: "/baseecic/v2/base/gateway/find/gateway" #网关
+    energyTrend: "/energy/v2/erg/trend" # 能源趋势
+    energyTree: "/energy/v2/erg/packing/energyTree" #能源树
+    dayAndNight: "/energy/v2/erg/trend/dayAndNight" # 日夜能耗分析
+    hisData: "/baseecic/v1/device/his/data" #历史数据
+
 
 

docker-compose.yml

@@ -0,0 +1,31 @@
+# docker-compose.yml
+services:
+  gitea:
+    image: gitea/gitea:1
+    container_name: gitea
+    restart: always
+    ports:
+      - 8081:8081
+    environment:
+      - TZ=Asia/Shanghai
+      - USER_UID=1000
+      - USER_GID=1000
+    volumes:
+      - ./data:/data
+
+  runner:
+    image: gitea/act_runner:latest
+    container_name: gitea-runner
+    restart: always
+    depends_on:
+      - gitea
+    environment:
+      - CONFIG_FILE=/config.yaml
+      - GITEA_INSTANCE_URL=http://gitea:3000
+      - GITEA_RUNNER_REGISTRATION_TOKEN=aeymtYQDlRfj3Zh1Q3hUD1UAjfEWZhvtEPWi48kB
+      - GITEA_RUNNER_NAME=gitea-runner
+    volumes:
+      - ./config.yaml:/config.yaml
+      - ./data:/data
+      - ./cache:/root
+      - /var/run/docker.sock:/var/run/docker.sock

internal/handler/energy.go

@@ -1,12 +1,15 @@
 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"
+	"strings"
 	"time"
 
 	"github.com/gin-gonic/gin"
@@ -52,27 +55,201 @@ func (h *EnergyHandler) GetEnergy(ctx *gin.Context) {
 		LastYearCarbonEmissions[name] = rand.Intn(1000)
 		YearCarbonEmissions[name] = rand.Intn(1000)
 	}
-	m["PowerConsumption"] = rand.Intn(1000)                    //今日实时电耗
-	m["WaterConsumption"] = rand.Intn(1000)                    //今日实时水耗
-	m["YesterdayConsumption"] = rand.Intn(1000)                //昨日电耗
-	m["MonthElectricityConsumption"] = rand.Intn(1000)         //本月电耗
-	m["YesterdayWaterConsumption"] = rand.Intn(1000)           //昨日水耗
-	m["MonthWaterConsumption"] = rand.Intn(1000)               //本月水耗
-	m["OnedayPowerConsumption"] = OnedayPowerConsumption       //本月水耗
-	m["OnedayWaterConsumption"] = OnedayWaterConsumption       //本月水耗
-	m["EnergyCount"] = rand.Intn(10000)                        //能源总量
-	m["EnergyIntensity"] = rand.Intn(1000)                     //能耗强度
-	m["CarbonEmissions"] = rand.Intn(1000)                     //碳排总量
-	m["CarbonIsntensity"] = rand.Intn(1000)                    //碳排强度
-	m["LastYearEnergyConsumption"] = LastYearEnergyConsumption //去年能耗
-	m["YearEnergyConsumption"] = YearEnergyConsumption         //今年能耗
-	m["LastYearCarbonEmissions"] = LastYearCarbonEmissions     //去年碳排
-	m["YearCarbonEmissions"] = YearCarbonEmissions             //今年碳排
+	getStatistics, err := h.energyService.GetStatistics()
+	if err != nil {
+		resp.HandleError(ctx, 1201, "缺少必要参数", nil)
+		return
+	}
+	tree, err := h.energyService.GetEnergyTree()
+	if err != nil {
+		resp.HandleError(ctx, 1201, "缺少必要参数", nil)
+		return
+	}
+	now := time.Now()
+	start_time := now.AddDate(0, 0, -7).Format("2006-01-02 00:00:00")
+	end_time := now.Format("2006-01-02 00:00:00")
+	var water, electricity model.T
+	var waterResp, electricityResp []model.EnergyTrend
+	var electricityNight, waterNight model.DayAndNightRespone
+	waterCount := make(map[string]any)
+	electricityCount := make(map[string]any)
+	for _, child := range tree.Data[0].Children {
+		if strings.Contains(child.Name, "电") {
+			electricity, err = h.energyService.GetEnergyTrend(model.Request{
+				TimeType:  "day",
+				Nodes:     []int{child.Id},
+				StartTime: start_time,
+				EndTime:   end_time,
+			})
+			if err != nil {
+				resp.HandleError(ctx, 1201, "获取电耗能源趋势失败", nil)
+				return
+			}
+			electricityNight, err = h.energyService.GetDayAndNight(model.DayAndNightRequst{
+				TimeType:  "day",
+				Node:      child.Id,
+				StartTime: start_time,
+				EndTime:   end_time,
+				DayTime:   "09:00",
+				NightTime: "18:00",
+			})
+			if err != nil {
+				resp.HandleError(ctx, 1201, "获取电耗夜耗失败", nil)
+				return
+			}
+		}
+		if strings.Contains(child.Name, "水") {
+			water, err = h.energyService.GetEnergyTrend(model.Request{
+				TimeType:  "day",
+				Nodes:     []int{child.Id},
+				StartTime: start_time,
+				EndTime:   end_time,
+			})
+			if err != nil {
+				resp.HandleError(ctx, 1201, "获取水耗能源趋势失败", nil)
+				return
+			}
+			waterNight, err = h.energyService.GetDayAndNight(model.DayAndNightRequst{
+				TimeType:  "day",
+				Node:      child.Id,
+				StartTime: start_time,
+				EndTime:   end_time,
+				DayTime:   "09:00",
+				NightTime: "18:00",
+			})
+			if err != nil {
+				resp.HandleError(ctx, 1201, "获取水耗夜耗失败", nil)
+				return
+			}
+		}
+	}
+	err = json.Unmarshal([]byte(water.RespJson), &waterResp)
+	err = json.Unmarshal([]byte(electricity.RespJson), &electricityResp)
+	if err != nil {
+		resp.HandleError(ctx, 1202, "json反序列化失败", nil)
+		return
+	}
+	for _, trend := range waterResp[0].Json {
+		waterCount[trend.Time] = trend.TotalUsage
+	}
+	for _, trend := range electricityResp[0].Json {
+		electricityCount[trend.Time] = trend.TotalUsage
+	}
+
+	m["DeviceCount"] = getStatistics.DeviceCount               //设备总数
+	m["GatewayCount"] = getStatistics.GatewayCount             //网关总数
+	m["AlarmCount"] = getStatistics.AlarmCount                 //报警总数
+	m["MonthElectricityConsumption"] = getStatistics.RoomCount // 房间总数
+	//m["YesterdayWaterConsumption"] = rand.Intn(1000)           //昨日水耗
+	//m["MonthWaterConsumption"] = rand.Intn(1000)               //本月水耗
+	//m["OnedayPowerConsumption"] = OnedayPowerConsumption       //本月水耗
+	m["OnedayWaterConsumption"] = OnedayWaterConsumption //本月水耗
+	//m["EnergyCount"] = rand.Intn(10000)                        //能源总量
+	//m["EnergyIntensity"] = rand.Intn(1000)                     //能耗强度
+	//m["CarbonEmissions"] = rand.Intn(1000)                     //碳排总量
+	//m["CarbonIsntensity"] = rand.Intn(1000)                    //碳排强度
+	//m["LastYearEnergyConsumption"] = LastYearEnergyConsumption //去年能耗
+	//m["YearEnergyConsumption"] = YearEnergyConsumption         //今年能耗
+	m["electricityNight"] = electricityNight.Data //昼夜用电分析
+	m["waterNight"] = waterNight.Data             //昼夜用水分析
+	m["electricityCount"] = electricityCount      //用电统计
+	m["waterCount"] = waterCount                  //用水统计
 	resp.HandleSuccess(ctx, m)
 }
 
-// 水表数据
-func (h *EnergyHandler) GetWaterMmeter(ctx *gin.Context) {
+// GetEnergyTrend 获取能耗趋势
+func (h *EnergyHandler) GetEnergyTrend(ctx *gin.Context) {
+	var rest model.Request
+	var tre []model.EnergyTrend
+	var waterResp []model.EnergyTrend
+
+	err := ctx.ShouldBindJSON(&rest)
+	if err != nil {
+		h.logger.Error("参数错误", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "参数错误", nil)
+		return
+	}
+	trend, err := h.energyService.GetEnergyTrend(rest)
+	if err != nil {
+		h.logger.Error("获取能耗趋势失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取能耗趋势失败", nil)
+	}
+	err = json.Unmarshal([]byte(trend.RespJson), &tre)
+	if err != nil {
+		h.logger.Error("json反序列化失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1202, "json反序列化失败", nil)
+		return
+	}
+	err = json.Unmarshal([]byte(trend.RespJson), &waterResp)
+	if err != nil {
+		h.logger.Error("json反序列化失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1202, "json反序列化失败", nil)
+		return
+	}
+	resp.HandleSuccess(ctx, waterResp)
+
+}
+
+// GetBaseecic 获取能耗设备列表
+func (h *EnergyHandler) 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.energyService.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 *EnergyHandler) GetgatewayFind(ctx *gin.Context) {
+	gateway, err := h.energyService.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))
+
+}
+
+// GetDayAndNight 获取日夜数据
+func (h *EnergyHandler) GetDayAndNight(ctx *gin.Context) {
+	var rest model.DayAndNightRequst
+	err := ctx.ShouldBindJSON(&rest)
+	if err != nil {
+		h.logger.Error("参数错误", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "参数错误", nil)
+	}
+	night, err := h.energyService.GetDayAndNight(rest)
+	if err != nil {
+		h.logger.Error("获取获取网关信息失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取网关信息失败", nil)
+		return
+	}
+	resp.HandleSuccess(ctx, night)
+	h.logger.Info("获取网关信息成功", zap.Any("night", night))
+}
+
+// GetEnergystatus 获取设备状态详情
+func (h *EnergyHandler) GetEnergystatus(ctx *gin.Context) {
 	// 设置响应头
 	ctx.Header("Content-Type", "text/event-stream")
 	ctx.Header("Cache-Control", "no-cache")
@@ -80,18 +257,79 @@ func (h *EnergyHandler) GetWaterMmeter(ctx *gin.Context) {
 	// 监听客户端断开连接
 	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"`
+	var response model.Response
+	m := make(map[string]any)
+	// 使用 map[string]interface{} 来接收未知结构的 JSON 对象
+	var data model.DevicesJsonObject
+	devices_udid := ctx.Query("devices_udid")
+	for conn {
+		select {
+		case <-notify:
+			conn = false
+			fmt.Println("断开连接")
+			return
+		default:
+			baseecic, err := h.energyService.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["state"] = baseecic.Devices[0].OnLine
+			err = json.Unmarshal([]byte(baseecic.Devices[0].DevicesJsonObject), &data)
+			if err != nil {
+				h.logger.Error("json反序列化失败")
+				response.Code = 1202
+				response.Msg = "json反序列化失败"
+				response.Data = nil
+				res, _ := json.Marshal(&response)
+				fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
+				conn = false
+			}
+			m["总水量"] = data.EPE
+			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)
+		}
 	}
-	stationNo := ctx.Query("id")
-	if len(stationNo) == 0 {
-		resp.HandleError(ctx, 1201, "缺少必要参数", nil)
+}
+
+// CategoryStatistics 获取设备类型统计
+func (h *EnergyHandler) CategoryStatistics(ctx *gin.Context) {
+	statistics, err := h.energyService.GetDeviceStatistics()
+	if err != nil {
+		h.logger.Error("获取设备类型统计失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取设备类型统计失败", nil)
 		return
 	}
-	var response Response
+	resp.HandleSuccess(ctx, statistics)
+}
+
+// 水表数据
+func (h *EnergyHandler) GetWaterMmeter(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)
+	// 使用 map[string]interface{} 来接收未知结构的 JSON 对象
+	var data model.TotalWater
+	devices_udid := ctx.Query("id")
 	for conn {
 		select {
 		case <-notify:
@@ -99,15 +337,34 @@ func (h *EnergyHandler) GetWaterMmeter(ctx *gin.Context) {
 			fmt.Println("断开连接")
 			return
 		default:
-			// 模拟数据
-			data := make(map[string]any)
+			baseecic, err := h.energyService.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["state"] = baseecic.Devices[0].OnLine
+			err = json.Unmarshal([]byte(baseecic.Devices[0].DevicesJsonObject), &data)
+			if err != nil {
+				h.logger.Error("json反序列化失败")
+				response.Code = 1202
+				response.Msg = "json反序列化失败"
+				response.Data = nil
+				res, _ := json.Marshal(&response)
+				fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
+				conn = false
+			}
+			m["总水量"] = data.TotalWater
 			response.Code = 200
-			response.RequestId = strconv.Itoa(rand.Intn(1000))
-			response.Msg = "success"
-			data["今日用水"] = rand.Intn(1000)
-			data["昨日用水"] = rand.Intn(1000)
-			data["本月用水量"] = rand.Intn(1000)
-			response.Data = data
+			response.Msg = "获取设备信息成功"
+			response.Data = m
 			res, _ := json.Marshal(&response)
 			fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
 			ctx.Writer.Flush()
@@ -125,18 +382,11 @@ func (h *EnergyHandler) GetAmmeter(ctx *gin.Context) {
 	// 监听客户端断开连接
 	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
+	var response model.Response
+	m := make(map[string]any)
+	// 使用 map[string]interface{} 来接收未知结构的 JSON 对象
+	var data model.DevicesJsonObject
+	devices_udid := ctx.Query("id")
 	for conn {
 		select {
 		case <-notify:
@@ -144,15 +394,34 @@ func (h *EnergyHandler) GetAmmeter(ctx *gin.Context) {
 			fmt.Println("断开连接")
 			return
 		default:
-			// 模拟数据
-			data := make(map[string]any)
+			baseecic, err := h.energyService.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["state"] = baseecic.Devices[0].OnLine
+			err = json.Unmarshal([]byte(baseecic.Devices[0].DevicesJsonObject), &data)
+			if err != nil {
+				h.logger.Error("json反序列化失败")
+				response.Code = 1202
+				response.Msg = "json反序列化失败"
+				response.Data = nil
+				res, _ := json.Marshal(&response)
+				fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
+				conn = false
+			}
+			m["总有攻电能(kW·h)"] = data.EPE
 			response.Code = 200
-			response.RequestId = strconv.Itoa(rand.Intn(1000))
-			response.Msg = "success"
-			data["今日用电量"] = rand.Intn(1000)
-			data["昨日用电量"] = rand.Intn(1000)
-			data["本月用水量"] = rand.Intn(1000)
-			response.Data = data
+			response.Msg = "获取设备信息成功"
+			response.Data = m
 			res, _ := json.Marshal(&response)
 			fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
 			ctx.Writer.Flush()
@@ -160,6 +429,42 @@ func (h *EnergyHandler) GetAmmeter(ctx *gin.Context) {
 		}
 	}
 }
+
+// GetHisData 获取历史数据
+func (h *EnergyHandler) GetHisData(ctx *gin.Context) {
+	dev_udid := ctx.Query("dev_udid")
+	start_time := ctx.Query("start_time")
+	end_time := ctx.Query("end_time")
+	data_size := ctx.Query("data_size")
+	data_type := ctx.Query("data_type")
+	cuerrentPage := ctx.Query("cuerrentPage")
+	pageSize := ctx.Query("pageSize")
+	is_page := ctx.Query("is_page")
+	if len(data_size) == 0 {
+		data_size = "1"
+	}
+	if len(data_type) == 0 {
+		data_type = "1"
+	}
+	if len(is_page) == 0 {
+		is_page = "1"
+	}
+	start, err := time.Parse("2006-01-02 15:04:05", start_time)
+	end, err := time.Parse("2006-01-02 15:04:05", end_time)
+	if err != nil {
+		resp.HandleError(ctx, 1201, "时间格式错误", nil)
+		return
+	}
+	start_time = start.Format("2006-01-02 15:04:05")
+	end_time = end.Format("2006-01-02 15:04:05")
+	data, err := h.energyService.GetHisData(dev_udid, start_time, end_time, data_size, data_type, cuerrentPage, pageSize, is_page)
+	if err != nil {
+		resp.HandleError(ctx, 1201, err.Error(), nil)
+		return
+	}
+	resp.HandleSuccess(ctx, data)
+}
+
 func (h *EnergyHandler) GetTemperature(ctx *gin.Context) {
 	// 设置响应头
 	ctx.Header("Content-Type", "text/event-stream")

internal/handler/illuminating.go

@@ -41,7 +41,7 @@ func (h *IlluminatingHandler) GetIlluminating(ctx *gin.Context) {
 	var statis model.IlluminatingStatistics
 
 	now := time.Now()
-	sevenDaysAgo := now.AddDate(0, 0, -7).Format("2006-01-02")
+	sevenDaysAgo := now.AddDate(0, 0, -30).Format("2006-01-02")
 	format := now.Format("2006-01-02")
 	alarmStatistics, err := h.illuminatingService.GetAlarmStatistics(sevenDaysAgo, format)
 	if err != nil {
@@ -170,13 +170,6 @@ func (h *IlluminatingHandler) GetStatistics(ctx *gin.Context) {
 		resp.HandleError(ctx, 1202, "json反序列化失败", nil)
 		return
 	}
-	alarm, err := h.illuminatingService.GetAlarm(1, 20)
-	if err != nil {
-		h.logger.Error("获取告警信息失败", zap.Any("err", err))
-		resp.HandleError(ctx, 1203, "获取告警信息失败", nil)
-		return
-	}
-	fmt.Println("报警信息统计", string(alarm))
 	resp.HandleSuccess(ctx, statis)
 }
 func (h *IlluminatingHandler) GetBaseecic(ctx *gin.Context) {
@@ -272,7 +265,7 @@ func (h *IlluminatingHandler) GetLightingstatus(ctx *gin.Context) {
 				return
 			}
 			m["设备名称"] = baseecic.Devices[0].DevicesName
-			m["state"] = baseecic.Devices[0].GatewayStatus
+			m["state"] = baseecic.Devices[0].OnLine
 			err = json.Unmarshal([]byte(baseecic.Devices[0].DevicesJsonObject), &data)
 			if err != nil {
 				h.logger.Error("json反序列化失败")
@@ -343,3 +336,134 @@ func (h *IlluminatingHandler) GetDeviceOrgid(ctx *gin.Context) {
 	resp.HandleSuccess(ctx, response)
 	h.logger.Info("获取照明定时策略成功", zap.Any("control", response))
 }
+
+// GetBuildingRegionRoomTree 获取建筑区域房间树
+func (h *IlluminatingHandler) GetBuildingRegionRoomTree(ctx *gin.Context) {
+	building_id := ctx.Query("building_id")
+	region_parent_id := ctx.Query("region_parent_id")
+	var response model.GetBuildingRegionRoomTree
+	control, err := h.illuminatingService.GetBuildingRegionRoomTree(building_id, region_parent_id)
+	if err != nil {
+		h.logger.Error("获取建筑区域房间树失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取建筑区域房间树失败", nil)
+		return
+	}
+	err = json.Unmarshal(control, &response)
+	if err != nil {
+		h.logger.Error("json反序列化失败")
+		resp.HandleError(ctx, 1202, "json反序列化失败", nil)
+		return
+	}
+	resp.HandleSuccess(ctx, response.Data)
+	h.logger.Info("获取建筑区域房间树成功", zap.Any("control", response))
+}
+
+// CategoryPart 获取分类部分
+func (h *IlluminatingHandler) CategoryPart(ctx *gin.Context) {
+	id, err := strconv.Atoi(ctx.Query("id"))
+	types, err := strconv.Atoi(ctx.Query("type"))
+	part, err := h.illuminatingService.CategoryPart(id, types)
+	if err != nil {
+		h.logger.Error("获取分类部分失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取分类部分失败", nil)
+		return
+	}
+
+	resp.HandleSuccess(ctx, part)
+	h.logger.Info("获取分类部分成功", zap.Any("control", part))
+}
+
+// DeviceAllMini 获取所有设备
+func (h *IlluminatingHandler) DeviceAllMini(ctx *gin.Context) {
+	device_type_id, err := strconv.Atoi(ctx.Query("device_type_id"))
+	devices_enabled, err := strconv.Atoi(ctx.Query("devices_enabled"))
+	position_id, err := strconv.Atoi(ctx.Query("position_id"))
+	position_type, err := strconv.Atoi(ctx.Query("position_type"))
+	part, err := h.illuminatingService.DeviceAllMini(device_type_id, devices_enabled, position_id, position_type)
+	if err != nil {
+		h.logger.Error("获取所有设备失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取所有设备失败", nil)
+		return
+	}
+
+	resp.HandleSuccess(ctx, part)
+	h.logger.Info("获取所有设备成功", zap.Any("control", part))
+}
+
+// TimingSave 添加定时策略
+func (h *IlluminatingHandler) TimingSave(ctx *gin.Context) {
+	//var request model.TimingSave
+	m := make(map[string]any)
+	err := ctx.ShouldBindJSON(&m)
+	if err != nil {
+		h.logger.Error("参数错误", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "参数错误", nil)
+		return
+	}
+	respone, err := h.illuminatingService.TimingSave(m)
+	if err != nil {
+		h.logger.Error("获取所有设备失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取所有设备失败", nil)
+		return
+	}
+
+	resp.HandleSuccess(ctx, respone)
+	h.logger.Info("获取所有设备成功", zap.Any("control", respone))
+}
+
+// ChangeState 修改定时策略状态
+func (h *IlluminatingHandler) ChangeState(ctx *gin.Context) {
+	timing_id, err := strconv.Atoi(ctx.Query("timing_id"))
+	timing_state, err := strconv.Atoi(ctx.Query("timing_state"))
+	if err != nil {
+		h.logger.Error("参数错误", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "参数错误", nil)
+		return
+	}
+	respone, err := h.illuminatingService.ChangeState(timing_id, timing_state)
+	if err != nil {
+		h.logger.Error("获取所有设备失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取所有设备失败", nil)
+		return
+	}
+
+	resp.HandleSuccess(ctx, string(respone))
+	h.logger.Info("获取所有设备成功", zap.Any("control", respone))
+}
+
+// GetTypeFind 获取类型
+func (h *IlluminatingHandler) GetTypeFind(ctx *gin.Context) {
+	category_id, err := strconv.Atoi(ctx.Query("category_id"))
+	timing_state, err := strconv.Atoi(ctx.Query("devices_enabled"))
+	id, err := strconv.Atoi(ctx.Query("id"))
+	types, err := strconv.Atoi(ctx.Query("type"))
+	if err != nil {
+		h.logger.Error("参数错误", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "参数错误", nil)
+		return
+	}
+	respone, err := h.illuminatingService.GetTypeFind(category_id, timing_state, id, types)
+	if err != nil {
+		h.logger.Error("获取设备类型失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取设备类型失败", nil)
+		return
+	}
+
+	resp.HandleSuccess(ctx, respone)
+	h.logger.Info("获取设备类型成功", zap.Any("control", respone))
+}
+
+// GetTimingId 获取定时策略详情
+func (h *IlluminatingHandler) GetTimingId(ctx *gin.Context) {
+	timing_id := ctx.Query("timing_id")
+
+	respone, err := h.illuminatingService.GetTimingId(timing_id)
+	if err != nil {
+		h.logger.Error("获取定时策略详情失败", zap.Any("err", err))
+		resp.HandleError(ctx, 1201, "获取定时策略详情失败", nil)
+		return
+	}
+
+	resp.HandleSuccess(ctx, respone)
+	h.logger.Info("获取定时策略详情成功", zap.Any("control", respone))
+}

internal/model/energy.go

@@ -5,6 +5,297 @@ import "gorm.io/gorm"
 type Energy struct {
 	gorm.Model
 }
+type EnergyTree struct {
+	Data []struct {
+		Id                    int           `json:"id"`
+		Name                  string        `json:"name"`
+		ParentId              int           `json:"parentId"`
+		PackingCode           string        `json:"packing_code"`
+		PackingBuildingId     int           `json:"packing_building_id"`
+		BuildingName          string        `json:"building_name"`
+		PackingSort           int           `json:"packing_sort"`
+		PackingFormula        int           `json:"packing_formula"`
+		PackingEnergyTypeCode string        `json:"packing_energy_type_code"`
+		EnergyType            []interface{} `json:"energy_type"`
+		Children              []struct {
+			Id                    int    `json:"id"`
+			Name                  string `json:"name"`
+			ParentId              int    `json:"parentId"`
+			PackingCode           string `json:"packing_code"`
+			PackingBuildingId     int    `json:"packing_building_id"`
+			BuildingName          string `json:"building_name"`
+			PackingSort           int    `json:"packing_sort"`
+			PackingFormula        int    `json:"packing_formula"`
+			PackingEnergyTypeCode string `json:"packing_energy_type_code"`
+			EnergyType            []struct {
+				EnergyTypeId             int    `json:"energy_type_id"`
+				EnergyTypeCode           string `json:"energy_type_code"`
+				EnergyTypeName           string `json:"energy_type_name"`
+				EnergyTypeUnit           string `json:"energy_type_unit"`
+				EnergyTypeSystematic     int    `json:"energy_type_systematic"`
+				EnergyTypeSort           int    `json:"energy_type_sort"`
+				EnergyTypeCategoryTypeId int    `json:"energy_type_category_type_id"`
+				FieldKey                 string `json:"field_key"`
+				EnergyTypeAlias          string `json:"energy_type_alias"`
+				EnergyTypeIcons          string `json:"energy_type_icons"`
+			} `json:"energy_type"`
+			Children []struct {
+				Id                    int    `json:"id"`
+				Name                  string `json:"name"`
+				ParentId              int    `json:"parentId"`
+				PackingCode           string `json:"packing_code"`
+				PackingBuildingId     int    `json:"packing_building_id"`
+				BuildingName          string `json:"building_name"`
+				PackingSort           int    `json:"packing_sort"`
+				PackingFormula        int    `json:"packing_formula"`
+				PackingEnergyTypeCode string `json:"packing_energy_type_code"`
+				EnergyType            []struct {
+					EnergyTypeId             int    `json:"energy_type_id"`
+					EnergyTypeCode           string `json:"energy_type_code"`
+					EnergyTypeName           string `json:"energy_type_name"`
+					EnergyTypeUnit           string `json:"energy_type_unit"`
+					EnergyTypeSystematic     int    `json:"energy_type_systematic"`
+					EnergyTypeSort           int    `json:"energy_type_sort"`
+					EnergyTypeCategoryTypeId int    `json:"energy_type_category_type_id"`
+					FieldKey                 string `json:"field_key"`
+					EnergyTypeAlias          string `json:"energy_type_alias"`
+					EnergyTypeIcons          string `json:"energy_type_icons"`
+				} `json:"energy_type"`
+				Children []struct {
+					Id                    int    `json:"id"`
+					Name                  string `json:"name"`
+					ParentId              int    `json:"parentId"`
+					PackingCode           string `json:"packing_code"`
+					PackingBuildingId     int    `json:"packing_building_id"`
+					BuildingName          string `json:"building_name"`
+					PackingSort           int    `json:"packing_sort"`
+					PackingFormula        int    `json:"packing_formula"`
+					PackingEnergyTypeCode string `json:"packing_energy_type_code"`
+					EnergyType            []struct {
+						EnergyTypeId             int    `json:"energy_type_id"`
+						EnergyTypeCode           string `json:"energy_type_code"`
+						EnergyTypeName           string `json:"energy_type_name"`
+						EnergyTypeUnit           string `json:"energy_type_unit"`
+						EnergyTypeSystematic     int    `json:"energy_type_systematic"`
+						EnergyTypeSort           int    `json:"energy_type_sort"`
+						EnergyTypeCategoryTypeId int    `json:"energy_type_category_type_id"`
+						FieldKey                 string `json:"field_key"`
+						EnergyTypeAlias          string `json:"energy_type_alias"`
+						EnergyTypeIcons          string `json:"energy_type_icons"`
+					} `json:"energy_type"`
+					Children                 []interface{} `json:"children"`
+					ValidAlert               int           `json:"valid_alert"`
+					EnergyTypeCategoryTypeId int           `json:"energy_type_category_type_id"`
+				} `json:"children"`
+				ValidAlert               int `json:"valid_alert"`
+				EnergyTypeCategoryTypeId int `json:"energy_type_category_type_id"`
+			} `json:"children"`
+			ValidAlert               int `json:"valid_alert"`
+			EnergyTypeCategoryTypeId int `json:"energy_type_category_type_id"`
+		} `json:"children"`
+		ValidAlert               int `json:"valid_alert"`
+		EnergyTypeCategoryTypeId int `json:"energy_type_category_type_id"`
+	} `json:"data"`
+}
+type T struct {
+	RespJson string `json:"resp_json"`
+}
+type Request struct {
+	TimeType  string `json:"time_type"`
+	Nodes     []int  `json:"nodes"`
+	StartTime string `json:"start_time"`
+	EndTime   string `json:"end_time"`
+}
+
+// EnergyTrend 能耗趋势结构体，用于表示某个建筑或组织在不同时间点的能源消耗趋势数据
+type EnergyTrend struct {
+	BuildId int `json:"build_id"` // 建筑ID，表示该能耗数据所属的建筑编号
+
+	EnergyType []struct { // 能源类型信息，描述该条记录涉及的能源类型
+		EnergyTypeAlias string `json:"energy_type_alias"` // 能源类型别名，用于显示名称
+		EnergyTypeIcons string `json:"energy_type_icons"` // 能源类型图标，用于前端展示
+		EnergyTypeUnit  string `json:"energy_type_unit"`  // 能源单位，如“千瓦时”
+		FieldKey        string `json:"field_key"`         // 字段标识符，用于后端识别该能源类型
+	} `json:"energy_type"` // 能源类型数组，包含多个能源类型的详细信息
+
+	Id    int `json:"id"`    // 记录唯一标识，用于区分不同的能耗趋势记录
+	Index int `json:"index"` // 排序索引，用于排序展示多条记录
+
+	Json []struct { // 时间维度下的能耗数据集合
+		DeviceUsage []struct { // 设备使用情况，记录每个设备在该时间点的能耗数据
+			EPE               float64 `json:"EPE"`                        // 实际能耗值（Electric Power Equivalent）
+			EPEForecast       float64 `json:"EPE_forecast,omitempty"`     // 预测能耗值
+			Column            int     `json:"column"`                     // 列号，用于前端表格展示定位
+			DevicesName       string  `json:"devices_name"`               // 设备名称
+			FormulaProportion int     `json:"formula_proportion"`         // 公式比例，参与计算总能耗的权重
+			MaxEPE            float64 `json:"max_EPE"`                    // 最大实际能耗值
+			MaxEPEForecast    float64 `json:"max_EPE_forecast,omitempty"` // 最大预测能耗值
+			MinEPE            float64 `json:"min_EPE"`                    // 最小实际能耗值
+			MinEPEForecast    float64 `json:"min_EPE_forecast,omitempty"` // 最小预测能耗值
+		} `json:"device_usage"` // 设备使用情况数组
+
+		Time string `json:"time"` // 时间点，表示当前记录的时间戳，格式如"2023-10-01"
+
+		TotalUsage struct { // 总计能耗，表示该时间点所有设备的综合能耗
+			EPE            float64 `json:"EPE"`              // 实际总能耗值
+			EPEForecast    float64 `json:"EPE_forecast"`     // 预测总能耗值
+			MaxEPE         float64 `json:"max_EPE"`          // 最大实际总能耗值
+			MaxEPEForecast float64 `json:"max_EPE_forecast"` // 最大预测总能耗值
+			MinEPE         float64 `json:"min_EPE"`          // 最小实际总能耗值
+			MinEPEForecast float64 `json:"min_EPE_forecast"` // 最小预测总能耗值
+		} `json:"total_usage"` // 总计能耗数据
+
+	} `json:"json"` // 包含多个时间点的能耗数据集合
+
+	OrgId       int    `json:"org_id"`       // 组织ID，表示该能耗数据所属的组织编号
+	PackingCode string `json:"packing_code"` // 打包代码，用于标识数据来源或分类规则
+	PackingName string `json:"packing_name"` // 打包名称，用于前端展示打包的名称
+}
+
+// DayAndNightRequst  昼夜请求参数
+type DayAndNightRequst struct {
+	TimeType  string `json:"time_type"`
+	Node      int    `json:"node"`
+	StartTime string `json:"start_time"`
+	EndTime   string `json:"end_time"`
+	DayTime   string `json:"dayTime"`
+	NightTime string `json:"nightTime"`
+}
+
+// DayAndNightRespone  昼夜返回参数
+type DayAndNightRespone struct {
+	Data []struct {
+		Time       string `json:"time"`
+		TotalUsage string `json:"total_usage"`
+		DayUsage   string `json:"day_usage"`
+	} `json:"data"`
+}
+
+// CategoryStatistics  设备分类统计结构体
+type CategoryStatistics struct {
+	CategoryStatistics []struct {
+		CategoryId     int    `json:"category_id"`
+		CategoryName   string `json:"category_name"`
+		Total          int    `json:"total"`
+		TypeStatistics []struct {
+			DevicesTypeId   int    `json:"devices_type_id"`
+			DevicesTypeName string `json:"devices_type_name"`
+			Total           int    `json:"total"`
+			OnLine          int    `json:"on_line"`
+			OffLine         int    `json:"off_line"`
+		} `json:"type_statistics"`
+		CategorySort int `json:"category_sort"`
+		OnLine       int `json:"on_line"`
+		OffLine      int `json:"off_line"`
+	} `json:"category_statistics"`
+}
+
+// DevicesJsonObject  设备数据结构体
+type DevicesJsonObject struct {
+	EPE        float64 `json:"EPE"`
+	DevUdid    string  `json:"dev_udid"`
+	DisDevName string  `json:"dis_dev_name"`
+}
+
+// TotalWater  总用水结构体
+type TotalWater struct {
+	DevUdid    string `json:"dev_udid"`
+	DisDevName string `json:"dis_dev_name"`
+	TotalWater int    `json:"total_water"`
+}
+
+// HisData  历史数据结构体
+type HisData struct {
+	Data []struct {
+		DevicesId                     int    `json:"devices_id"`
+		DevicesUdid                   string `json:"devices_udid"`
+		DevicesTypeId                 int    `json:"devices_type_id"`
+		DevicesName                   string `json:"devices_name"`
+		DevicesReqInterval            int    `json:"devices_req_interval"`
+		DevicesLastRequestTime        string `json:"devices_last_request_time"`
+		DevicesJsonObject             string `json:"devices_json_object"`
+		DevicesEnabled                int    `json:"devices_enabled"`
+		DevicesCreated                string `json:"devices_created"`
+		DevicesSource                 string `json:"devices_source"`
+		DevicesDescription            string `json:"devices_description"`
+		ExtendId                      int    `json:"extend_id"`
+		BaseId                        int    `json:"base_id"`
+		Longitude                     string `json:"longitude"`
+		Latitude                      string `json:"latitude"`
+		ExtendJson                    string `json:"extend_json"`
+		Adcode                        string `json:"adcode"`
+		McuFirmwareVer                string `json:"mcu_firmware_ver"`
+		WifiFirmwareVer               string `json:"wifi_firmware_ver"`
+		McuProgramCode                string `json:"mcu_program_code"`
+		UpdatePrior                   int    `json:"update_prior"`
+		LastUpdateQueueTime           string `json:"last_update_queue_time"`
+		LastUpdateValue               int    `json:"last_update_value"`
+		UtcDeviation                  int    `json:"utc_deviation"`
+		ConsecutiveUpdateTimes        int    `json:"consecutive_update_times"`
+		UpgradeOption                 int    `json:"upgrade_option"`
+		DevicesTypeCode               string `json:"devices_type_code"`
+		DevicesTypeName               string `json:"devices_type_name"`
+		DevicesTypeWiredWireless      int    `json:"devices_type_wired_wireless"`
+		DevicesTypeCategoryId         int    `json:"devices_type_category_id"`
+		DevicesTypeSort               int    `json:"devices_type_sort"`
+		DevicesTypeCharging           int    `json:"devices_type_charging"`
+		CategoryId                    int    `json:"category_id"`
+		CategoryClassification        string `json:"category_classification"`
+		CategoryName                  string `json:"category_name"`
+		CategorySystematic            int    `json:"category_systematic"`
+		CategorySort                  int    `json:"category_sort"`
+		GatewayId                     int    `json:"gateway_id"`
+		GatewayCode                   string `json:"gateway_code"`
+		GatewayDescription            string `json:"gateway_description"`
+		GatewayOrgId                  int    `json:"gateway_org_id"`
+		GatewayStatus                 int    `json:"gateway_status"`
+		GatewayLastRequestTime        string `json:"gateway_last_request_time"`
+		DevicesGatewayId              int    `json:"devices_gateway_id"`
+		RoomId                        int    `json:"room_id"`
+		RoomRegionId                  int    `json:"room_region_id"`
+		RoomName                      string `json:"room_name"`
+		RoomUserId                    int    `json:"room_user_id"`
+		RoomCheckinDate               string `json:"room_checkin_date"`
+		RoomCheckoutDate              string `json:"room_checkout_date"`
+		RegionId                      int    `json:"region_id"`
+		RegionBuildingId              int    `json:"region_building_id"`
+		RegionName                    string `json:"region_name"`
+		RegionParentId                int    `json:"region_parent_id"`
+		OnLine                        int    `json:"on_line"`
+		RealDeviceName                string `json:"real_device_name"`
+		DeviceDataStatus              int    `json:"device_data_status"`
+		BuildingId                    int    `json:"building_id"`
+		BuildingName                  string `json:"building_name"`
+		ProvinceId                    int    `json:"province_id"`
+		ProvinceName                  string `json:"province_name"`
+		CityId                        int    `json:"city_id"`
+		CityName                      string `json:"city_name"`
+		CountyId                      int    `json:"county_id"`
+		CountyName                    string `json:"county_name"`
+		OfflineConsecutiveTimes       int    `json:"offline_consecutive_times"`
+		OfflineInterval               int    `json:"offline_interval"`
+		OfflineLastRequestTime        string `json:"offline_last_request_time"`
+		DataFrom                      string `json:"data_from"`
+		OriginalMcuFirmwareVer        string `json:"original_mcu_firmware_ver"`
+		OriginalWifiFirmwareVer       string `json:"original_wifi_firmware_ver"`
+		Ip                            string `json:"ip"`
+		LastRequestTimestampInSeconds string `json:"lastRequestTimestampInSeconds"`
+		RoomType                      string `json:"room_type"`
+		GatewayName                   string `json:"gateway_name"`
+		LastFreqTimestamp             string `json:"last_freq_timestamp"`
+		UpgradeFreq                   bool   `json:"upgrade_freq"`
+		DeviceVer                     string `json:"device_ver"`
+		LastUpdateSuccessTime         string `json:"last_update_success_time"`
+		DownloadPercent               int    `json:"download_percent"`
+		FileDeviceVersion             string `json:"file_device_version"`
+		ProgramName                   string `json:"program_name"`
+		GatewayType                   int    `json:"gateway_type"`
+		FullRegionName                string `json:"full_region_name"`
+		DevicesReplaceStatus          int    `json:"devices_replace_status"`
+		DevicesReplaceApplyStatus     int    `json:"devices_replace_apply_status"`
+	} `json:"data"`
+	Count int `json:"count"`
+}
 
 func (m *Energy) TableName() string {
 	return "energy"

internal/model/illuminating.go

@@ -260,6 +260,282 @@ type DeviceOrgid struct {
 	} `json:"Timing"`
 }
 
+// GetBuildingRegionRoomTree 获取建筑区域树
+type GetBuildingRegionRoomTree struct {
+	Data []struct {
+		Id                   int           `json:"id"`
+		Name                 string        `json:"name"`
+		Type                 int           `json:"type"`
+		ParentId             int           `json:"parentId"`
+		RegionId             int           `json:"RegionId"`
+		BuildingId           int           `json:"BuildingId"`
+		IsLastRegion         int           `json:"IsLastRegion"`
+		RegionType           int           `json:"RegionType"`
+		ParentName           string        `json:"parentName"`
+		SysRole              []interface{} `json:"sys_role"`
+		Children             []interface{} `json:"children"`
+		BuildingProvinceId   int           `json:"building_province_id"`
+		BuildingCityId       int           `json:"building_city_id"`
+		BuildingCountyId     int           `json:"building_county_id"`
+		ProvinceName         string        `json:"province_name"`
+		CityName             string        `json:"city_name"`
+		CountyName           string        `json:"county_name"`
+		BuildingAddress      string        `json:"building_address"`
+		BuildingLongitude    string        `json:"building_longitude"`
+		BuildingLatitude     string        `json:"building_latitude"`
+		RoomAccountBalance   int           `json:"room_account_balance"`
+		Sort                 int           `json:"sort"`
+		ChildrenCount        int           `json:"children_count"`
+		BuildingCoordAddress string        `json:"building_coord_address"`
+		RoomArea             int           `json:"room_area"`
+		SplicingId           string        `json:"splicing_id"`
+		TotalUser            int           `json:"total_user"`
+		TotalArea            int           `json:"total_area"`
+		TotalAir             int           `json:"total_air"`
+	} `json:"data"`
+	BuildCount int `json:"build_count"`
+}
+type CategoryPart struct {
+	BaseDevicesCategorys []struct {
+		CategoryId             int    `json:"category_id"`
+		CategoryClassification string `json:"category_classification"`
+		CategoryName           string `json:"category_name"`
+		CategorySystematic     int    `json:"category_systematic"`
+		CategorySort           int    `json:"category_sort"`
+		TsHour                 string `json:"ts_hour"`
+		TsDay                  string `json:"ts_day"`
+		TsHourStatistics       string `json:"ts_hour_statistics"`
+		TsDayStatistics        string `json:"ts_day_statistics"`
+		TsHis                  string `json:"ts_his"`
+	} `json:"BaseDevicesCategorys"`
+}
+
+// 设备列表
+type DeviceAllMini struct {
+	Devices []struct {
+		DevicesId              int       `json:"devices_id"`
+		DevicesUdid            string    `json:"devices_udid"`
+		DevicesTypeId          int       `json:"devices_type_id"`
+		DevicesName            string    `json:"devices_name"`
+		DevicesLastRequestTime time.Time `json:"devices_last_request_time"`
+		DevicesEnabled         int       `json:"devices_enabled"`
+		DevicesCreated         time.Time `json:"devices_created"`
+		DevicesTypeCode        string    `json:"devices_type_code"`
+		DevicesTypeName        string    `json:"devices_type_name"`
+		DevicesTypeCharging    int       `json:"devices_type_charging"`
+		CategoryId             int       `json:"category_id"`
+		CategoryClassification string    `json:"category_classification"`
+		CategoryName           string    `json:"category_name"`
+		GatewayId              int       `json:"gateway_id"`
+		GatewayCode            string    `json:"gateway_code"`
+		GatewayName            string    `json:"gateway_name"`
+		FullRegionName         string    `json:"full_region_name"`
+		RoomName               string    `json:"room_name"`
+		Sort                   int       `json:"sort"`
+	} `json:"devices"`
+	Count int `json:"count"`
+}
+
+// 定时策略保存-请求参数
+type TimingSave struct {
+	RegionIds       string `json:"region_ids"`
+	Radio           int    `json:"radio"`
+	TimingName      string `json:"timing_name"`
+	Weeks           []int  `json:"weeks"`
+	TimingStartTime string `json:"timing_start_time"`
+	TimingAgreement string `json:"timing_agreement"`
+	CommitAgreement string `json:"commit_agreement"`
+	DeviceIds       []int  `json:"device_ids"`
+	TimingState     int    `json:"timing_state"`
+	TimingId        int    `json:"timing_id"`
+}
+type ResponeTimingSave struct {
+	TimingId        int           `json:"timing_id"`
+	TimingName      string        `json:"timing_name"`
+	TimingWeek      int           `json:"timing_week"`
+	TimingStartTime string        `json:"timing_start_time"`
+	TimingState     int           `json:"timing_state"`
+	TimingAgreement string        `json:"timing_agreement"`
+	OrgId           int           `json:"org_id"`
+	DeviceIds       []interface{} `json:"device_ids"`
+	Devices         []interface{} `json:"devices"`
+	Weeks           []interface{} `json:"weeks"`
+	Agreement       string        `json:"agreement"`
+	RegionIds       string        `json:"region_ids"`
+	CategoryId      int           `json:"category_id"`
+	DeviceTypeId    int           `json:"device_type_id"`
+	GroupId         int           `json:"group_id"`
+	CommitAgreement string        `json:"commit_agreement"`
+}
+
+// 获取设备类型
+type GetTypeFind struct {
+	Count          int `json:"count"`
+	BaseDeviceType []struct {
+		DevicesTypeId            int    `json:"devices_type_id"`
+		DevicesTypeCode          string `json:"devices_type_code"`
+		DevicesTypeName          string `json:"devices_type_name"`
+		DevicesTypeWiredWireless int    `json:"devices_type_wired_wireless"`
+		DevicesTypeCategoryId    int    `json:"devices_type_category_id"`
+		DevicesTypeSort          int    `json:"devices_type_sort"`
+		DevicesTypeCharging      int    `json:"devices_type_charging"`
+		CategoryName             string `json:"category_name"`
+		CategoryClassification   string `json:"category_classification"`
+		IsControl                int    `json:"is_control"`
+		DialectAgreements        []struct {
+			DialectId               int           `json:"dialect_id"`
+			DeviceTypeId            int           `json:"device_type_id"`
+			DialectKey              string        `json:"dialect_key"`
+			DialectDataType         int           `json:"dialect_data_type"`
+			DialectIsEnable         int           `json:"dialect_is_enable"`
+			AgreementId             int           `json:"agreement_id"`
+			DialectShow             int           `json:"dialect_show"`
+			DialectSetting          int           `json:"dialect_setting"`
+			DialectRange            int           `json:"dialect_range"`
+			DialectMin              int           `json:"dialect_min"`
+			DialectMax              int           `json:"dialect_max"`
+			DialectDetails          int           `json:"dialect_details"`
+			AgreementKey            string        `json:"agreement_key"`
+			AgreementName           string        `json:"agreement_name"`
+			AgreementDataType       int           `json:"agreement_data_type"`
+			AgreementDescription    string        `json:"agreement_description"`
+			OpsMonitorSettingIsShow int           `json:"ops_monitor_setting_is_show"`
+			DialectAgreements       []interface{} `json:"dialect_agreements"`
+			Option                  []struct {
+				OptionId             int    `json:"option_id"`
+				AgreementId          int    `json:"agreement_id"`
+				OptionValue          string `json:"option_value"`
+				OptionName           string `json:"option_name"`
+				Kv                   string `json:"kv"`
+				DialectDataoptionId  int    `json:"dialect_dataoption_id"`
+				DialectId            int    `json:"dialect_id"`
+				DialectOptionValue   string `json:"dialect_option_value"`
+				AgreementOptionId    int    `json:"agreement_option_id"`
+				DialectOptionShow    int    `json:"dialect_option_show"`
+				DialectOptionSetting int    `json:"dialect_option_setting"`
+			} `json:"option"`
+			DialectParentId int `json:"dialect_parent_id"`
+			Sort            int `json:"sort"`
+			DialectStepLen  int `json:"dialect_step_len"`
+		} `json:"dialect_agreements"`
+		EnergyType             []interface{} `json:"energy_type"`
+		DeviceTypeFile         []interface{} `json:"device_type_file"`
+		TypeFileId             int           `json:"type_file_id"`
+		DevicesTypeImage       interface{}   `json:"devices_type_image"`
+		IsSettingFanRatio      int           `json:"is_setting_fan_ratio"`
+		Sum                    int           `json:"sum"`
+		FunctionType           []interface{} `json:"function_type"`
+		DevicesTypeNonStandard int           `json:"devices_type_non_standard"`
+	} `json:"baseDeviceType"`
+}
+
+// 获取定时策略详情
+type TimingId struct {
+	TimingId        int    `json:"timing_id"`
+	TimingName      string `json:"timing_name"`
+	TimingWeek      int    `json:"timing_week"`
+	TimingStartTime string `json:"timing_start_time"`
+	TimingState     int    `json:"timing_state"`
+	TimingAgreement string `json:"timing_agreement"`
+	OrgId           int    `json:"org_id"`
+	DeviceIds       []int  `json:"device_ids"`
+	Devices         []struct {
+		DevicesId                     int       `json:"devices_id"`
+		DevicesUdid                   string    `json:"devices_udid"`
+		DevicesTypeId                 int       `json:"devices_type_id"`
+		DevicesName                   string    `json:"devices_name"`
+		DevicesReqInterval            int       `json:"devices_req_interval"`
+		DevicesLastRequestTime        time.Time `json:"devices_last_request_time"`
+		DevicesJsonObject             string    `json:"devices_json_object"`
+		DevicesEnabled                int       `json:"devices_enabled"`
+		DevicesCreated                time.Time `json:"devices_created"`
+		DevicesSource                 string    `json:"devices_source"`
+		DevicesDescription            string    `json:"devices_description"`
+		ExtendId                      int       `json:"extend_id"`
+		BaseId                        int       `json:"base_id"`
+		Longitude                     string    `json:"longitude"`
+		Latitude                      string    `json:"latitude"`
+		ExtendJson                    string    `json:"extend_json"`
+		Adcode                        string    `json:"adcode"`
+		McuFirmwareVer                string    `json:"mcu_firmware_ver"`
+		WifiFirmwareVer               string    `json:"wifi_firmware_ver"`
+		McuProgramCode                string    `json:"mcu_program_code"`
+		UpdatePrior                   int       `json:"update_prior"`
+		LastUpdateQueueTime           string    `json:"last_update_queue_time"`
+		LastUpdateValue               int       `json:"last_update_value"`
+		UtcDeviation                  int       `json:"utc_deviation"`
+		ConsecutiveUpdateTimes        int       `json:"consecutive_update_times"`
+		UpgradeOption                 int       `json:"upgrade_option"`
+		DevicesTypeCode               string    `json:"devices_type_code"`
+		DevicesTypeName               string    `json:"devices_type_name"`
+		DevicesTypeWiredWireless      int       `json:"devices_type_wired_wireless"`
+		DevicesTypeCategoryId         int       `json:"devices_type_category_id"`
+		DevicesTypeSort               int       `json:"devices_type_sort"`
+		DevicesTypeCharging           int       `json:"devices_type_charging"`
+		CategoryId                    int       `json:"category_id"`
+		CategoryClassification        string    `json:"category_classification"`
+		CategoryName                  string    `json:"category_name"`
+		CategorySystematic            int       `json:"category_systematic"`
+		CategorySort                  int       `json:"category_sort"`
+		GatewayId                     int       `json:"gateway_id"`
+		GatewayCode                   string    `json:"gateway_code"`
+		GatewayDescription            string    `json:"gateway_description"`
+		GatewayOrgId                  int       `json:"gateway_org_id"`
+		GatewayStatus                 int       `json:"gateway_status"`
+		GatewayLastRequestTime        string    `json:"gateway_last_request_time"`
+		DevicesGatewayId              int       `json:"devices_gateway_id"`
+		RoomId                        int       `json:"room_id"`
+		RoomRegionId                  int       `json:"room_region_id"`
+		RoomName                      string    `json:"room_name"`
+		RoomUserId                    int       `json:"room_user_id"`
+		RoomCheckinDate               string    `json:"room_checkin_date"`
+		RoomCheckoutDate              string    `json:"room_checkout_date"`
+		RegionId                      int       `json:"region_id"`
+		RegionBuildingId              int       `json:"region_building_id"`
+		RegionName                    string    `json:"region_name"`
+		RegionParentId                int       `json:"region_parent_id"`
+		OnLine                        int       `json:"on_line"`
+		RealDeviceName                string    `json:"real_device_name"`
+		DeviceDataStatus              int       `json:"device_data_status"`
+		BuildingId                    int       `json:"building_id"`
+		BuildingName                  string    `json:"building_name"`
+		ProvinceId                    int       `json:"province_id"`
+		ProvinceName                  string    `json:"province_name"`
+		CityId                        int       `json:"city_id"`
+		CityName                      string    `json:"city_name"`
+		CountyId                      int       `json:"county_id"`
+		CountyName                    string    `json:"county_name"`
+		OfflineConsecutiveTimes       int       `json:"offline_consecutive_times"`
+		OfflineInterval               int       `json:"offline_interval"`
+		OfflineLastRequestTime        string    `json:"offline_last_request_time"`
+		DataFrom                      string    `json:"data_from"`
+		OriginalMcuFirmwareVer        string    `json:"original_mcu_firmware_ver"`
+		OriginalWifiFirmwareVer       string    `json:"original_wifi_firmware_ver"`
+		Ip                            string    `json:"ip"`
+		LastRequestTimestampInSeconds string    `json:"lastRequestTimestampInSeconds"`
+		RoomType                      string    `json:"room_type"`
+		GatewayName                   string    `json:"gateway_name"`
+		LastFreqTimestamp             string    `json:"last_freq_timestamp"`
+		UpgradeFreq                   bool      `json:"upgrade_freq"`
+		DeviceVer                     string    `json:"device_ver"`
+		LastUpdateSuccessTime         string    `json:"last_update_success_time"`
+		DownloadPercent               int       `json:"download_percent"`
+		FileDeviceVersion             string    `json:"file_device_version"`
+		ProgramName                   string    `json:"program_name"`
+		GatewayType                   int       `json:"gateway_type"`
+		FullRegionName                string    `json:"full_region_name"`
+		DevicesReplaceStatus          int       `json:"devices_replace_status"`
+		DevicesReplaceApplyStatus     int       `json:"devices_replace_apply_status"`
+	} `json:"devices"`
+	Weeks           []int  `json:"weeks"`
+	Agreement       string `json:"agreement"`
+	RegionIds       string `json:"region_ids"`
+	CategoryId      int    `json:"category_id"`
+	DeviceTypeId    int    `json:"device_type_id"`
+	GroupId         int    `json:"group_id"`
+	CommitAgreement string `json:"commit_agreement"`
+}
+
 func (m *Illuminating) TableName() string {
 	return "illuminating"
 }

internal/server/http.go

@@ -111,6 +111,13 @@ func NewServerHTTP(
 		ill.GET("/gatewayFind", illuminating.GetgatewayFind)
 		ill.POST("/devicesControl", illuminating.DevicesControl)
 		ill.GET("/getDeviceOrgid", illuminating.GetDeviceOrgid)
+		ill.GET("/getBuildingRegionRoomTree", illuminating.GetBuildingRegionRoomTree)
+		ill.GET("/categoryPart", illuminating.CategoryPart)
+		ill.GET("/deviceAllMini", illuminating.DeviceAllMini)
+		ill.POST("/timingSave", illuminating.TimingSave)
+		ill.GET("/changeState", illuminating.ChangeState)
+		ill.GET("/getTypeFind", illuminating.GetTypeFind)
+		ill.GET("/getTimingId", illuminating.GetTimingId)
 	}
 	//能源系统
 	ener := r.Group("/energy")
@@ -119,6 +126,11 @@ func NewServerHTTP(
 		ener.GET("/GetWaterMmeter", energy.GetWaterMmeter)
 		ener.GET("/getAmmeter", energy.GetAmmeter)
 		ener.GET("/getTemperature", energy.GetTemperature)
+		ener.POST("/getBaseecic", energy.GetBaseecic)
+		ener.GET("/gatewayFind", energy.GetgatewayFind)
+		ener.POST("/getEnergyTrend", energy.GetEnergyTrend)
+		ener.GET("/categoryStatistics", energy.CategoryStatistics)
+		ener.GET("/getHisData", energy.GetHisData)
 	}
 	//楼宇智控
 	inte := r.Group("/intell")

internal/service/energy.go

@@ -1,30 +1,340 @@
 package service
 
 import (
+	"bytes"
 	"city_chips/internal/model"
 	"city_chips/internal/repository"
-	"context"
+	"encoding/json"
+	"errors"
+	"github.com/spf13/viper"
+	"io"
+	"log"
+	"net/http"
 )
 
 type EnergyService interface {
-	GetEnergy(ctx context.Context, id int64) (*model.Energy, error)
+	GetStatistics() (model.IlluminatingStatistics, error)
+	GetBaseecic(currentPage, device_type_id, devices_enabled, gateway_id, pageSize int, query, devices_udid string) (model.IlluminatingBaseecic, error)
+	GetAlarm(currentPage, pageSize int) ([]byte, error)
+	GetAlarmStatistics(start_time, end_time string) ([]byte, error)
+	GetgatewayFind() (model.GatewayFind, error)
+	DevicesControl(agreement_json, request_id, udid string, source int) (model.DevicesControl, error)
+	GetEnergyTrend(request model.Request) (model.T, error)
+	GetEnergyTree() (model.EnergyTree, error)
+	GetDayAndNight(request model.DayAndNightRequst) (model.DayAndNightRespone, error)
+	GetDeviceStatistics() (model.CategoryStatistics, error)
+	GetHisData(dev_udid, start_time, end_time, data_size, data_type, cuerrentPage, pageSize, is_page string) (model.HisData, error)
 }
 
 func NewEnergyService(
 	service *Service,
 	energyRepository repository.EnergyRepository,
+	viperViper *viper.Viper,
+	client *http.Client,
+
 ) EnergyService {
+	if client == nil {
+		client = http.DefaultClient
+	}
 	return &energyService{
 		Service:          service,
 		energyRepository: energyRepository,
+		conf:             viperViper,
+		client:           client,
 	}
 }
 
 type energyService struct {
 	*Service
 	energyRepository repository.EnergyRepository
+	conf             *viper.Viper
+	client           *http.Client
+}
+
+func (s *energyService) energy(method, url string, body any) ([]byte, error) {
+	login, err := s.login()
+	if err != nil {
+		return nil, err
+	}
+
+	var reqBody io.Reader
+	var finalURL = url
+
+	// 如果是 GET 请求，把 body 当作 query 参数处理
+	if method == http.MethodGet || method == "" {
+		vals, err := buildQueryParams(body)
+		if err != nil {
+			return nil, err
+		}
+		finalURL = addQueryParams(url, vals)
+	} else {
+		// 非 GET 请求才构造 body
+		reqBody, err = buildRequestBody(body)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	request, err := http.NewRequest(method, finalURL, reqBody)
+	if err != nil {
+		return nil, err
+	}
+	request.Header.Set("Authorization", login.AccessToken)
+
+	response, err := s.client.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	respBody, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, err
+	}
+	return respBody, nil
+}
+
+// login 封装登录逻辑
+func (s *energyService) login() (*model.Login, error) {
+	auth := s.conf.GetString("energy.authorization")
+	clientId := s.conf.GetInt("energy.clientId")
+	mobile := s.conf.GetString("energy.mobile")
+	password := s.conf.GetString("energy.password")
+
+	loginReq := model.LoginRequst{
+		Authorization: auth,
+		ClientId:      clientId,
+		Mobile:        mobile,
+		Password:      password,
+	}
+
+	bodyBytes, err := json.Marshal(loginReq)
+	if err != nil {
+		return nil, err
+	}
+
+	url := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.login")
+	request, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyBytes))
+	if err != nil {
+		return nil, err
+	}
+
+	response, err := s.client.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	respBody, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var login model.Login
+	if err := json.Unmarshal(respBody, &login); err != nil {
+		return nil, err
+	}
+
+	return &login, nil
+}
+
+// 构建请求体工具函数
+
+// GetStatistics 获取统计信息
+func (s *energyService) GetStatistics() (model.IlluminatingStatistics, error) {
+	var response model.IlluminatingStatistics
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.statistics")
+	energy, err := s.energy("GET", urls, nil)
+	if err != nil {
+		return model.IlluminatingStatistics{}, errors.New("获取统计信息失败")
+	}
+	err = json.Unmarshal(energy, &response)
+	if err != nil {
+		return model.IlluminatingStatistics{}, errors.New("json反序列化失败")
+	}
+	return response, nil
+}
+
+// GetDeviceStatistics 获取设备统计信息
+func (s *energyService) GetDeviceStatistics() (model.CategoryStatistics, error) {
+	var response model.CategoryStatistics
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.deviceStatistics")
+	energy, err := s.energy("GET", urls, nil)
+	if err != nil {
+		return model.CategoryStatistics{}, errors.New("获取设备统计信息失败")
+	}
+	err = json.Unmarshal(energy, &response)
+	if err != nil {
+		return model.CategoryStatistics{}, errors.New("json反序列化失败")
+	}
+	return response, nil
+}
+
+// GetAlarm 获取报警信息
+func (s *energyService) GetAlarm(currentPage, pageSize int) ([]byte, error) {
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.alarm")
+	m := make(map[string]any)
+	m["currentPage"] = currentPage
+	m["pageSize"] = pageSize
+	energy, err := s.energy("POST", urls, m)
+	if err != nil {
+		return nil, errors.New("获取统计信息失败")
+	}
+	return energy, nil
 }
 
-func (s *energyService) GetEnergy(ctx context.Context, id int64) (*model.Energy, error) {
-	return s.energyRepository.GetEnergy(ctx, id)
+// GetAlarmStatistics 获取报警统计信息
+func (s *energyService) GetAlarmStatistics(start_time, end_time string) ([]byte, error) {
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.alarmStatistics")
+	urls += "?start_time=" + start_time + "&end_time=" + end_time
+	energy, err := s.energy("GET", urls, nil)
+	if err != nil {
+		return nil, errors.New("获取统计信息失败")
+	}
+	return energy, nil
+}
+
+// GetBaseecic 获取能耗列表
+func (s *energyService) GetBaseecic(currentPage, device_type_id, devices_enabled, gateway_id, pageSize int, query, devices_udid string) (model.IlluminatingBaseecic, error) {
+	var baseecic model.IlluminatingBaseecic
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.baseecic")
+	m := make(map[string]any)
+	m["currentPage"] = currentPage
+	m["pageSize"] = pageSize
+
+	if currentPage == 0 {
+		m["currentPage"] = 1
+	}
+	if pageSize == 0 {
+		m["pageSize"] = 20
+	}
+	if device_type_id != 0 {
+		m["device_type_id"] = device_type_id
+	}
+	if devices_enabled != 0 {
+		m["devices_enabled"] = devices_enabled
+	}
+	if gateway_id != 0 {
+		m["gateway_id"] = gateway_id
+	}
+	if devices_udid != "" {
+		m["devices_udid"] = devices_udid
+	}
+	if query != "" {
+		m["query"] = query
+	}
+	energy, err := s.energy("POST", urls, m)
+	if err != nil {
+		return model.IlluminatingBaseecic{}, errors.New("获取统计信息失败")
+	}
+	err = json.Unmarshal(energy, &baseecic)
+	if err != nil {
+		return model.IlluminatingBaseecic{}, errors.New("json反序列化失败")
+	}
+	return baseecic, nil
+}
+
+// GetgatewayFind 获取网关列表
+func (s *energyService) GetgatewayFind() (model.GatewayFind, error) {
+	var gateway model.GatewayFind
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.gatewayFind")
+	m := make(map[string]any)
+	m["gateway_type"] = -1
+
+	energy, err := s.energy("POST", urls, m)
+	if err != nil {
+		return model.GatewayFind{}, errors.New("获取统计信息失败")
+	}
+	err = json.Unmarshal(energy, &gateway)
+	if err != nil {
+		return model.GatewayFind{}, errors.New("json反序列化失败")
+	}
+	return gateway, nil
+}
+
+// DevicesControl 设备控制
+func (s *energyService) DevicesControl(agreement_json, request_id, udid string, source int) (model.DevicesControl, error) {
+	var devicesControl model.DevicesControl
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.devicesControl")
+	m := make(map[string]any)
+	m["agreement_json"] = agreement_json
+	if request_id != "" {
+		m["request_id"] = request_id
+	}
+	m["source"] = source
+	m["udid"] = udid
+
+	energy, err := s.energy("POST", urls, m)
+	if err != nil {
+		return model.DevicesControl{}, errors.New("控制灯光设备失败")
+	}
+	err = json.Unmarshal(energy, &devicesControl)
+	if err != nil {
+		return model.DevicesControl{}, errors.New("json反序列化失败")
+	}
+
+	return devicesControl, nil
+}
+
+// GetEnergyTree 获取能耗树
+func (s *energyService) GetEnergyTree() (model.EnergyTree, error) {
+	var response model.EnergyTree
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.energyTree")
+	energy, err := s.energy("GET", urls, nil)
+	if err != nil {
+		return model.EnergyTree{}, errors.New("获取能耗树失败")
+	}
+	err = json.Unmarshal(energy, &response)
+	if err != nil {
+		return model.EnergyTree{}, errors.New("json反序列化失败")
+	}
+	return response, nil
+}
+
+// GetEnergyTrend 获取能耗趋势
+func (s *energyService) GetEnergyTrend(request model.Request) (model.T, error) {
+	var response model.T
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.energyTrend")
+	energy, err := s.energy("POST", urls, request)
+	if err != nil {
+		return model.T{}, errors.New("获取能耗趋势失败")
+	}
+	err = json.Unmarshal(energy, &response)
+	if err != nil {
+		return model.T{}, errors.New("json反序列化失败")
+	}
+	return response, nil
+}
+
+// GetDayAndNight 获取昼夜能耗分析
+func (s *energyService) GetDayAndNight(request model.DayAndNightRequst) (model.DayAndNightRespone, error) {
+	var response model.DayAndNightRespone
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.dayAndNight")
+	energy, err := s.energy("POST", urls, request)
+	if err != nil {
+		return model.DayAndNightRespone{}, errors.New("获取能耗趋势失败")
+	}
+	err = json.Unmarshal(energy, &response)
+	if err != nil {
+		return model.DayAndNightRespone{}, errors.New("json反序列化失败")
+	}
+	return response, nil
+}
+
+// GetHisData 获取历史数据
+func (s *energyService) GetHisData(dev_udid, start_time, end_time, data_size, data_type, cuerrentPage, pageSize, is_page string) (model.HisData, error) {
+	var response model.HisData
+	urls := s.conf.GetString("energy.baseUrl") + s.conf.GetString("energy.api.hisData")
+	//urls += "?dev_udid=" + dev_udid + "&start_time=" + start_time + "&end_time=" + end_time + "&data_size=" + data_size + "&data_type=" + data_type + "&cuerrentPage=" + cuerrentPage + "&pageSize=" + pageSize + "&is_page=" + is_page
+	urls += "?dev_udid=" + dev_udid + "&data_size=" + data_size + "&data_type=" + data_type + "&start_time=" + start_time + "&end_time=" + end_time
+	energy, err := s.energy("GET", urls, nil)
+	log.Println(string(energy))
+	if err != nil {
+		return model.HisData{}, errors.New("获取历史数据失败")
+	}
+	err = json.Unmarshal(energy, &response)
+	if err != nil {
+		return model.HisData{}, errors.New("json反序列化失败")
+	}
+	return response, nil
 }

internal/service/illuminating.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"city_chips/internal/model"
 	"city_chips/internal/repository"
-	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -17,7 +16,6 @@ import (
 )
 
 type IlluminatingService interface {
-	GetIlluminating(ctx context.Context, id int64) (*model.Illuminating, error)
 	Illuminating(method, url string, body any) ([]byte, error)
 	GetStatistics() ([]byte, error)
 	GetBaseecic(currentPage, device_type_id, devices_enabled, gateway_id, pageSize int, query, devices_udid string) (model.IlluminatingBaseecic, error)
@@ -26,6 +24,13 @@ type IlluminatingService interface {
 	GetgatewayFind() (model.GatewayFind, error)
 	DevicesControl(agreement_json, request_id, udid string, source int) (model.DevicesControl, error)
 	GetDeviceOrgid(currentPage, pageSize, searchText string) ([]byte, error)
+	GetBuildingRegionRoomTree(building_id, region_parent_id string) ([]byte, error)
+	CategoryPart(id, type_id int) (model.CategoryPart, error)
+	DeviceAllMini(device_type_id, devices_enabled, position_id, position_type int) (model.DeviceAllMini, error)
+	TimingSave(rust map[string]any) (model.ResponeTimingSave, error)
+	ChangeState(timing_id, timing_state int) ([]byte, error)
+	GetTypeFind(category_id, devices_enabled, id, types int) (model.GetTypeFind, error)
+	GetTimingId(timing_id string) (model.TimingId, error)
 }
 
 func NewIlluminatingService(
@@ -52,10 +57,6 @@ type illuminatingService struct {
 	client                 *http.Client
 }
 
-func (s *illuminatingService) GetIlluminating(ctx context.Context, id int64) (*model.Illuminating, error) {
-	return s.illuminatingRepository.GetIlluminating(ctx, id)
-}
-
 func (s *illuminatingService) Illuminating(method, url string, body any) ([]byte, error) {
 	login, err := s.login()
 	if err != nil {
@@ -346,3 +347,133 @@ func (s *illuminatingService) GetDeviceOrgid(currentPage, pageSize, searchText s
 	}
 	return illuminating, nil
 }
+
+// GetBuildingRegionRoomTree 获取建筑区域房间树
+func (s *illuminatingService) GetBuildingRegionRoomTree(building_id, region_parent_id string) ([]byte, error) {
+	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("illuminating.api.getBuildingRegionRoomTree")
+	if building_id != "" && region_parent_id == "" {
+		urls += "?building_id=" + building_id
+	}
+	if region_parent_id != "" && building_id != "" {
+		urls += "?building_id=" + building_id + "&region_parent_id=" + region_parent_id
+	}
+	illuminating, err := s.Illuminating("GET", urls, nil)
+	if err != nil {
+		return nil, errors.New("获取建筑区域房间树失败")
+	}
+	return illuminating, nil
+}
+
+// CategoryPart 获取分类
+func (s *illuminatingService) CategoryPart(id, type_id int) (model.CategoryPart, error) {
+	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("illuminating.api.categoryPart")
+	var respone model.CategoryPart
+	m := make(map[string]any)
+	if id == 0 {
+		m["id"] = 1
+	} else {
+		m["id"] = id
+	}
+	if type_id == 0 {
+		m["type"] = 1
+	} else {
+		m["type"] = type_id
+	}
+	illuminating, err := s.Illuminating("POST", urls, m)
+	if err != nil {
+		return model.CategoryPart{}, errors.New("获取分类失败")
+	}
+	err = json.Unmarshal(illuminating, &respone)
+	if err != nil {
+		return model.CategoryPart{}, errors.New("json反序列化失败")
+	}
+	return respone, nil
+}
+
+// DeviceAllMini 获取所有设备型号
+func (s *illuminatingService) DeviceAllMini(device_type_id, devices_enabled, position_id, position_type int) (model.DeviceAllMini, error) {
+	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("illuminating.api.deviceAllMini")
+	var respone model.DeviceAllMini
+	m := make(map[string]any)
+	m["device_type_id"] = device_type_id
+	m["devices_enabled"] = devices_enabled
+	m["position_id"] = position_id
+	m["position_type"] = position_type
+	illuminating, err := s.Illuminating("POST", urls, m)
+	if err != nil {
+		return model.DeviceAllMini{}, errors.New("获取分类失败")
+	}
+	err = json.Unmarshal(illuminating, &respone)
+	if err != nil {
+		return model.DeviceAllMini{}, errors.New("json反序列化失败")
+	}
+	return respone, nil
+}
+
+// TimingSave 保存定时策略
+func (s *illuminatingService) TimingSave(rust map[string]any) (model.ResponeTimingSave, error) {
+	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("illuminating.api.timingSave")
+	var respone model.ResponeTimingSave
+
+	illuminating, err := s.Illuminating("POST", urls, rust)
+	if err != nil {
+		return model.ResponeTimingSave{}, errors.New("获取分类失败")
+	}
+	err = json.Unmarshal(illuminating, &respone)
+	if err != nil {
+		return model.ResponeTimingSave{}, errors.New("json反序列化失败")
+	}
+	return respone, nil
+}
+
+// ChangeState 修改定时策略状态
+func (s *illuminatingService) ChangeState(timing_id, timing_state int) ([]byte, error) {
+	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("illuminating.api.changeState")
+	m := make(map[string]any)
+	m["timing_id"] = timing_id
+	m["timing_state"] = timing_state
+	illuminating, err := s.Illuminating("POST", urls, m)
+	if err != nil {
+		return nil, errors.New("获取分类失败")
+	}
+
+	return illuminating, nil
+}
+
+// GetTypeFind 获取设备型号
+func (s *illuminatingService) GetTypeFind(category_id, devices_enabled, id, types int) (model.GetTypeFind, error) {
+	var respone model.GetTypeFind
+	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("illuminating.api.typeFind")
+	m := make(map[string]any)
+	m["category_id"] = category_id
+	m["devices_enabled"] = devices_enabled
+	m["id"] = id
+	m["type"] = types
+	illuminating, err := s.Illuminating("POST", urls, m)
+	if err != nil {
+		return model.GetTypeFind{}, errors.New("获取分类失败")
+	}
+	err = json.Unmarshal(illuminating, &respone)
+	if err != nil {
+		return model.GetTypeFind{}, errors.New("json反序列化失败")
+	}
+	return respone, nil
+}
+
+// GettimingId 获取定时策略详情
+func (s *illuminatingService) GetTimingId(timing_id string) (model.TimingId, error) {
+	var respone model.TimingId
+	urls := s.conf.GetString("illuminating.baseUrl") + s.conf.GetString("illuminating.api.timingId")
+	if timing_id != "" {
+		urls += "?timing_id=" + timing_id
+	}
+	illuminating, err := s.Illuminating("GET", urls, nil)
+	if err != nil {
+		return model.TimingId{}, errors.New("获取定时策略详情失败")
+	}
+	err = json.Unmarshal(illuminating, &respone)
+	if err != nil {
+		return model.TimingId{}, errors.New("json反序列化失败")
+	}
+	return respone, nil
+}