city_chips/internal/service/energy.go

package service

import (
	"bytes"
	"city_chips/internal/model"
	"city_chips/internal/repository"
	"encoding/json"
	"errors"
	"github.com/spf13/viper"
	"io"
	"log"
	"net/http"
)

type EnergyService interface {
	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
}

// 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
}