mirror of
https://github.com/MickMake/GoSungrow.git
synced 2025-06-08 22:20:06 +02:00
975 lines
28 KiB
Go
975 lines
28 KiB
Go
package iSolarCloud
|
|
|
|
import (
|
|
"GoSungrow/iSolarCloud/api"
|
|
"GoSungrow/iSolarCloud/api/GoStruct/valueTypes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"github.com/MickMake/GoUnify/Only"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
|
|
// SunGrowDataRequest - Collection of all possible request args.
|
|
type SunGrowDataRequest struct {
|
|
args RequestArgs
|
|
Required map[string]string
|
|
aPsId valueTypes.PsIds
|
|
}
|
|
type SunGrowDataRequests map[string]SunGrowDataRequest
|
|
|
|
type RequestArgs struct {
|
|
// Be careful with types. If you see a general 'error' response,
|
|
// then it's more likely a type mismatch.
|
|
PsId *valueTypes.PsId `json:"ps_id,omitempty"`
|
|
PsId2 *valueTypes.PsId `json:"psId,omitempty"` // Specifically for WebIscmAppService.getPowerStationInfo
|
|
PsId3 *valueTypes.PsId `json:"psid,omitempty"` // Specifically for WebAppService.getPsTree
|
|
PsIds *valueTypes.PsIds `json:"psIds,omitempty"`
|
|
PsIdList *valueTypes.String `json:"ps_id_list,omitempty"`
|
|
ReportType *valueTypes.String `json:"report_type,omitempty"`
|
|
FaultTypeCode *valueTypes.Integer `json:"fault_type_code,omitempty"`
|
|
Size *valueTypes.Integer `json:"size,omitempty"`
|
|
CurPage *valueTypes.Integer `json:"curPage,omitempty"`
|
|
DeviceType *valueTypes.String `json:"device_type,omitempty"`
|
|
ReportId *valueTypes.String `json:"report_id,omitempty"`
|
|
CodeType *valueTypes.String `json:"code_type,omitempty"`
|
|
OrgIds *valueTypes.String `json:"orgIds,omitempty"`
|
|
Uuid *valueTypes.String `json:"uuid,omitempty"`
|
|
TemplateId *valueTypes.String `json:"template_id,omitempty"`
|
|
DeviceModelId *valueTypes.String `json:"device_model_id,omitempty"`
|
|
|
|
// Points
|
|
PsKeyList *valueTypes.String `json:"ps_key_list,omitempty"`
|
|
PsKeys *valueTypes.PsKeys `json:"-,omitempty"` // Used by queryMutiPointDataList
|
|
PsKey *valueTypes.PsKey `json:"ps_key,omitempty"`
|
|
Point *valueTypes.PointId `json:"point_id,omitempty"`
|
|
Points *valueTypes.PointIds `json:"points,omitempty"`
|
|
|
|
// DateTime
|
|
DateId *valueTypes.DateTime `json:"date_id,omitempty"`
|
|
DateType *string `json:"date_type,omitempty"`
|
|
MonthDate *valueTypes.DateTime `json:"month_date,omitempty"`
|
|
Day *valueTypes.DateTime `json:"day,omitempty"`
|
|
BeginTime *valueTypes.DateTime `json:"beginTime,omitempty"` // valueTypes.Time
|
|
EndTime *valueTypes.DateTime `json:"endTime,omitempty"` // valueTypes.Time
|
|
StartTimeStamp *valueTypes.DateTime `json:"start_time_stamp,omitempty"`
|
|
EndTimeStamp *valueTypes.DateTime `json:"end_time_stamp,omitempty"`
|
|
|
|
// UNVERIFIED
|
|
AppKey *valueTypes.String `json:"app_key,omitempty"`
|
|
DealerOrgCode *valueTypes.String `json:"dealer_org_code,omitempty"`
|
|
DeviceSn *valueTypes.String `json:"device_sn,omitempty"`
|
|
FaultCode *valueTypes.Integer `json:"fault_code,omitempty"`
|
|
FaultName *valueTypes.String `json:"fault_name,omitempty"`
|
|
Id *valueTypes.Integer `json:"id,omitempty"`
|
|
MinuteInterval *valueTypes.Integer `json:"minute_interval,omitempty"`
|
|
OrderId *valueTypes.String `json:"order_id,omitempty"`
|
|
OrgId *valueTypes.String `json:"org_id,omitempty"`
|
|
Prefix *valueTypes.String `json:"prefix,omitempty"`
|
|
PrimaryKey *valueTypes.String `json:"primaryKey,omitempty"`
|
|
QueryType *valueTypes.String `json:"query_type,omitempty"`
|
|
Sn *valueTypes.String `json:"sn,omitempty"`
|
|
Table *valueTypes.String `json:"table,omitempty"`
|
|
TaskId *valueTypes.String `json:"task_id,omitempty"`
|
|
UserId *valueTypes.String `json:"userId,omitempty"`
|
|
MenuId *valueTypes.Integer `json:"menuId,omitempty"`
|
|
// UserId2 *valueTypes.String `json:"userId,omitempty"`
|
|
|
|
// PsId valueTypes.PsId `json:"id"`
|
|
// PsId valueTypes.PsId `json:"ps_id"`
|
|
// DeviceType valueTypes.String `json:"device_type"`
|
|
// DateType *valueTypes.String `json:"date_type,omitempty"`
|
|
|
|
// AppKey string `json:"app_key"`
|
|
// BeginTime string `json:"beginTime"`
|
|
// DealerOrgCode string `json:"dealer_org_code"`
|
|
// DeviceSn valueTypes.String `json:"device_sn"`
|
|
// EndTimeStamp string `json:"end_time_stamp"`
|
|
// FaultCode string `json:"fault_code"`
|
|
// FaultName string `json:"fault_name"`
|
|
// FaultTypeCode string `json:"fault_type_code"`
|
|
// Id string `json:"id"`
|
|
// MinuteInterval string `json:"minute_interval"`
|
|
// OrderId string `json:"order_id"`
|
|
// OrgId string `json:"org_id"`
|
|
// PointId string `json:"point_id"`
|
|
// Points string `json:"points"`
|
|
// Prefix string `json:"prefix"`
|
|
// PrimaryKey string `json:"primaryKey"`
|
|
// PsKeyList string `json:"ps_key_list"`
|
|
// QueryType valueTypes.String `json:"query_type"`
|
|
// Sn valueTypes.String `json:"sn"`
|
|
// StartTimeStamp string `json:"start_time_stamp"`
|
|
// Table string `json:"table"`
|
|
// TaskId valueTypes.String `json:"task_id"`
|
|
}
|
|
|
|
//goland:noinspection GoCommentStart
|
|
const (
|
|
NamePsId = "PsId"
|
|
NamePsId2 = "PsId2"
|
|
NamePsId3 = "PsId3"
|
|
NamePsIds = "PsIds"
|
|
NamePsIdList = "PsIdList"
|
|
NameReportType = "ReportType"
|
|
NameFaultTypeCode = "FaultTypeCode"
|
|
NameSize = "Size"
|
|
NameCurPage = "CurPage"
|
|
NameDeviceType = "DeviceType"
|
|
NameReportId = "ReportId"
|
|
NameCodeType = "CodeType"
|
|
NameOrgIds = "OrgIds"
|
|
NameUuid = "Uuid"
|
|
NameTemplateId = "TemplateId"
|
|
NameDeviceModelId = "DeviceModelId"
|
|
|
|
NamePsKeyList = "PsKeyList"
|
|
NamePsKeys = "PsKeys"
|
|
NamePsKey = "PsKey"
|
|
NamePointId = "PointId"
|
|
NamePoints = "Points"
|
|
|
|
// DateTime
|
|
NameDateId = "DateId"
|
|
NameDateType = "DateType"
|
|
NameMonthDate = "MonthDate"
|
|
NameDay = "Day"
|
|
NameBeginTime = "BeginTime"
|
|
NameEndTime = "EndTime"
|
|
NameStartTimeStamp = "StartTimeStamp"
|
|
NameEndTimeStamp = "EndTimeStamp"
|
|
|
|
// UNVERIFIED
|
|
NameAppKey = "AppKey"
|
|
NameDealerOrgCode = "DealerOrgCode"
|
|
NameDeviceSn = "DeviceSn"
|
|
NameFaultCode = "FaultCode"
|
|
NameFaultName = "FaultName"
|
|
NameId = "Id"
|
|
NameMinuteInterval = "MinuteInterval"
|
|
NameOrderId = "OrderId"
|
|
NameOrgId = "OrgId"
|
|
NamePrefix = "Prefix"
|
|
NamePrimaryKey = "PrimaryKey"
|
|
NameQueryType = "QueryType"
|
|
NameSn = "Sn"
|
|
NameTable = "Table"
|
|
NameTaskId = "TaskId"
|
|
NameUserId = "UserId"
|
|
NameMenuId = "MenuId"
|
|
)
|
|
|
|
var Help = map[string]string{
|
|
NamePsId: "PsId - valid ps_id",
|
|
NamePsId2: "PsId - valid ps_id",
|
|
NamePsId3: "PsId - valid ps_id",
|
|
NamePsIds: "PsIds - list of ps_id",
|
|
NamePsIdList: "PsIdList - ",
|
|
NameReportType: "ReportType - ",
|
|
NameFaultTypeCode: "FaultTypeCode - ",
|
|
NameSize: "Size - ",
|
|
NameCurPage: "CurPage - ",
|
|
NameDeviceType: "DeviceType - ",
|
|
NameReportId: "ReportId - ",
|
|
NameCodeType: "CodeType - ",
|
|
NameOrgIds: "OrgIds - ",
|
|
NameUuid: "Uuid - ",
|
|
NameTemplateId: "TemplateId - ",
|
|
NameDeviceModelId: "DeviceModelId - ",
|
|
|
|
NamePsKeyList: "PsKeyList - ",
|
|
NamePsKey: "PsKey - ",
|
|
NamePointId: "PointId - ",
|
|
NamePoints: "Points - ",
|
|
|
|
// DateTime
|
|
NameDateId: "DateId - Date in format YYYYMMDD or YYYYMM or YYYY",
|
|
NameDateType: "DateType - ",
|
|
NameMonthDate: "MonthDate - Date in format YYYYMM",
|
|
NameDay: "Day - Date in format YYYYMMDD",
|
|
NameBeginTime: "BeginTime - ",
|
|
NameEndTime: "EndTime - ",
|
|
NameStartTimeStamp: "StartTimeStamp - ",
|
|
NameEndTimeStamp: "EndTimeStamp - ",
|
|
|
|
// UNVERIFIED
|
|
NameAppKey: "AppKey - ",
|
|
NameDealerOrgCode: "DealerOrgCode - ",
|
|
NameDeviceSn: "DeviceSn - ",
|
|
NameFaultCode: "FaultCode - ",
|
|
NameFaultName: "FaultName - ",
|
|
NameId: "Id - ",
|
|
NameMinuteInterval: "MinuteInterval - ",
|
|
NameOrderId: "OrderId - ",
|
|
NameOrgId: "OrgId - ",
|
|
NamePrefix: "Prefix - ",
|
|
NamePrimaryKey: "PrimaryKey - ",
|
|
NameQueryType: "QueryType - ",
|
|
NameSn: "Sn - ",
|
|
NameTable: "Table - ",
|
|
NameTaskId: "TaskId - ",
|
|
NameUserId: "UserId - ",
|
|
NameMenuId: "MenuId - ",
|
|
}
|
|
|
|
// MarshalJSON - Convert value to JSON
|
|
func (sgd SunGrowDataRequest) MarshalJSON() ([]byte, error) {
|
|
var data []byte
|
|
var err error
|
|
|
|
for range Only.Once {
|
|
var dt *string
|
|
if sgd.args.DateId != nil {
|
|
dt = &sgd.args.DateId.DateType
|
|
}
|
|
|
|
if sgd.IsRequired(NamePsKeys) {
|
|
// queryMutiPointDataList - expects multiple pskeys separated by comma.
|
|
// getDevicePointMinuteDataList - expects a single pskey.
|
|
pskey := valueTypes.SetPsKeyString(sgd.args.PsKeys.String())
|
|
sgd.args.PsKey = &pskey
|
|
sgd.args.PsKeys = nil
|
|
}
|
|
|
|
type Parse RequestArgs
|
|
// Store result from string
|
|
data, err = json.Marshal(Parse {
|
|
PsId: sgd.args.PsId,
|
|
PsId2: sgd.args.PsId2,
|
|
PsId3: sgd.args.PsId3,
|
|
PsIds: sgd.args.PsIds,
|
|
PsIdList: sgd.args.PsIdList,
|
|
ReportType: sgd.args.ReportType,
|
|
FaultTypeCode: sgd.args.FaultTypeCode,
|
|
Size: sgd.args.Size,
|
|
CurPage: sgd.args.CurPage,
|
|
DeviceType: sgd.args.DeviceType,
|
|
ReportId: sgd.args.ReportId,
|
|
CodeType: sgd.args.CodeType,
|
|
OrgIds: sgd.args.OrgIds,
|
|
Uuid: sgd.args.Uuid,
|
|
TemplateId: sgd.args.TemplateId,
|
|
DeviceModelId: sgd.args.DeviceModelId,
|
|
|
|
// Points
|
|
PsKeyList: sgd.args.PsKeyList,
|
|
PsKey: sgd.args.PsKey,
|
|
PsKeys: sgd.args.PsKeys,
|
|
Point: sgd.args.Point,
|
|
Points: sgd.args.Points,
|
|
|
|
// DateTime
|
|
DateId: sgd.args.DateId,
|
|
DateType: dt,
|
|
MonthDate: sgd.args.MonthDate,
|
|
BeginTime: sgd.args.BeginTime,
|
|
EndTime: sgd.args.EndTime,
|
|
StartTimeStamp: sgd.args.StartTimeStamp,
|
|
EndTimeStamp: sgd.args.EndTimeStamp,
|
|
|
|
// UNVERIFIED
|
|
Day: sgd.args.Day,
|
|
AppKey: sgd.args.AppKey,
|
|
DealerOrgCode: sgd.args.DealerOrgCode,
|
|
DeviceSn: sgd.args.DeviceSn,
|
|
FaultCode: sgd.args.FaultCode,
|
|
FaultName: sgd.args.FaultName,
|
|
Id: sgd.args.Id,
|
|
MinuteInterval: sgd.args.MinuteInterval,
|
|
OrderId: sgd.args.OrderId,
|
|
OrgId: sgd.args.OrgId,
|
|
Prefix: sgd.args.Prefix,
|
|
PrimaryKey: sgd.args.PrimaryKey,
|
|
QueryType: sgd.args.QueryType,
|
|
Sn: sgd.args.Sn,
|
|
Table: sgd.args.Table,
|
|
TaskId: sgd.args.TaskId,
|
|
UserId: sgd.args.UserId,
|
|
MenuId: sgd.args.MenuId,
|
|
})
|
|
if err == nil {
|
|
break
|
|
}
|
|
}
|
|
|
|
return data, err
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) Set(arg string, value string) {
|
|
for range Only.Once {
|
|
switch arg {
|
|
case NamePsId:
|
|
fallthrough
|
|
case NamePsId2:
|
|
fallthrough
|
|
case NamePsId3:
|
|
sgd.aPsId = valueTypes.SetPsIdStrings(SplitArg(value)) // strings.Split(a[1], ","))
|
|
sgd.SetPsId(value)
|
|
case NamePsIds:
|
|
sgd.aPsId = valueTypes.SetPsIdStrings(SplitArg(value)) // strings.Split(a[1], ","))
|
|
val := valueTypes.SetPsIdStrings(SplitArg(value)); sgd.args.PsIds = &val
|
|
case NameReportType:
|
|
val := valueTypes.SetStringValue(value); sgd.args.ReportType = &val
|
|
case NameFaultTypeCode:
|
|
val := valueTypes.SetIntegerString(value); sgd.args.FaultTypeCode = &val
|
|
case NameSize:
|
|
val := valueTypes.SetIntegerString(value); sgd.args.Size = &val
|
|
case NameCurPage:
|
|
val := valueTypes.SetIntegerString(value); sgd.args.CurPage = &val
|
|
case NameDeviceType:
|
|
val := valueTypes.SetStringValue(value); sgd.args.DeviceType = &val
|
|
case NameReportId:
|
|
val := valueTypes.SetStringValue(value); sgd.args.ReportId = &val
|
|
case NameCodeType:
|
|
val := valueTypes.SetStringValue(value); sgd.args.CodeType = &val
|
|
case NameOrgIds:
|
|
val := valueTypes.SetStringValue(value); sgd.args.OrgIds = &val
|
|
case NamePsIdList:
|
|
val := valueTypes.SetStringValue(value); sgd.args.PsIdList = &val
|
|
case NameUuid:
|
|
val := valueTypes.SetStringValue(value); sgd.args.Uuid = &val
|
|
case NameTemplateId:
|
|
val := valueTypes.SetStringValue(value); sgd.args.TemplateId = &val
|
|
case NameDeviceModelId:
|
|
val := valueTypes.SetStringValue(value); sgd.args.DeviceModelId = &val
|
|
|
|
// Points
|
|
case NamePsKeyList:
|
|
val := valueTypes.SetStringValue(value); sgd.args.PsKeyList = &val
|
|
case NamePsKeys:
|
|
val := valueTypes.SetPsKeysString(value); sgd.args.PsKeys = &val
|
|
case NamePsKey:
|
|
val := valueTypes.SetPsKeyString(value); sgd.args.PsKey = &val
|
|
case NamePointId:
|
|
val := valueTypes.SetPointIdString(value); sgd.args.Point = &val
|
|
case NamePoints:
|
|
sgd.SetPoints(value)
|
|
// val := valueTypes.SetPointIdsString(value); sgd.args.Points = &val
|
|
|
|
// DateTime
|
|
case NameDateId:
|
|
sgd.SetDateId(value)
|
|
case NameMonthDate:
|
|
sgd.SetMonthDate(value)
|
|
case NameDay:
|
|
sgd.SetDay(value)
|
|
case NameBeginTime:
|
|
val := valueTypes.SetDateTimeString(value); sgd.args.BeginTime = &val
|
|
case NameEndTime:
|
|
val := valueTypes.SetDateTimeString(value); sgd.args.EndTime = &val
|
|
case NameStartTimeStamp:
|
|
val := valueTypes.SetDateTimeString(value); sgd.args.StartTimeStamp = &val
|
|
case NameEndTimeStamp:
|
|
val := valueTypes.SetDateTimeString(value); sgd.args.EndTimeStamp = &val
|
|
|
|
// UNVERIFIED
|
|
case NameAppKey:
|
|
val := valueTypes.SetStringValue(value); sgd.args.AppKey = &val
|
|
case NameDealerOrgCode:
|
|
val := valueTypes.SetStringValue(value); sgd.args.DealerOrgCode = &val
|
|
case NameDeviceSn:
|
|
val := valueTypes.SetStringValue(value); sgd.args.DeviceSn = &val
|
|
case NameFaultCode:
|
|
val := valueTypes.SetIntegerString(value); sgd.args.FaultCode = &val
|
|
case NameFaultName:
|
|
val := valueTypes.SetStringValue(value); sgd.args.FaultName = &val
|
|
case NameId:
|
|
val := valueTypes.SetIntegerString(value); sgd.args.Id = &val
|
|
case NameMinuteInterval:
|
|
val := valueTypes.SetIntegerString(value); sgd.args.MinuteInterval = &val
|
|
case NameOrderId:
|
|
val := valueTypes.SetStringValue(value); sgd.args.OrderId = &val
|
|
case NameOrgId:
|
|
val := valueTypes.SetStringValue(value); sgd.args.OrgId = &val
|
|
case NamePrefix:
|
|
val := valueTypes.SetStringValue(value); sgd.args.Prefix = &val
|
|
case NamePrimaryKey:
|
|
val := valueTypes.SetStringValue(value); sgd.args.PrimaryKey = &val
|
|
case NameQueryType:
|
|
val := valueTypes.SetStringValue(value); sgd.args.QueryType = &val
|
|
case NameSn:
|
|
val := valueTypes.SetStringValue(value); sgd.args.Sn = &val
|
|
case NameTable:
|
|
val := valueTypes.SetStringValue(value); sgd.args.Table = &val
|
|
case NameTaskId:
|
|
val := valueTypes.SetStringValue(value); sgd.args.TaskId = &val
|
|
case NameUserId:
|
|
val := valueTypes.SetStringValue(value); sgd.args.UserId = &val
|
|
case NameMenuId:
|
|
val := valueTypes.SetIntegerString(value); sgd.args.MenuId = &val
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) Get(arg string) string {
|
|
var value string
|
|
for range Only.Once {
|
|
switch arg {
|
|
case NamePsId:
|
|
value = sgd.args.PsId.String()
|
|
case NamePsId2:
|
|
value = sgd.args.PsId2.String()
|
|
case NamePsId3:
|
|
value = sgd.args.PsId3.String()
|
|
case NamePsIds:
|
|
value = strings.Join(sgd.args.PsIds.Strings(), ",")
|
|
case NameReportType:
|
|
value = sgd.args.ReportType.String()
|
|
case NameFaultTypeCode:
|
|
value = sgd.args.FaultTypeCode.String()
|
|
case NameSize:
|
|
value = sgd.args.Size.String()
|
|
case NameCurPage:
|
|
value = sgd.args.CurPage.String()
|
|
case NameDeviceType:
|
|
value = sgd.args.DeviceType.String()
|
|
case NameReportId:
|
|
value = sgd.args.ReportId.String()
|
|
case NameCodeType:
|
|
value = sgd.args.CodeType.String()
|
|
case NameOrgIds:
|
|
value = sgd.args.OrgIds.String()
|
|
case NamePsIdList:
|
|
value = sgd.args.PsIdList.String()
|
|
case NameUuid:
|
|
value = sgd.args.Uuid.String()
|
|
case NameTemplateId:
|
|
value = sgd.args.TemplateId.String()
|
|
case NameDeviceModelId:
|
|
value = sgd.args.DeviceModelId.String()
|
|
|
|
// Points
|
|
case NamePsKeyList:
|
|
value = sgd.args.PsKeyList.String()
|
|
case NamePsKeys:
|
|
value = sgd.args.PsKeys.String()
|
|
case NamePsKey:
|
|
value = sgd.args.PsKey.String()
|
|
case NamePointId:
|
|
value = sgd.args.Point.String()
|
|
case NamePoints:
|
|
value = sgd.args.Points.String()
|
|
|
|
|
|
// DateTime
|
|
case NameMonthDate:
|
|
value = sgd.args.MonthDate.Original()
|
|
case NameDateId:
|
|
value = sgd.args.DateId.Original()
|
|
case NameDay:
|
|
value = sgd.args.Day.Original()
|
|
case NameBeginTime:
|
|
value = sgd.args.BeginTime.Original()
|
|
case NameEndTime:
|
|
value = sgd.args.EndTime.Original()
|
|
case NameStartTimeStamp:
|
|
value = sgd.args.StartTimeStamp.Original()
|
|
case NameEndTimeStamp:
|
|
value = sgd.args.EndTimeStamp.Original()
|
|
|
|
// UNVERIFIED
|
|
case NameAppKey:
|
|
value = sgd.args.AppKey.String()
|
|
case NameDealerOrgCode:
|
|
value = sgd.args.DealerOrgCode.String()
|
|
case NameDeviceSn:
|
|
value = sgd.args.DeviceSn.String()
|
|
case NameFaultCode:
|
|
value = sgd.args.FaultCode.String()
|
|
case NameFaultName:
|
|
value = sgd.args.FaultName.String()
|
|
case NameId:
|
|
value = sgd.args.Id.String()
|
|
case NameMinuteInterval:
|
|
value = sgd.args.MinuteInterval.String()
|
|
case NameOrderId:
|
|
value = sgd.args.OrderId.String()
|
|
case NameOrgId:
|
|
value = sgd.args.OrgId.String()
|
|
case NamePrefix:
|
|
value = sgd.args.Prefix.String()
|
|
case NamePrimaryKey:
|
|
value = sgd.args.PrimaryKey.String()
|
|
case NameQueryType:
|
|
value = sgd.args.QueryType.String()
|
|
case NameSn:
|
|
value = sgd.args.Sn.String()
|
|
case NameTable:
|
|
value = sgd.args.Table.String()
|
|
case NameTaskId:
|
|
value = sgd.args.TaskId.String()
|
|
case NameUserId:
|
|
value = sgd.args.UserId.String()
|
|
case NameMenuId:
|
|
value = sgd.args.MenuId.String()
|
|
}
|
|
}
|
|
return value
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsSet(arg string) bool {
|
|
var ok bool
|
|
for range Only.Once {
|
|
switch arg {
|
|
case NamePsId:
|
|
if sgd.args.PsId != nil { ok = true }
|
|
case NamePsId2:
|
|
if sgd.args.PsId2 != nil { ok = true }
|
|
case NamePsId3:
|
|
if sgd.args.PsId3 != nil { ok = true }
|
|
case NamePsIds:
|
|
if sgd.args.PsIds != nil { ok = true }
|
|
case NameReportType:
|
|
if sgd.args.ReportType != nil { ok = true }
|
|
case NameDateId:
|
|
if sgd.args.DateId != nil { ok = true }
|
|
case NameFaultTypeCode:
|
|
if sgd.args.FaultTypeCode != nil { ok = true }
|
|
case NameMonthDate:
|
|
if sgd.args.MonthDate != nil { ok = true }
|
|
case NameSize:
|
|
if sgd.args.Size != nil { ok = true }
|
|
case NameCurPage:
|
|
if sgd.args.CurPage != nil { ok = true }
|
|
case NameDeviceType:
|
|
if sgd.args.DeviceType != nil { ok = true }
|
|
case NameReportId:
|
|
if sgd.args.ReportId != nil { ok = true }
|
|
case NameCodeType:
|
|
if sgd.args.CodeType != nil { ok = true }
|
|
case NameOrgIds:
|
|
if sgd.args.OrgIds != nil { ok = true }
|
|
case NamePsIdList:
|
|
if sgd.args.PsIdList != nil { ok = true }
|
|
case NameUuid:
|
|
if sgd.args.Uuid != nil { ok = true }
|
|
case NameTemplateId:
|
|
if sgd.args.TemplateId != nil { ok = true }
|
|
case NameDeviceModelId:
|
|
if sgd.args.DeviceModelId != nil { ok = true }
|
|
|
|
|
|
// Points
|
|
case NamePsKeyList:
|
|
if sgd.args.PsKeyList != nil { ok = true }
|
|
case NamePsKeys:
|
|
if sgd.args.PsKeys != nil { ok = true }
|
|
case NamePsKey:
|
|
if sgd.args.PsKey != nil { ok = true }
|
|
case NamePointId:
|
|
if sgd.args.Point != nil { ok = true }
|
|
case NamePoints:
|
|
if sgd.args.Points != nil { ok = true }
|
|
|
|
|
|
// UNVERIFIED
|
|
case NameDay:
|
|
if sgd.args.Day != nil { ok = true }
|
|
case NameAppKey:
|
|
if sgd.args.AppKey != nil { ok = true }
|
|
case NameBeginTime:
|
|
if sgd.args.BeginTime != nil { ok = true }
|
|
case NameEndTime:
|
|
if sgd.args.EndTime != nil { ok = true }
|
|
case NameDealerOrgCode:
|
|
if sgd.args.DealerOrgCode != nil { ok = true }
|
|
case NameDeviceSn:
|
|
if sgd.args.DeviceSn != nil { ok = true }
|
|
case NameEndTimeStamp:
|
|
if sgd.args.EndTimeStamp != nil { ok = true }
|
|
case NameFaultCode:
|
|
if sgd.args.FaultCode != nil { ok = true }
|
|
case NameFaultName:
|
|
if sgd.args.FaultName != nil { ok = true }
|
|
case NameId:
|
|
if sgd.args.Id != nil { ok = true }
|
|
case NameMinuteInterval:
|
|
if sgd.args.MinuteInterval != nil { ok = true }
|
|
case NameOrderId:
|
|
if sgd.args.OrderId != nil { ok = true }
|
|
case NameOrgId:
|
|
if sgd.args.OrgId != nil { ok = true }
|
|
case NamePrefix:
|
|
if sgd.args.Prefix != nil { ok = true }
|
|
case NamePrimaryKey:
|
|
if sgd.args.PrimaryKey != nil { ok = true }
|
|
case NameQueryType:
|
|
if sgd.args.QueryType != nil { ok = true }
|
|
case NameSn:
|
|
if sgd.args.Sn != nil { ok = true }
|
|
case NameStartTimeStamp:
|
|
if sgd.args.StartTimeStamp != nil { ok = true }
|
|
case NameTable:
|
|
if sgd.args.Table != nil { ok = true }
|
|
case NameTaskId:
|
|
if sgd.args.TaskId != nil { ok = true }
|
|
case NameUserId:
|
|
if sgd.args.UserId != nil { ok = true }
|
|
case NameMenuId:
|
|
if sgd.args.MenuId != nil { ok = true }
|
|
}
|
|
}
|
|
return ok
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsNotSet(arg string) bool {
|
|
return !sgd.IsSet(arg)
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetArgs(args ...string) {
|
|
for range Only.Once {
|
|
for _, arg := range args {
|
|
a := strings.Split(arg, ":")
|
|
if len(a) == 0 {
|
|
continue
|
|
}
|
|
|
|
if len(a) == 1 {
|
|
a = append(a, "")
|
|
}
|
|
|
|
sgd.Set(a[0], a[1])
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) Validate(endpoint api.EndPoint) bool {
|
|
ok := true
|
|
for range Only.Once {
|
|
args := endpoint.GetRequestArgNames()
|
|
for key, value := range args {
|
|
if value != "true" {
|
|
continue
|
|
}
|
|
|
|
if key == NamePsId {
|
|
// Handled differently.
|
|
continue
|
|
}
|
|
if key == NamePsId2 {
|
|
// Handled differently.
|
|
continue
|
|
}
|
|
if key == NamePsId3 {
|
|
// Handled differently.
|
|
continue
|
|
}
|
|
if key == NamePsIds {
|
|
// Handled differently.
|
|
continue
|
|
}
|
|
|
|
if key == NameDateType {
|
|
continue
|
|
}
|
|
|
|
if sgd.IsSet(key) {
|
|
continue
|
|
}
|
|
|
|
ok = false
|
|
fmt.Printf("%s is required\n", key)
|
|
fmt.Printf("%s\n", Help[key])
|
|
}
|
|
}
|
|
return ok
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) GetArgs(endpoint api.EndPoint) string {
|
|
var ret string
|
|
for range Only.Once {
|
|
args := endpoint.GetRequestArgNames()
|
|
for key, value := range args {
|
|
if value != "true" {
|
|
continue
|
|
}
|
|
|
|
if key == NameDateType {
|
|
continue // Handled differently.
|
|
}
|
|
|
|
if sgd.IsNotSet(key) {
|
|
continue
|
|
}
|
|
|
|
ret += fmt.Sprintf("%s:%s ", key, sgd.Get(key))
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) Help(endpoint api.EndPoint) {
|
|
for range Only.Once {
|
|
args := endpoint.GetRequestArgNames()
|
|
for key, value := range args {
|
|
if key == NamePsId {
|
|
continue
|
|
}
|
|
if key == NamePsIds {
|
|
continue
|
|
}
|
|
|
|
if key == NameDateType {
|
|
continue
|
|
}
|
|
|
|
if value != "true" {
|
|
fmt.Printf("optional - %s:value\n", key)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("required - %s:value\n", key)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) RequestAsFilePrefix() string {
|
|
var ret string
|
|
for range Only.Once {
|
|
j, err := json.Marshal(*sgd)
|
|
if err != nil {
|
|
break
|
|
}
|
|
ret = string(j)
|
|
ret = strings.TrimPrefix(ret, "{")
|
|
ret = strings.TrimSuffix(ret, "}")
|
|
ret = strings.ReplaceAll(ret, `"`, ``)
|
|
ret = strings.ReplaceAll(ret, `,`, `-`)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetDateId(date string) {
|
|
for range Only.Once {
|
|
// if sgd.IsNotRequired(NameDateId) {
|
|
// break
|
|
// }
|
|
var did valueTypes.DateTime
|
|
if date == "total" {
|
|
did = valueTypes.NewDateTime(valueTypes.Now)
|
|
did.DateType = "4"
|
|
} else {
|
|
did = valueTypes.SetDateTimeString(date)
|
|
}
|
|
sgd.args.DateId = &did
|
|
if sgd.args.DateId.IsZero() {
|
|
did = valueTypes.NewDateTime(valueTypes.Now)
|
|
sgd.args.DateId = &did
|
|
}
|
|
|
|
sgd.args.DateType = &did.DateType
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetMonthDate(date string) {
|
|
for range Only.Once {
|
|
did := valueTypes.SetDateTimeString(date)
|
|
sgd.args.MonthDate = &did
|
|
if sgd.args.MonthDate.IsZero() {
|
|
did = valueTypes.NewDateTime(valueTypes.Now)
|
|
sgd.args.MonthDate = &did
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetDay(date string) {
|
|
for range Only.Once {
|
|
// if sgd.IsNotRequired(NameDay) {
|
|
// break
|
|
// }
|
|
did := valueTypes.SetDateTimeString(date)
|
|
sgd.args.Day = &did
|
|
if sgd.args.Day.IsZero() {
|
|
now := time.Now().Format(valueTypes.DateLayoutDay)
|
|
did = valueTypes.NewDateTime(now)
|
|
sgd.args.Day = &did
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetStartTimeStamp(date string) {
|
|
for range Only.Once {
|
|
// if sgd.IsNotRequired(NameDay) {
|
|
// break
|
|
// }
|
|
did := valueTypes.SetDateTimeString(date)
|
|
sgd.args.StartTimeStamp = &did
|
|
if sgd.args.StartTimeStamp.IsZero() {
|
|
now := time.Now().Format(valueTypes.DateTimeLayoutSecond)
|
|
did = valueTypes.NewDateTime(now)
|
|
sgd.args.StartTimeStamp = &did
|
|
// Use valueTypes.GetDayStartTimestamp
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetEndTimeStamp(date string) {
|
|
for range Only.Once {
|
|
// if sgd.IsNotRequired(NameDay) {
|
|
// break
|
|
// }
|
|
did := valueTypes.SetDateTimeString(date)
|
|
sgd.args.EndTimeStamp = &did
|
|
if sgd.args.EndTimeStamp.IsZero() {
|
|
now := time.Now().Format(valueTypes.DateTimeLayoutSecond)
|
|
did = valueTypes.NewDateTime(now)
|
|
sgd.args.EndTimeStamp = &did
|
|
// Use valueTypes.GetDayEndTimestamp
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetFaultTypeCode(ftc string) {
|
|
for range Only.Once {
|
|
// if sgd.IsNotRequired(NameFaultTypeCode) {
|
|
// break
|
|
// }
|
|
aftc := valueTypes.SetIntegerString(ftc)
|
|
sgd.args.FaultTypeCode = &aftc
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetReportType(rt string) {
|
|
for range Only.Once {
|
|
// if sgd.IsNotRequired(NameReportType) {
|
|
// break
|
|
// }
|
|
art := valueTypes.SetStringValue(rt)
|
|
sgd.args.ReportType = &art
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetPSIDs(psIds []string) {
|
|
sgd.aPsId = valueTypes.SetPsIdStrings(psIds)
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) GetPSIDs() valueTypes.PsIds {
|
|
return sgd.aPsId
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetRequired(req map[string]string) {
|
|
sgd.Required = req
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsRequiredAndNotSet(arg string) bool {
|
|
var yes bool
|
|
for range Only.Once {
|
|
if _, ok := sgd.Required[arg]; !ok {
|
|
break
|
|
}
|
|
if sgd.IsNotRequired(arg) {
|
|
break
|
|
}
|
|
if sgd.IsSet(arg) {
|
|
break
|
|
}
|
|
yes = true
|
|
}
|
|
return yes
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsRequiredAndSet(arg string) bool {
|
|
return !sgd.IsRequiredAndNotSet(arg)
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetIfRequired(arg string, value string) {
|
|
for range Only.Once {
|
|
if sgd.IsNotRequired(arg) {
|
|
break
|
|
}
|
|
if sgd.IsRequiredAndSet(arg) {
|
|
break
|
|
}
|
|
sgd.Set(arg, value)
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetPsId(psId string) {
|
|
for range Only.Once {
|
|
// if sgd.IsNotRequired(NamePsId) {
|
|
// break
|
|
// }
|
|
if psId == "" {
|
|
sgd.args.PsId = nil
|
|
break
|
|
}
|
|
|
|
pid := valueTypes.SetPsIdString(psId)
|
|
if pid.Error != nil {
|
|
fmt.Printf("Error: %s - %s\n", NamePsId, pid.Error)
|
|
break
|
|
}
|
|
|
|
if sgd.IsRequired(NamePsId) {
|
|
sgd.args.PsId = &pid
|
|
}
|
|
if sgd.IsRequired(NamePsId2) {
|
|
sgd.args.PsId2 = &pid // Specifically for WebIscmAppService.getPowerStationInfo
|
|
}
|
|
if sgd.IsRequired(NamePsId3) {
|
|
sgd.args.PsId3 = &pid // Specifically for WebAppService.getPsTree
|
|
}
|
|
if sgd.IsRequired(NamePsIds) {
|
|
// sgd.args.PsIds = &pid
|
|
}
|
|
|
|
sgd.SetIfRequired(NamePsId, psId)
|
|
// sgd.SetIfRequired(NamePsId2, psId)
|
|
// sgd.SetIfRequired(NamePsId3, psId)
|
|
// sgd.SetIfRequired(NamePsIds, psId)
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) SetPoints(points string) {
|
|
for range Only.Once {
|
|
pids := valueTypes.SetPointIdsString(points)
|
|
if pids.Error != nil {
|
|
fmt.Printf("Error: %s - %s\n", NamePsId, sgd.args.Points.Error)
|
|
break
|
|
}
|
|
|
|
var pskeys []string
|
|
for _, pskey := range pids.PointIds {
|
|
pskeys = append(pskeys, pskey.PsKey.String())
|
|
}
|
|
sgd.args.Points = &pids
|
|
psk := valueTypes.SetPsKeysString(strings.Join(pskeys, ","))
|
|
if sgd.IsRequired(NamePsKey) {
|
|
sgd.args.PsKey = &psk.PsKeys[0]
|
|
}
|
|
if sgd.IsRequired(NamePsKeys) {
|
|
sgd.args.PsKeys = &psk
|
|
}
|
|
}
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsRequired(req string) bool {
|
|
var yes bool
|
|
if _, ok := sgd.Required[req]; ok {
|
|
yes = true
|
|
}
|
|
return yes
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsNotRequired(req string) bool {
|
|
return !sgd.IsRequired(req)
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsPsIdRequired() bool {
|
|
if sgd.IsRequired(NamePsId) {
|
|
return true
|
|
}
|
|
if sgd.IsRequired(NamePsId2) {
|
|
return true
|
|
}
|
|
if sgd.IsRequired(NamePsId3) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (sgd *SunGrowDataRequest) IsPsIdNotRequired() bool {
|
|
return !sgd.IsPsIdRequired()
|
|
}
|