city_chips/internal/handler/conference.go

package handler

import (
	"city_chips/internal/model"
	"city_chips/internal/service"
	"city_chips/pkg/helper/resp"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/spf13/viper"
	"github.com/tidwall/gjson"
	"net/http"
	"time"
)

type ConferenceHandler struct {
	*Handler
	conferenceService service.ConferenceService
	conf              *viper.Viper
}

func NewConferenceHandler(handler *Handler, conferenceService service.ConferenceService, conf *viper.Viper) *ConferenceHandler {
	return &ConferenceHandler{
		Handler:           handler,
		conferenceService: conferenceService,
		conf:              conf,
	}
}

// RoomOps 会议室运维概览统计数据
func (h *ConferenceHandler) RoomOps(ctx *gin.Context) {
	roomOpsurl := h.conf.GetString("conference.baseurl") + h.conf.GetString("conference.roomOps")
	request, err := h.conferenceService.SendRequest(http.DefaultClient, "GET", roomOpsurl, nil)
	if err != nil {
		resp.HandleError(ctx, 1203, "获取会议概要失败", nil)
		return
	}
	if gjson.Get(string(request), "code").Int() == 0 {
		s := gjson.Get(string(request), "data").String()
		resp.HandleSuccess(ctx, s)
		return
	}
	resp.HandleError(ctx, 1203, "获取会议概要失败", nil)
}

// DataAnalysis 数据大屏
func (h *ConferenceHandler) DataAnalysis(ctx *gin.Context) {
	dataAnalysisurl := h.conf.GetString("conference.baseurl") + h.conf.GetString("conference.dataAnalysis")
	meetingRoomStatus := h.conf.GetString("conference.baseurl") + h.conf.GetString("conference.meetingRoomStatus")

	request, err := h.conferenceService.SendRequest(http.DefaultClient, "GET", dataAnalysisurl, nil)
	meetingRoomrequest, err := h.conferenceService.SendRequest(http.DefaultClient, "GET", meetingRoomStatus, nil)
	if err != nil {
		resp.HandleError(ctx, 1203, "获取数据大屏信息失败", nil)
		return
	}
	var bigdata model.BigData
	if gjson.Get(string(request), "code").Int() == 0 && gjson.Get(string(meetingRoomrequest), "code").Int() == 0 {
		err = json.Unmarshal(request, &bigdata)
		if err != nil {
			h.logger.Error("json序列化失败")
			resp.HandleError(ctx, 1203, "json序列化失败", nil)
			return
		}
		meetingRoomFreeCount := gjson.Get(string(meetingRoomrequest), "data.meetingRoomFreeCount").Int()
		meetingRoomOccupiedCount := gjson.Get(string(meetingRoomrequest), "data.meetingRoomOccupiedCount").Int()
		meetingRoomForbiddenCount := gjson.Get(string(meetingRoomrequest), "data.meetingRoomForbiddenCount").Int()
		bigdata.Data.MeetingRoomFreeCount = meetingRoomFreeCount
		bigdata.Data.MeetingRoomForbiddenCount = meetingRoomForbiddenCount
		bigdata.Data.MeetingRoomOccupiedCount = meetingRoomOccupiedCount
		resp.HandleSuccess(ctx, bigdata.Data)
		return
	}
	resp.HandleError(ctx, 1203, "获取数据大屏信息失败", nil)
}

