illuminating.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469
  1. package handler
  2. import (
  3. "city_chips/internal/model"
  4. "city_chips/internal/service"
  5. "city_chips/pkg/helper/resp"
  6. "encoding/json"
  7. "fmt"
  8. "go.uber.org/zap"
  9. "strconv"
  10. "strings"
  11. "time"
  12. "github.com/gin-gonic/gin"
  13. "github.com/spf13/viper"
  14. )
  15. type IlluminatingHandler struct {
  16. *Handler
  17. illuminatingService service.IlluminatingService
  18. conf *viper.Viper
  19. }
  20. func NewIlluminatingHandler(
  21. handler *Handler,
  22. illuminatingService service.IlluminatingService,
  23. conf *viper.Viper,
  24. ) *IlluminatingHandler {
  25. return &IlluminatingHandler{
  26. Handler: handler,
  27. illuminatingService: illuminatingService,
  28. conf: conf,
  29. }
  30. }
  31. // GetIlluminating 照明系统
  32. func (h *IlluminatingHandler) GetIlluminating(ctx *gin.Context) {
  33. m := make(map[string]any)
  34. var alarmstatistics model.AlarmStatistics
  35. var alarmCount model.AlarmCount
  36. var statis model.IlluminatingStatistics
  37. now := time.Now()
  38. sevenDaysAgo := now.AddDate(0, 0, -30).Format("2006-01-02")
  39. format := now.Format("2006-01-02")
  40. alarmStatistics, err := h.illuminatingService.GetAlarmStatistics(sevenDaysAgo, format)
  41. if err != nil {
  42. h.logger.Error("获取告警信息统计失败", zap.Any("err", err))
  43. resp.HandleError(ctx, 1204, "获取告警信息统计失败", nil)
  44. return
  45. }
  46. err = json.Unmarshal(alarmStatistics, &alarmstatistics)
  47. if err != nil {
  48. h.logger.Error("json反序列化失败")
  49. resp.HandleError(ctx, 1205, "json序列化失败", nil)
  50. return
  51. }
  52. alarm, err := h.illuminatingService.GetAlarm(1, 20)
  53. if err != nil {
  54. h.logger.Error("获取告警信息失败", zap.Any("err", err))
  55. resp.HandleError(ctx, 1203, "获取告警信息失败", nil)
  56. return
  57. }
  58. err = json.Unmarshal(alarm, &alarmCount)
  59. if err != nil {
  60. h.logger.Error("json反序列化失败")
  61. resp.HandleError(ctx, 1205, "json序列化失败", nil)
  62. return
  63. }
  64. statistics, err := h.illuminatingService.GetStatistics()
  65. if err != nil {
  66. h.logger.Error("获取统计信息失败", zap.Any("err", err))
  67. resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
  68. return
  69. }
  70. err = json.Unmarshal(statistics, &statis)
  71. if err != nil {
  72. h.logger.Error("json反序列化失败")
  73. resp.HandleError(ctx, 1202, "json反序列化失败", nil)
  74. return
  75. }
  76. for i, _ := range alarmstatistics.TimeStatistics {
  77. s := alarmstatistics.TimeStatistics[i].TimeDay.Format("2006-01-02 15:04:05")
  78. alarmstatistics.TimeStatistics[i].Time = s
  79. }
  80. baseecic, err := h.illuminatingService.GetBaseecic(1, 0, -1, 0, 20, "", "")
  81. if err != nil {
  82. h.logger.Error("获取 basement_ecic 列表失败", zap.Any("err", err))
  83. resp.HandleError(ctx, 1202, "获取 basement_ecic 列表失败", nil)
  84. return
  85. }
  86. m["IlluminatingDevice"] = baseecic.Devices //设备列表
  87. m["DeviceCount"] = statis.DeviceCount //设备总数
  88. m["GatewayCount"] = statis.GatewayCount //网关数量
  89. m["OffCount"] = statis.StrategyCount //策略总数
  90. m["AlarmCount"] = statis.AlarmCount //报警数量
  91. m["RunAnalyse"] = alarmstatistics.TimeStatistics //运行分析
  92. m["EventList"] = alarmCount //报警事件
  93. resp.HandleSuccess(ctx, m)
  94. }
  95. // 获取灯光状态
  96. //func (h *IlluminatingHandler) GetLightingstatus(ctx *gin.Context) {
  97. // // 设置响应头
  98. // ctx.Header("Content-Type", "text/event-stream")
  99. // ctx.Header("Cache-Control", "no-cache")
  100. // ctx.Header("Connection", "keep-alive")
  101. // // 监听客户端断开连接
  102. // conn := true
  103. // notify := ctx.Writer.CloseNotify()
  104. // type Response struct {
  105. // RequestId string `protobuf:"bytes,1,opt,name=requestId,proto3" json:"requestId,omitempty"`
  106. // Code int32 `protobuf:"varint,2,opt,name=code,proto3" json:"code,omitempty"`
  107. // Msg string `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
  108. // Data any `json:"data"`
  109. // }
  110. // stationNo := ctx.Query("id")
  111. // if len(stationNo) == 0 {
  112. // resp.HandleError(ctx, 1201, "缺少必要参数", nil)
  113. // return
  114. // }
  115. // var response Response
  116. // for conn {
  117. // select {
  118. // case <-notify:
  119. // conn = false
  120. // fmt.Println("断开连接")
  121. // return
  122. // default:
  123. // // 模拟数据
  124. // data := make(map[string]any)
  125. // response.Code = 200
  126. // response.RequestId = strconv.Itoa(rand.Intn(1000))
  127. // response.Msg = "success"
  128. // data["设备名称"] = model.GetRandomItem(model.IlluminatingDeviceNames)
  129. // data["state"] = rand.Intn(2) // 1开 0关 2故障
  130. // response.Data = data
  131. // res, _ := json.Marshal(&response)
  132. // fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
  133. // ctx.Writer.Flush()
  134. // time.Sleep(10 * time.Second)
  135. // }
  136. // }
  137. //}
  138. // 修改灯光状态
  139. func (h *IlluminatingHandler) UpdataLightingStatus(ctx *gin.Context) {
  140. id := ctx.PostForm("id")
  141. state := ctx.PostForm("state")
  142. if len(id) == 0 || len(state) == 0 {
  143. resp.HandleError(ctx, 1201, "缺少必要参数", nil)
  144. return
  145. }
  146. resp.HandleSuccess(ctx, id)
  147. }
  148. // GetStatistics 获取灯光统计数据
  149. func (h *IlluminatingHandler) GetStatistics(ctx *gin.Context) {
  150. var statis model.IlluminatingStatistics
  151. statistics, err := h.illuminatingService.GetStatistics()
  152. if err != nil {
  153. h.logger.Error("获取统计信息失败", zap.Any("err", err))
  154. resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
  155. return
  156. }
  157. err = json.Unmarshal(statistics, &statis)
  158. if err != nil {
  159. h.logger.Error("json反序列化失败")
  160. resp.HandleError(ctx, 1202, "json反序列化失败", nil)
  161. return
  162. }
  163. resp.HandleSuccess(ctx, statis)
  164. }
  165. func (h *IlluminatingHandler) GetBaseecic(ctx *gin.Context) {
  166. currentPageStr := ctx.PostForm("currentPage")
  167. currentPage, err := strconv.Atoi(currentPageStr)
  168. device_type_idStr := ctx.PostForm("device_type_id")
  169. device_type_id, err := strconv.Atoi(device_type_idStr)
  170. devices_enabledStr := ctx.PostForm("devices_enabled")
  171. devices_enabled, err := strconv.Atoi(devices_enabledStr)
  172. pageSizeStr := ctx.PostForm("pageSize")
  173. gatewayStr := ctx.PostForm("gateway_id")
  174. gateway_id, err := strconv.Atoi(gatewayStr)
  175. pageSize, err := strconv.Atoi(pageSizeStr)
  176. if err != nil {
  177. resp.HandleError(ctx, 1203, "参数错误", err)
  178. return
  179. }
  180. query := ctx.PostForm("query")
  181. baseecic, err := h.illuminatingService.GetBaseecic(currentPage, device_type_id, devices_enabled, gateway_id, pageSize, query, "")
  182. if err != nil {
  183. h.logger.Error("获取统计信息失败", zap.Any("err", err))
  184. resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
  185. return
  186. }
  187. resp.HandleSuccess(ctx, baseecic)
  188. }
  189. // GetgatewayFind 获取网关信息
  190. func (h *IlluminatingHandler) GetgatewayFind(ctx *gin.Context) {
  191. gateway, err := h.illuminatingService.GetgatewayFind()
  192. if err != nil {
  193. h.logger.Error("获取统计信息失败", zap.Any("err", err))
  194. resp.HandleError(ctx, 1201, "获取统计信息失败", nil)
  195. return
  196. }
  197. resp.HandleSuccess(ctx, gateway)
  198. h.logger.Info("获取统计信息成功", zap.Any("control", gateway))
  199. }
  200. // DevicesControl 设备控制
  201. func (h *IlluminatingHandler) DevicesControl(ctx *gin.Context) {
  202. agreement_json := ctx.PostForm("agreement_json")
  203. request_id := ctx.PostForm("request_id")
  204. udid := ctx.PostForm("udid")
  205. source, err := strconv.Atoi(ctx.PostForm("source"))
  206. if err != nil {
  207. resp.HandleError(ctx, 1203, "参数错误", err)
  208. return
  209. }
  210. control, err := h.illuminatingService.DevicesControl(agreement_json, request_id, udid, source)
  211. if err != nil {
  212. h.logger.Error("控制灯光设备失败", zap.Any("err", err))
  213. resp.HandleError(ctx, 1201, "控制灯光设备失败", nil)
  214. return
  215. }
  216. resp.HandleSuccess(ctx, control)
  217. h.logger.Info("控制灯光设备成功", zap.Any("control", control))
  218. }
  219. // GetLightingstatus 获取设备信息详情
  220. func (h *IlluminatingHandler) GetLightingstatus(ctx *gin.Context) {
  221. // 设置响应头
  222. ctx.Header("Content-Type", "text/event-stream")
  223. ctx.Header("Cache-Control", "no-cache")
  224. ctx.Header("Connection", "keep-alive")
  225. // 监听客户端断开连接
  226. conn := true
  227. notify := ctx.Writer.CloseNotify()
  228. var response model.Response
  229. m := make(map[string]any)
  230. // 使用 map[string]interface{} 来接收未知结构的 JSON 对象
  231. var data map[string]any
  232. devices_udid := ctx.Query("devices_udid")
  233. for conn {
  234. select {
  235. case <-notify:
  236. conn = false
  237. fmt.Println("断开连接")
  238. return
  239. default:
  240. baseecic, err := h.illuminatingService.GetBaseecic(1, 0, -1, 0, 1, "", devices_udid)
  241. if err != nil {
  242. h.logger.Error("获取设备信息详情失败")
  243. response.Code = 1203
  244. response.Msg = "获取设备信息详情失败"
  245. response.Data = nil
  246. res, _ := json.Marshal(&response)
  247. fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
  248. ctx.Writer.Flush()
  249. conn = false
  250. return
  251. }
  252. m["设备名称"] = baseecic.Devices[0].DevicesName
  253. m["state"] = baseecic.Devices[0].OnLine
  254. err = json.Unmarshal([]byte(baseecic.Devices[0].DevicesJsonObject), &data)
  255. if err != nil {
  256. h.logger.Error("json反序列化失败")
  257. response.Code = 1202
  258. response.Msg = "json反序列化失败"
  259. response.Data = nil
  260. res, _ := json.Marshal(&response)
  261. fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
  262. conn = false
  263. }
  264. deviceTags := make(map[string]int)
  265. // 遍历所有 key
  266. for key, value := range data {
  267. // 检查是否是 name 开头
  268. if strings.HasPrefix(key, "name") {
  269. // 尝试将 value 转为字符串
  270. name, ok := value.(string)
  271. if !ok {
  272. continue
  273. }
  274. // 提取序号,比如 name1 -> 1
  275. indexStr := strings.TrimPrefix(key, "name")
  276. index, err := strconv.Atoi(indexStr)
  277. if err != nil {
  278. continue
  279. }
  280. // 构造对应的 tag 键名
  281. tagKey := fmt.Sprintf("tag%d", index)
  282. // 获取 tag 的值并转为 int
  283. if tagValue, ok := data[tagKey].(float64); ok {
  284. deviceTags[name] = int(tagValue)
  285. }
  286. }
  287. }
  288. for k, v := range deviceTags {
  289. m[k] = v
  290. }
  291. response.Code = 200
  292. response.Msg = "获取设备信息成功"
  293. response.Data = m
  294. res, _ := json.Marshal(&response)
  295. fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
  296. ctx.Writer.Flush()
  297. time.Sleep(10 * time.Second)
  298. }
  299. }
  300. }
  301. // GetDeviceOrgid 获取照明定时策略
  302. func (h *IlluminatingHandler) GetDeviceOrgid(ctx *gin.Context) {
  303. currentPage := ctx.Query("currentPage")
  304. pageSize := ctx.Query("pageSize")
  305. searchText := ctx.Query("searchText")
  306. var response model.DeviceOrgid
  307. control, err := h.illuminatingService.GetDeviceOrgid(currentPage, pageSize, searchText)
  308. if err != nil {
  309. h.logger.Error("获取照明定时策略失败", zap.Any("err", err))
  310. resp.HandleError(ctx, 1201, "获取照明定时策略失败", nil)
  311. return
  312. }
  313. err = json.Unmarshal(control, &response)
  314. if err != nil {
  315. h.logger.Error("json反序列化失败")
  316. resp.HandleError(ctx, 1202, "json反序列化失败", nil)
  317. return
  318. }
  319. resp.HandleSuccess(ctx, response)
  320. h.logger.Info("获取照明定时策略成功", zap.Any("control", response))
  321. }
  322. // GetBuildingRegionRoomTree 获取建筑区域房间树
  323. func (h *IlluminatingHandler) GetBuildingRegionRoomTree(ctx *gin.Context) {
  324. building_id := ctx.Query("building_id")
  325. region_parent_id := ctx.Query("region_parent_id")
  326. var response model.GetBuildingRegionRoomTree
  327. control, err := h.illuminatingService.GetBuildingRegionRoomTree(building_id, region_parent_id)
  328. if err != nil {
  329. h.logger.Error("获取建筑区域房间树失败", zap.Any("err", err))
  330. resp.HandleError(ctx, 1201, "获取建筑区域房间树失败", nil)
  331. return
  332. }
  333. err = json.Unmarshal(control, &response)
  334. if err != nil {
  335. h.logger.Error("json反序列化失败")
  336. resp.HandleError(ctx, 1202, "json反序列化失败", nil)
  337. return
  338. }
  339. resp.HandleSuccess(ctx, response.Data)
  340. h.logger.Info("获取建筑区域房间树成功", zap.Any("control", response))
  341. }
  342. // CategoryPart 获取分类部分
  343. func (h *IlluminatingHandler) CategoryPart(ctx *gin.Context) {
  344. id, err := strconv.Atoi(ctx.Query("id"))
  345. types, err := strconv.Atoi(ctx.Query("type"))
  346. part, err := h.illuminatingService.CategoryPart(id, types)
  347. if err != nil {
  348. h.logger.Error("获取分类部分失败", zap.Any("err", err))
  349. resp.HandleError(ctx, 1201, "获取分类部分失败", nil)
  350. return
  351. }
  352. resp.HandleSuccess(ctx, part)
  353. h.logger.Info("获取分类部分成功", zap.Any("control", part))
  354. }
  355. // DeviceAllMini 获取所有设备
  356. func (h *IlluminatingHandler) DeviceAllMini(ctx *gin.Context) {
  357. device_type_id, err := strconv.Atoi(ctx.Query("device_type_id"))
  358. devices_enabled, err := strconv.Atoi(ctx.Query("devices_enabled"))
  359. position_id, err := strconv.Atoi(ctx.Query("position_id"))
  360. position_type, err := strconv.Atoi(ctx.Query("position_type"))
  361. part, err := h.illuminatingService.DeviceAllMini(device_type_id, devices_enabled, position_id, position_type)
  362. if err != nil {
  363. h.logger.Error("获取所有设备失败", zap.Any("err", err))
  364. resp.HandleError(ctx, 1201, "获取所有设备失败", nil)
  365. return
  366. }
  367. resp.HandleSuccess(ctx, part)
  368. h.logger.Info("获取所有设备成功", zap.Any("control", part))
  369. }
  370. // TimingSave 添加定时策略
  371. func (h *IlluminatingHandler) TimingSave(ctx *gin.Context) {
  372. //var request model.TimingSave
  373. m := make(map[string]any)
  374. err := ctx.ShouldBindJSON(&m)
  375. if err != nil {
  376. h.logger.Error("参数错误", zap.Any("err", err))
  377. resp.HandleError(ctx, 1201, "参数错误", nil)
  378. return
  379. }
  380. respone, err := h.illuminatingService.TimingSave(m)
  381. if err != nil {
  382. h.logger.Error("获取所有设备失败", zap.Any("err", err))
  383. resp.HandleError(ctx, 1201, "获取所有设备失败", nil)
  384. return
  385. }
  386. resp.HandleSuccess(ctx, respone)
  387. h.logger.Info("获取所有设备成功", zap.Any("control", respone))
  388. }
  389. // ChangeState 修改定时策略状态
  390. func (h *IlluminatingHandler) ChangeState(ctx *gin.Context) {
  391. timing_id, err := strconv.Atoi(ctx.Query("timing_id"))
  392. timing_state, err := strconv.Atoi(ctx.Query("timing_state"))
  393. if err != nil {
  394. h.logger.Error("参数错误", zap.Any("err", err))
  395. resp.HandleError(ctx, 1201, "参数错误", nil)
  396. return
  397. }
  398. respone, err := h.illuminatingService.ChangeState(timing_id, timing_state)
  399. if err != nil {
  400. h.logger.Error("获取所有设备失败", zap.Any("err", err))
  401. resp.HandleError(ctx, 1201, "获取所有设备失败", nil)
  402. return
  403. }
  404. resp.HandleSuccess(ctx, string(respone))
  405. h.logger.Info("获取所有设备成功", zap.Any("control", respone))
  406. }
  407. // GetTypeFind 获取类型
  408. func (h *IlluminatingHandler) GetTypeFind(ctx *gin.Context) {
  409. category_id, err := strconv.Atoi(ctx.Query("category_id"))
  410. timing_state, err := strconv.Atoi(ctx.Query("devices_enabled"))
  411. id, err := strconv.Atoi(ctx.Query("id"))
  412. types, err := strconv.Atoi(ctx.Query("type"))
  413. if err != nil {
  414. h.logger.Error("参数错误", zap.Any("err", err))
  415. resp.HandleError(ctx, 1201, "参数错误", nil)
  416. return
  417. }
  418. respone, err := h.illuminatingService.GetTypeFind(category_id, timing_state, id, types)
  419. if err != nil {
  420. h.logger.Error("获取设备类型失败", zap.Any("err", err))
  421. resp.HandleError(ctx, 1201, "获取设备类型失败", nil)
  422. return
  423. }
  424. resp.HandleSuccess(ctx, respone)
  425. h.logger.Info("获取设备类型成功", zap.Any("control", respone))
  426. }
  427. // GetTimingId 获取定时策略详情
  428. func (h *IlluminatingHandler) GetTimingId(ctx *gin.Context) {
  429. timing_id := ctx.Query("timing_id")
  430. respone, err := h.illuminatingService.GetTimingId(timing_id)
  431. if err != nil {
  432. h.logger.Error("获取定时策略详情失败", zap.Any("err", err))
  433. resp.HandleError(ctx, 1201, "获取定时策略详情失败", nil)
  434. return
  435. }
  436. resp.HandleSuccess(ctx, respone)
  437. h.logger.Info("获取定时策略详情成功", zap.Any("control", respone))
  438. }