city_chips/internal/service/hikvision.go

package service

import (
	"city_chips/internal/model"
	"city_chips/internal/repository"
	"city_chips/pkg/helper/hikvisionOpenAPIGo"
	"encoding/json"
	"errors"
	"strings"

	"github.com/spf13/viper"
	//"github.com/zxbit2011/hikvisionOpenAPIGo"
)

type HikvisionService interface {
	Hikvision(url string, body map[string]any, timeout int) (hikvisionOpenAPIGo.Result, error)
	DeviceResource(Device string) (error, model.DeviceResource)
	GetRegionsRoot() (error, model.RegionsRoot)
	GetRegionsSubRegions(pageNo, pageSize string) (error, model.RegionsSubRegions)
	GetVqdByIndexCodes(pageNo, pageSize string, indexCodes []string) (error, model.VqdList)
	GetCameraOnline(regionId, includeSubNode, status, pageNo, pageSize string, indexCodes []string) (error, model.CameraOnline)
	GetRecordList(beginTime, endTime, pageNo, pageSize string, indexCodes []string) (error, model.RecordList)
	GetCamerasList(pageNo, pageSize string) (error, model.Cameras)
	GetVisitingRecords(receptionistId, receptionistName, visitorName, pageNo, pageSize string) (error, model.VisitingRecords)
	GetVisitorTypeInfo(pageNo, pageSize string) (error, model.VisitorTypeInfo)
	GetAppointmentRecords(receptionistId, visitorName, phoneNo, pageNo, pageSize string) (error, model.VisitorTypeInfo)
	GetVisitorTypeList() (error, model.VisitorTypeList)
	GetTurnoverSearch(pageNo, pageSize string) (error, model.TurnoverSearch)
	GetcameraSearch(pageNo, pageSize, name string) (error, hikvisionOpenAPIGo.Result)
	GetDoorSearch(pageNo, pageSize, name string, doorIndexCodes []string) (error, hikvisionOpenAPIGo.Result)
	GetDoorStates(pageNo, pageSize string, indexCodes []string) (error, hikvisionOpenAPIGo.Result)
	GetAcsDeviceSearch(pageNo, pageSize, name string) (error, hikvisionOpenAPIGo.Result)
	GetManualCapture(cameraIndexCode string) (error, hikvisionOpenAPIGo.Result)
	GetAcsDoorStates(indexCodes []string) (error, hikvisionOpenAPIGo.Result)
	GetDoorDoControl(doorIndexCodes []string, controlType int) (error, hikvisionOpenAPIGo.Result)
	GetEventLogs(pageNo, pageSize, srcType, startTime, endTime, srcName string, eventType int) (error, hikvisionOpenAPIGo.Result)
	GetIasDeviceSearch(pageNo, pageSize, name string) (error, hikvisionOpenAPIGo.Result)
}

func NewHikvisionService(service *Service, hikvisionRepository repository.HikvisionRepository, conf *viper.Viper) HikvisionService {
	return &hikvisionService{
		Service:             service,
		hikvisionRepository: hikvisionRepository,
		conf:                conf,
	}
}

type hikvisionService struct {
	*Service
	hikvisionRepository repository.HikvisionRepository
	conf                *viper.Viper
}

// Hikvision 海康威视对接
func (s *hikvisionService) Hikvision(url string, body map[string]any, timeout int) (hikvisionOpenAPIGo.Result, error) {
	config := hikvisionOpenAPIGo.HKConfig{
		Ip:      s.conf.GetString("hikvision.Ip"),
		Port:    s.conf.GetInt("hikvision.Port"),
		AppKey:  s.conf.GetString("hikvision.AppKey"),
		Secret:  s.conf.GetString("hikvision.Secret"),
		IsHttps: s.conf.GetBool("hikvision.IsHttps"),
	}
	result, err := config.HttpPost(url, body, timeout)
	return result, err
}

// DeviceResource 根据设备类型获取设备资源
func (s *hikvisionService) DeviceResource(Device string) (error, model.DeviceResource) {
	var deviceResource model.DeviceResource
	m := make(map[string]any)
	m["pageNo"] = "1"
	m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	m["resourceType"] = Device
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.deviceResource"), m, 15)
	if err != nil {
		return errors.New("获取设备资源失败"), deviceResource
	}
	if hikvision.Code != "0" {
		return errors.New("获取设备资源失败"), deviceResource
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), deviceResource
	}
	err = json.Unmarshal(marshalString, &deviceResource)
	if err != nil {
		return errors.New("json反序列化失败"), deviceResource
	}
	return nil, deviceResource
}

