city_chips/internal/handler/intelligentbuildingcontrol.go

package handler

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

	"github.com/spf13/viper"

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

type IntelligentBuildingControlHandler struct {
	*Handler
	intelligentBuildingControlService service.IntelligentBuildingControlService
	conf                              *viper.Viper
}

func NewIntelligentBuildingControlHandler(
	handler *Handler,
	intelligentBuildingControlService service.IntelligentBuildingControlService,
	conf *viper.Viper,
) *IntelligentBuildingControlHandler {
	return &IntelligentBuildingControlHandler{
		Handler:                           handler,
		intelligentBuildingControlService: intelligentBuildingControlService,
		conf:                              conf,
	}
}

// 智能楼宇控制系统

// 示例：创建一个报警记录
func generateAlarm() model.AlarmList {
	return model.AlarmList{
		Id:           rand.Intn(100),
		Name:         model.GetRandomItem(model.DeviceNames),
		State:        rand.Intn(2), // 假设0为正常，1为报警
		Date:         time.Now().Format("2006-01-02 15:04:05"),
		Location:     model.GetRandomItem(model.Locations),
		AlarmContent: model.GetRandomItem(model.AlarmContents),
	}
}
func (h *IntelligentBuildingControlHandler) GetIntelligentBuildingControl(ctx *gin.Context) {
	m := make(map[string]any)
	var device []model.AlarmList
	for i := 0; i < 20; i++ {
		alarm := generateAlarm()
		device = append(device, alarm)
	}
	count, err := h.intelligentBuildingControlService.DeviceCount()
	if err != nil {
		resp.HandleError(ctx, 1201, "查询设备总数失败", nil)
		return
	}
	m["DeviceCount"] = count          //设备总数
	m["StopState"] = rand.Intn(100)   //停止状态
	m["RunState"] = rand.Intn(100)    //运行状态
	m["FaultState"] = rand.Intn(1000) //故障状态
	m["DeviceList"] = device          //设备列表
	resp.HandleSuccess(ctx, m)
}

func (h *IntelligentBuildingControlHandler) GetPoint(ctx *gin.Context) {
	pointName := ctx.PostForm("pointName")
	deviceType := ctx.PostForm("deviceType")
	building := ctx.PostForm("building")
	floor := ctx.PostForm("floor")
	section := ctx.PostForm("section")
	device_name := ctx.PostForm("deviceName")
	pageNum, err := strconv.Atoi(ctx.PostForm("pageNum"))
	pageSize, err := strconv.Atoi(ctx.PostForm("pageSize"))
	conds := make(map[string]any)
	//var pointType []model.PointType
	if pointName != "" {
		conds["point_name"] = pointName
	}
	if deviceType != "" {
		conds["device_type"] = deviceType
	}
	if building != "" {
		conds["building"] = building
	}
	if floor != "" {
		conds["floor"] = floor
	}
	if section != "" {
		conds["section"] = section
	}
	if device_name != "" {
		conds["device_name"] = device_name
	}

	//baseUrl := h.conf.GetString("obix.baseUrl")
	point, total, err := h.intelligentBuildingControlService.GetPoint(conds, pageNum, pageSize)
	if err != nil {
		resp.HandleError(ctx, 1201, "查询点位失败", nil)
		return
	}
	//
	//var wg sync.WaitGroup
	//var mutex sync.Mutex // 保护切片并发写入
	//m := make(map[string]string)
	//sem := make(chan struct{}, 10) // 最大并发数为10
	//
	//for _, v := range *points {
	//	url := baseUrl + v.FullPath
	//	wg.Add(1)
	//	sem <- struct{}{}
	//	go func(url string, pointName string) {
	//		defer func() {
	//			<-sem
	//			wg.Done()
	//		}()
	//
	//		request, err := obix.SendSecureRequest(url, h.conf.GetString("obix.username"), h.conf.GetString("obix.password"))
	//		if err != nil {
	//			h.logger.Error("发送请求失败", zap.Error(err))
	//			return
	//		}
	//
	//		re := regexp.MustCompile(`val="([^"]+)"`)
	//		matches := re.FindStringSubmatch(request)
	//
	//		mutex.Lock()
	//		defer mutex.Unlock()
	//
	//		if len(matches) > 1 {
	//			s := model.PointName[pointName]
	//			m[s] = matches[1]
	//			pointType = append(pointType, model.PointType{Type: m})
	//		} else {
	//			h.logger.Warn("未找到 val 值", zap.String("url", url))
	//		}
	//	}(url, v.PointName)
	//}
	//
	//// 等待所有协程完成
	//wg.Wait()

	// 统一返回结果
	resp.PageHandleSuccess(ctx, point, total, pageNum, pageSize)
}