// GetRoomsByLocationId  获取会议室数据
func (h *ConferenceHandler) GetRoomsByLocationId(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"`
	}
	getRoomsByLocationId := h.conf.GetString("conference.baseurl") + h.conf.GetString("conference.getRoomsByLocationId")
	now := time.Now().Format("2006-01-02")
	m := make(map[string]any)
	m["date"] = now
	m["appoint_time"] = ""
	m["search"] = ""
	m["locationId"] = []int{}
	m["capacity"] = []string{}
	m["deviceType"] = []string{}
	m["roomType"] = []int{}
	m["status"] = ""
	m["page"] = 1
	m["page_size"] = h.conf.GetInt("conference.pageSize")
	var response Response
	for conn {
		select {
		case <-notify:
			conn = false
			fmt.Println("断开连接")
			return
		default:
			request, err := h.conferenceService.SendRequest(http.DefaultClient, "POST", getRoomsByLocationId, m)
			if err != nil {
				resp.HandleError(ctx, 1203, "获取会议室数据失败", err)
				return
			}
			var rooms model.Room
			var meetingRoomDetail []model.MeetingRoomDetail
			if gjson.Get(string(request), "code").Int() == 0 {
				err = json.Unmarshal(request, &rooms)
				if err != nil {
					h.logger.Error("json序列化失败")
					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()
					return
				}
				for _, v := range rooms.Data.List {
					detail := model.MeetingRoomDetail{
						Id:           v.Id,
						LocationId:   v.LocationId,
						LocationName: v.LocationName,
						CompanyId:    v.CompanyId,
						Status:       v.Status,
						Usage:        v.Usage,
						Name:         v.Name,
					}
					meetingRoomDetail = append(meetingRoomDetail, detail)
				}
			} else {
				response.Code = 1203
				response.Msg = "获取会议室数据失败"
				response.Data = string(request)
				res, _ := json.Marshal(&response)
				fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
				ctx.Writer.Flush()
				return
			}
			response.Code = 200
			response.Msg = "查询成功"
			response.Data = meetingRoomDetail
			res, _ := json.Marshal(&response)
			fmt.Fprintf(ctx.Writer, "data: %s\n\n", string(res))
			ctx.Writer.Flush()
			time.Sleep(10 * time.Second)
		}
	}
}

// MeetingRoomById 会议室详情
func (h *ConferenceHandler) MeetingRoomById(ctx *gin.Context) {
	id := ctx.Query("id")
	if len(id) <= 0 {
		resp.HandleError(ctx, 1203, "缺少必要参数id", nil)
		return
	}
	dataAnalysisurl := h.conf.GetString("conference.baseurl") + h.conf.GetString("conference.meetingRoom") + "/" + id
	request, err := h.conferenceService.SendRequest(http.DefaultClient, "GET", dataAnalysisurl, nil)
	if err != nil {
		resp.HandleError(ctx, 1203, "获取会议室详情失败", err)
		return
	}
	if gjson.Get(string(request), "code").Int() == 0 {
		s := gjson.Get(string(request), "data").Value()
		resp.HandleSuccess(ctx, s)
		return
	}
	resp.HandleError(ctx, 1203, "获取会议室详情失败", string(request))
}

// Location 地点详情
func (h *ConferenceHandler) Location(ctx *gin.Context) {
	id := ctx.Query("id")
	if len(id) <= 0 {
		resp.HandleError(ctx, 1203, "缺少必要参数id", nil)
		return
	}
	dataAnalysisurl := h.conf.GetString("conference.baseurl") + h.conf.GetString("conference.location") + "/" + id
	request, err := h.conferenceService.SendRequest(http.DefaultClient, "GET", dataAnalysisurl, nil)
	if err != nil {
		resp.HandleError(ctx, 1203, "获取地点详情失败", err)
		return
	}
	if gjson.Get(string(request), "code").Int() == 0 {
		s := gjson.Get(string(request), "data").Value()
		resp.HandleSuccess(ctx, s)
		return
	}
	resp.HandleError(ctx, 1203, "获取地点详情失败", string(request))
}

// GetRoomsByLocation 查询会议室数据
func (h *ConferenceHandler) GetRoomsByLocation(ctx *gin.Context) {
	getRoomsByLocation := h.conf.GetString("conference.baseurl") + h.conf.GetString("conference.getRoomsByLocationId")
	var respGetRooms model.RespGetRooms
	err := ctx.ShouldBindJSON(&respGetRooms)
	if err != nil {
		resp.HandleError(ctx, 1203, "json序列化失败", nil)
		return
	}
	_, err = time.Parse("2006-01-02", respGetRooms.Date)
	if err != nil {
		resp.HandleError(ctx, 1203, "时间格式错误", nil)
		return
	}
	request, err := h.conferenceService.SendRequest(http.DefaultClient, "POST", getRoomsByLocation, respGetRooms)
	if err != nil {
		resp.HandleError(ctx, 1203, "获取会议室列表失败", err)
		return
	}
	if gjson.Get(string(request), "code").Int() == 0 {
		s := gjson.Get(string(request), "data").Value()
		resp.HandleSuccess(ctx, s)
		return
	}
	resp.HandleError(ctx, 1203, "获取会议室列表失败", string(request))
}