// GetRegionsRoot 获取根目录资源信息
func (s *hikvisionService) GetRegionsRoot() (error, model.RegionsRoot) {
	var regionsRoot model.RegionsRoot
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.regionsRoot"), nil, 15)
	if err != nil {
		return errors.New("获取根目录资源失败"), regionsRoot
	}
	if hikvision.Code != "0" {
		return errors.New("获取根目录资源失败"), regionsRoot
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), regionsRoot
	}
	err = json.Unmarshal(marshalString, &regionsRoot)
	if err != nil {
		return errors.New("json反序列化失败"), regionsRoot
	}
	return nil, regionsRoot
}

// GetRegionsSubRegions 获取子目录资源信息
func (s *hikvisionService) GetRegionsSubRegions(pageNo, pageSize string) (error, model.RegionsSubRegions) {
	var regionsSubRegions model.RegionsSubRegions
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	m["parentIndexCode"] = "0"
	m["resourceType"] = "0"
	m["cascadeFlag"] = "0"

	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.regionsSubRegions"), m, 15)
	if err != nil {
		return errors.New("获取子目录资源信息失败"), regionsSubRegions
	}
	if hikvision.Code != "0" {
		return errors.New("获取子目录资源信息失败"), regionsSubRegions
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), regionsSubRegions
	}
	err = json.Unmarshal(marshalString, &regionsSubRegions)
	if err != nil {
		return errors.New("json反序列化失败"), regionsSubRegions
	}
	return nil, regionsSubRegions
}

// GetVqdByIndexCodes 根据监控点列表查询视频质量诊断结果
func (s *hikvisionService) GetVqdByIndexCodes(pageNo, pageSize string, indexCodes []string) (error, model.VqdList) {
	var vqdlist model.VqdList
	// 获取门禁状态
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	m["indexCodes"] = strings.Join(indexCodes, ",")

	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.vqdList"), m, 15)
	if err != nil {
		return errors.New("获取视频质量诊断信息失败"), vqdlist
	}
	if hikvision.Code != "0" {
		return errors.New("获取视频质量诊断失败"), vqdlist
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), vqdlist
	}
	err = json.Unmarshal(marshalString, &vqdlist)
	if err != nil {
		return errors.New("json反序列化失败"), vqdlist
	}
	return nil, vqdlist
}

// GetCameraOnline 获取监控点在线状态
//
// regionId		string	false	区域编号，可从查询区域列表v2接口获取返回参数indexCode
// includeSubNode		string	false	是否包含下级，1包含，0不包含（若regionId为空，则该参数不起作用）
// indexCodes		string[]	false	监控点编码集，最大500，查询监控点列表接口获取返回参数cameraIndexCode
// status		string	false	状态，1-在线，0-离线，-1-未检测
func (s *hikvisionService) GetCameraOnline(regionId, includeSubNode, status, pageNo, pageSize string, indexCodes []string) (error, model.CameraOnline) {
	var cameraOnline model.CameraOnline
	// 获取门禁状态
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if regionId != "" {
		m["regionId"] = regionId
	}
	if includeSubNode != "" {
		m["includeSubNode"] = includeSubNode
	}
	if status != "" {
		m["status"] = status
	}
	if len(indexCodes) > 0 {
		m["indexCodes"] = strings.Join(indexCodes, ",")
	}

	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.getCameraOnline"), m, 15)
	if err != nil {
		return errors.New("获取监控点在线状态信息失败"), cameraOnline
	}
	if hikvision.Code != "0" {
		return errors.New("获取监控点在线状态失败"), cameraOnline
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), cameraOnline
	}
	err = json.Unmarshal(marshalString, &cameraOnline)
	if err != nil {
		return errors.New("json反序列化失败"), cameraOnline
	}
	return nil, cameraOnline
}

// GetRecordList 根据监控点列表查询录像完整性结果
// pageNo		integer	true	当前页码，0 < pageNo
// pageSize		integer	true	分页大小，0<pageSize≤1000
// beginTime		string	true	录像开始日期，IOS8601格式
// endTime		string	true	录像结束日期，IOS8601格式
// indexCodes		string[]	true	监控点编号集，
// 查询监控点列表接口获取返回参数cameraIndexCode
func (s *hikvisionService) GetRecordList(beginTime, endTime, pageNo, pageSize string, indexCodes []string) (error, model.RecordList) {
	var recordList model.RecordList
	// 获取门禁状态
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	m["beginTime"] = beginTime
	m["endTime"] = endTime
	if len(indexCodes) > 0 {
		m["indexCodes"] = strings.Join(indexCodes, ",")
	}

	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.recordList"), m, 15)
	if err != nil {
		return errors.New("获取监控点列表查询录像完整性失败"), recordList
	}
	if hikvision.Code != "0" {
		return errors.New("获取监控点列表查询录像完整性失败"), recordList
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), recordList
	}
	err = json.Unmarshal(marshalString, &recordList)
	if err != nil {
		return errors.New("json反序列化失败"), recordList
	}
	return nil, recordList
}