// GetGetPoint 获取点位设备数据
func (h *IntelligentBuildingControlHandler) GetGetPoint(ctx *gin.Context) {
	pointName := ctx.Query("pointName")
	deviceType := ctx.Query("deviceType")
	building := ctx.Query("building")
	floor := ctx.Query("floor")
	section := ctx.Query("section")
	device_name := ctx.Query("deviceName")
	conds := make(map[string]any)
	if pointName != "" {
		conds["point_name"] = pointName
	}
	if deviceType != "" {
		conds["device_type"] = deviceType
	}
	if building != "" {
		conds["building"] = building
	}
	if floor != "" {
		conds["floor"] = floor
	}
	if section != "" {
		conds["section"] = section
	}
	if device_name != "" {
		conds["device_name"] = device_name
	}
	baseUrl := h.conf.GetString("obix.baseUrl")
	m := make(map[string]any)
	points, _, err := h.intelligentBuildingControlService.GetPoint(conds, 1, 100)
	if err != nil {
		resp.HandleError(ctx, 1201, "查询点位失败", nil)
	}
	for _, v := range *points {
		url := baseUrl + v.FullPath
		request, err := obix.SendSecureRequest(url, h.conf.GetString("obix.username"), h.conf.GetString("obix.password"))
		if err != nil {
			h.logger.Error("发送请求失败", zap.Error(err))
			return
		}
		re := regexp.MustCompile(`val="([^"]+)"`)
		matches := re.FindStringSubmatch(request)
		if len(matches) > 1 {
			s := model.PointName[v.PointName]
			if s != "" {
				value := matches[1]
				switch val := obix.DetectType(value).(type) {
				case int:
					m[s] = val
				case float64:
					m[s] = fmt.Sprintf("%.2f", val) // 保留两位小数输出
				case bool:
					if val {
						m[s] = "是"
					} else {
						m[s] = "否"
					}
				default:
					m[s] = value // 原样输出字符串
				}
			}
		} else {
			h.logger.Warn("未找到 val 值", zap.String("url", url))
		}
	}
	resp.HandleSuccess(ctx, m)

}

func (h *IntelligentBuildingControlHandler) GetGetPointSSE(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"`
	}
	pointName := ctx.Query("pointName")
	deviceType := ctx.Query("deviceType")
	building := ctx.Query("building")
	floor := ctx.Query("floor")
	section := ctx.Query("section")
	device_name := ctx.Query("deviceName")
	conds := make(map[string]any)
	if pointName != "" {
		conds["point_name"] = pointName
	}
	if deviceType != "" {
		conds["device_type"] = deviceType
	}
	if building != "" {
		conds["building"] = building
	}
	if floor != "" {
		conds["floor"] = floor
	}
	if section != "" {
		conds["section"] = section
	}
	if device_name != "" {
		conds["device_name"] = device_name
	}

	baseUrl := h.conf.GetString("obix.baseUrl")

	var response Response
	for conn {
		select {
		case <-notify:
			conn = false
			fmt.Println("断开连接")
			return
		default:
			m := make(map[string]any)
			points, _, err := h.intelligentBuildingControlService.GetPoint(conds, 1, 100)
			if err != nil {
				resp.HandleError(ctx, 1201, "查询点位失败", nil)
				conn = false
			}
			for _, v := range *points {
				url := baseUrl + v.FullPath
				request, err := obix.SendSecureRequest(url, h.conf.GetString("obix.username"), h.conf.GetString("obix.password"))
				if err != nil {
					h.logger.Error("发送请求失败", zap.Error(err))
					conn = false
					return
				}
				re := regexp.MustCompile(`val="([^"]+)"`)
				matches := re.FindStringSubmatch(request)
				if len(matches) > 1 {
					s := model.PointName[v.PointName]
					if s != "" {
						value := matches[1]
						switch val := obix.DetectType(value).(type) {
						case int:
							m[s] = val
						case float64:
							m[s] = fmt.Sprintf("%.2f", val) // 保留两位小数输出
						case bool:
							if val {
								m[s] = "是"
							} else {
								m[s] = "否"
							}
						default:
							m[s] = value // 原样输出字符串
						}
					}
				} else {
					h.logger.Warn("未找到 val 值", zap.String("url", url))
					conn = false
				}
			}
			response.Code = 200
			response.RequestId = ctx.ClientIP()
			response.Msg = "success"
			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)
		}
	}
}