// GetCamerasList  分页获取监控点资源
func (s *hikvisionService) GetCamerasList(pageNo, pageSize string) (error, model.Cameras) {
	var cameras model.Cameras
	// 获取门禁状态
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.cameras"), m, 15)
	if err != nil {
		return errors.New("获取监控点列表查询录像完整性失败"), cameras
	}
	if hikvision.Code != "0" {
		return errors.New("获取监控点列表查询录像完整性失败"), cameras
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), cameras
	}
	err = json.Unmarshal(marshalString, &cameras)
	if err != nil {
		return errors.New("json反序列化失败"), cameras
	}
	return nil, cameras
}

// GetVisitingRecords  查询访客来访记录v2
// receptionistId 被访人唯一标识
// receptionistName 被访人姓名
// visitorName 访客名称
func (s *hikvisionService) GetVisitingRecords(receptionistId, receptionistName, visitorName, pageNo, pageSize string) (error, model.VisitingRecords) {
	var visitingRecords model.VisitingRecords
	// 获取门禁状态
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if receptionistId != "" {
		m["receptionistId"] = receptionistId
	}
	if receptionistName != "" {
		m["receptionistName"] = receptionistName
	}
	if visitorName != "" {
		m["visitorName"] = visitorName
	}
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.visitingRecords"), m, 15)
	if err != nil {
		return errors.New("获取查询访客来访记录失败"), visitingRecords
	}
	if hikvision.Code != "0" {
		return errors.New("获取查询访客来访记录失败"), visitingRecords
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), visitingRecords
	}
	err = json.Unmarshal(marshalString, &visitingRecords)
	if err != nil {
		return errors.New("json反序列化失败"), visitingRecords
	}
	return nil, visitingRecords
}

// GetVisitorTypeInfo 查询访客类型
func (s *hikvisionService) GetVisitorTypeInfo(pageNo, pageSize string) (error, model.VisitorTypeInfo) {
	var visitorTypeInfo model.VisitorTypeInfo
	// 获取门禁状态
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.visitorTypeInfo"), m, 15)
	if err != nil {
		return errors.New("获取查询访客类型失败"), visitorTypeInfo
	}
	if hikvision.Code != "0" {
		return errors.New("获取查询访客类型失败"), visitorTypeInfo
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), visitorTypeInfo
	}
	err = json.Unmarshal(marshalString, &visitorTypeInfo)
	if err != nil {
		return errors.New("json反序列化失败"), visitorTypeInfo
	}
	return nil, visitorTypeInfo
}

// GetAppointmentRecords  查询预约记录v2
// receptionistId 被访人唯一标识
// visitorName 访客名称
// phoneNo 手机号码
func (s *hikvisionService) GetAppointmentRecords(receptionistId, visitorName, phoneNo, pageNo, pageSize string) (error, model.VisitorTypeInfo) {
	var visitorTypeInfo model.VisitorTypeInfo
	// 获取门禁状态
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if receptionistId != "" {
		m["receptionistId"] = receptionistId
	}
	if visitorName != "" {
		m["visitorName"] = visitorName
	}
	if phoneNo != "" {
		m["phoneNo"] = phoneNo
	}
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.visitorTypeInfo"), m, 15)
	if err != nil {
		return errors.New("获取查询预约记录失败"), visitorTypeInfo
	}
	if hikvision.Code != "0" {
		return errors.New("获取查询预约记录失败"), visitorTypeInfo
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), visitorTypeInfo
	}
	err = json.Unmarshal(marshalString, &visitorTypeInfo)
	if err != nil {
		return errors.New("json反序列化失败"), visitorTypeInfo
	}
	return nil, visitorTypeInfo
}

// GetVisitorTypeList  查询全部访客类型
func (s *hikvisionService) GetVisitorTypeList() (error, model.VisitorTypeList) {
	var visitorTypeList model.VisitorTypeList
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.visitorTypeInfo"), nil, 15)
	if err != nil {
		return errors.New("获取访客类型失败"), visitorTypeList
	}
	if hikvision.Code != "0" {
		return errors.New("获取访客类型失败"), visitorTypeList
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), visitorTypeList
	}
	err = json.Unmarshal(marshalString, &visitorTypeList)
	if err != nil {
		return errors.New("json反序列化失败"), visitorTypeList
	}
	return nil, visitorTypeList
}

// GetTurnoverSearch 查询访客出入事件
func (s *hikvisionService) GetTurnoverSearch(pageNo, pageSize string) (error, model.TurnoverSearch) {
	var turnoverSearch model.TurnoverSearch
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.turnoverSearch"), m, 15)
	if err != nil {
		return errors.New("获取访客出入事件失败"), turnoverSearch
	}
	if hikvision.Code != "0" {
		return errors.New("获取访客出入事件失败"), turnoverSearch
	}
	marshalString, err := json.Marshal(hikvision)
	if err != nil {
		return errors.New("json序列化失败"), turnoverSearch
	}
	err = json.Unmarshal(marshalString, &turnoverSearch)
	if err != nil {
		return errors.New("json反序列化失败"), turnoverSearch
	}
	return nil, turnoverSearch
}

// GetCameraSearch 获取摄像头列表
func (s *hikvisionService) GetcameraSearch(pageNo, pageSize, name string) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if name != "" {
		m["name"] = name
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.cameraSearch"), m, 15)
	if err != nil {
		return errors.New("获取摄像头列表失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("获取摄像头列表失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetDoorSearch 获取门禁列表
func (s *hikvisionService) GetDoorSearch(pageNo, pageSize, name string, doorIndexCodes []string) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if name != "" {
		m["name"] = name
	}
	if len(doorIndexCodes) != 0 {
		m["doorIndexCodes"] = doorIndexCodes
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.doorSearch"), m, 15)
	if err != nil {
		return errors.New("获取门禁点列表失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("获取门禁点列表失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetDoorStates  获取门禁设备状态
func (s *hikvisionService) GetDoorStates(pageNo, pageSize string, indexCodes []string) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = "10"
	}
	if len(indexCodes) != 0 {
		m["indexCodes"] = indexCodes
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.doorStates"), m, 15)
	if err != nil {
		return errors.New("获取门禁点状态失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("获取门禁点状态失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetAcsDoorStates 查询门禁点状态
func (s *hikvisionService) GetAcsDoorStates(indexCodes []string) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if len(indexCodes) != 0 {
		m["doorIndexCodes"] = indexCodes
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.acsdoorstates"), m, 15)
	if err != nil {
		return errors.New("获取门禁点状态失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("获取门禁点状态失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetAcsDeviceSearch 获取门禁设备列表
func (s *hikvisionService) GetAcsDeviceSearch(pageNo, pageSize, name string) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if name != "" {
		m["name"] = name
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.acsDeviceSearch"), m, 15)
	if err != nil {
		return errors.New("获取门禁设备列表失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("获取门禁设备列表失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetManualCapture 手动抓图
func (s *hikvisionService) GetManualCapture(cameraIndexCode string) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if cameraIndexCode != "" {
		m["cameraIndexCode"] = cameraIndexCode
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.manualCapture"), m, 15)
	if err != nil {
		return errors.New("手动抓图失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("手动抓图失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetDoorDoControl  门禁点控制
func (s *hikvisionService) GetDoorDoControl(doorIndexCodes []string, controlType int) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if len(doorIndexCodes) != 0 {
		m["doorIndexCodes"] = doorIndexCodes
	} else {
		return errors.New("请选择门禁点"), hikvisionOpenAPIGo.Result{}
	}
	m["controlType"] = controlType
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.doorDoControl"), m, 15)
	if err != nil {
		return errors.New("门禁点控制失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("门禁点控制失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetEventLogs 入侵报警事件日志查询v2
func (s *hikvisionService) GetEventLogs(pageNo, pageSize, srcType, startTime, endTime, srcName string, eventType int) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if srcType != "" {
		m["srcType"] = srcType
	}
	if startTime != "" {
		m["startTime"] = startTime
	}
	if endTime != "" {
		m["endTime"] = endTime
	}
	if srcName != "" {
		m["srcName"] = srcName
	}
	if eventType != 0 {
		m["eventType"] = eventType
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.eventLogs"), m, 15)
	if err != nil {
		return errors.New("入侵报警事件日志查询失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("入侵报警事件日志查询失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}

// GetIasDeviceSearch 查询入侵报警主机列表v2
func (s *hikvisionService) GetIasDeviceSearch(pageNo, pageSize, name string) (error, hikvisionOpenAPIGo.Result) {
	//var cameraSearch model.CameraSearch
	m := make(map[string]any)
	if pageNo != "" {
		m["pageNo"] = pageNo
	} else {
		m["pageNo"] = "1"
	}
	if pageSize != "" {
		m["pageSize"] = pageSize
	} else {
		m["pageSize"] = s.conf.GetString("hikvision.pageSize")
	}
	if name != "" {
		m["name"] = name
	}
	// 获取门禁状态
	hikvision, err := s.Hikvision(s.conf.GetString("hikvision.api.iasDeviceSearch"), m, 15)
	if err != nil {
		return errors.New("获取入侵报警主机列表失败"), hikvisionOpenAPIGo.Result{}
	}
	if hikvision.Code != "0" {
		return errors.New("获取入侵报警主机列表失败"), hikvisionOpenAPIGo.Result{}
	}
	return nil, hikvision
}