//func (h *IntelligentBuildingControlHandler) GetGetPointSSE(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 `json:"requestId,omitempty"`
//		Code      int32  `json:"code,omitempty"`
//		Msg       string `json:"msg,omitempty"`
//		Data      any    `json:"data"`
//	}
//
//	pointName := ctx.Query("pointName")
//	deviceType := ctx.Query("deviceType")
//	building := ctx.Query("building")
//	floor := ctx.Query("floor")
//	section := ctx.Query("section")
//	device_name := ctx.Query("deviceName")
//
//	conds := make(map[string]any)
//	if pointName != "" {
//		conds["point_name"] = pointName
//	}
//	if deviceType != "" {
//		conds["device_type"] = deviceType
//	}
//	if building != "" {
//		conds["building"] = building
//	}
//	if floor != "" {
//		conds["floor"] = floor
//	}
//	if section != "" {
//		conds["section"] = section
//	}
//	if device_name != "" {
//		conds["device_name"] = device_name
//	}
//
//	baseUrl := h.conf.GetString("obix.baseUrl")
//
//	var response Response
//	for conn {
//		select {
//		case <-notify:
//			conn = false
//			fmt.Println("客户端断开连接")
//			return
//		default:
//			m := make(map[string]any)
//			points, _, err := h.intelligentBuildingControlService.GetPoint(conds, 1, 100)
//			if err != nil {
//				resp.HandleError(ctx, 1201, "查询点位失败", nil)
//				conn = false
//				continue
//			}
//
//			var wg sync.WaitGroup
//			var mutex sync.Mutex
//			sem := make(chan struct{}, 10) // 控制最大并发数为10
//
//			for _, v := range *points {
//				select {
//				case sem <- struct{}{}:
//				default:
//					<-sem
//					sem <- struct{}{}
//				}
//				wg.Add(1)
//				go func(v model.Point) {
//					defer func() {
//						<-sem
//						wg.Done()
//					}()
//
//					url := baseUrl + v.FullPath
//					request, err := obix.SendSecureRequest(url, h.conf.GetString("obix.username"), h.conf.GetString("obix.password"))
//					if err != nil {
//						h.logger.Error("发送请求失败", zap.String("url", url), zap.Error(err))
//						return
//					}
//
//					re := regexp.MustCompile(`val="([^"]+)"`)
//					matches := re.FindStringSubmatch(request)
//
//					if len(matches) > 1 {
//						s := model.PointName[v.PointName]
//						if s != "" {
//							value := matches[1]
//							result := obix.DetectType(value)
//
//							mutex.Lock()
//							defer mutex.Unlock()
//
//							switch val := result.(type) {
//							case int:
//								m[s] = val
//							case float64:
//								m[s] = fmt.Sprintf("%.2f", val)
//							case bool:
//								if val {
//									m[s] = "是"
//								} else {
//									m[s] = "否"
//								}
//							default:
//								m[s] = value
//							}
//						}
//					} else {
//						h.logger.Warn("未找到 val 值", zap.String("url", url))
//					}
//				}(v)
//			}
//
//			wg.Wait() // 等待所有 goroutine 完成
//
//			response.Code = 200
//			response.RequestId = ctx.ClientIP()
//			response.Msg = "success"
//			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)
//		}
//	}
//}

// GetPointType 获取点位类型
func (h *IntelligentBuildingControlHandler) GetPointType(ctx *gin.Context) {
	points, err := h.intelligentBuildingControlService.GetPointType()
	if err != nil {
		resp.HandleError(ctx, 1201, "查询点位类型失败", nil)
		return
	}
	resp.HandleSuccess(ctx, points)
}

// GetDeviceType 获取设备类型
func (h *IntelligentBuildingControlHandler) GetDeviceType(ctx *gin.Context) {
	points, err := h.intelligentBuildingControlService.DeviceType()
	if err != nil {
		resp.HandleError(ctx, 1201, "查询设备类型失败", nil)
		return
	}
	m := make(map[string]string)
	for _, v := range points {
		m[v] = model.DeviceType[v]
	}
	resp.HandleSuccess(ctx, m)
}

// GetDevices 获取设备列表
func (h *IntelligentBuildingControlHandler) GetDevices(ctx *gin.Context) {
	conds := make(map[string]any)
	pageNum, err := strconv.Atoi(ctx.Query("pageNum"))
	pageSize, err := strconv.Atoi(ctx.Query("pageSize"))
	device_type := ctx.Query("device_type")
	if len(device_type) == 0 || device_type == "" {
		resp.HandleError(ctx, 1201, "设备类型不能为空", nil)
	}
	conds["device_type"] = device_type
	if err != nil {
		resp.HandleError(ctx, 1201, "获取分页参数失败", nil)
		return
	}
	devices, total, err := h.intelligentBuildingControlService.GetDevices(conds, pageNum, pageSize)
	if err != nil {
		resp.HandleError(ctx, 1201, "查询设备类型失败", nil)
		return
	}
	resp.PageHandleSuccess(ctx, devices, total, pageNum, pageSize)
}

// ConfigurationDiagram 获取设备组态图
func (h *IntelligentBuildingControlHandler) ConfigurationDiagram(c *gin.Context) {
	// 获取查询参数
	//type-deviceName
	id := c.Query("id")

	if len(id) == 0 {
		resp.HandleError(c, 1201, "设备名称不能为空", nil)
		return
	}
	split := strings.Split(id, "-")
	if len(split) != 2 {
		resp.HandleError(c, 1201, "设备名称格式错误", nil)
		return
	}
	deviceName := split[1]
	types := split[0]
	switch types {
	case "PAU":
		c.HTML(http.StatusOK, "PAU.html", gin.H{
			"deviceName": deviceName,
		})
	case "JSK":
		c.HTML(http.StatusOK, "JSK.html", gin.H{
			"deviceName": deviceName,
		})
	case "PF":
		c.HTML(http.StatusOK, "PF.html", gin.H{
			"deviceName": deviceName,
		})
	}
}