iot_server/internal/dtos/thingmodeltemplate.go

577 lines
19 KiB
Go

/*******************************************************************************
* Copyright 2017 Dell Inc.
* Copyright (c) 2019 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*******************************************************************************/
package dtos
import (
"encoding/json"
"github.com/winc-link/hummingbird/internal/models"
"github.com/winc-link/hummingbird/internal/pkg/constants"
"github.com/winc-link/hummingbird/internal/pkg/utils"
"strconv"
"strings"
"time"
)
type ThingModelTemplate struct {
Properties []ThingModelTemplateProperties `json:"properties"`
Events []ThingModelTemplateEvents `json:"events"`
Services []ThingModelTemplateServices `json:"services"`
}
//------------------------------------------------------------
//array
//{
//"childDataType":"TEXT",
//"customFlag":true,
//"dataType":"ARRAY",
//"size":128
//}
type ThingModelTemplateArray struct {
ChildDataType string `json:"childDataType"`
Size int `json:"size"`
}
//------------------------------------------------------------
//{
// "dataType":"DOUBLE",
// "max":"23",
// "min":"16",
// "precise":7,
// "step":"0.01",
// "unit":"°C",
// "unitName":"摄氏度"
//}
type ThingModelTemplateIntOrFloat struct {
Max string `json:"max"`
Min string `json:"min"`
Step string `json:"step"`
Unit string `json:"unit"`
UnitName string `json:"unitName"`
}
//------------------------------------------------------------
//[
//{
//"dataType":"BOOL",
//"name":"未查询",
//"value":0
//},
//{
//"dataType":"BOOL",
//"name":"查询",
//"value":1
//}
//]
type ThingModelTemplateBool struct {
Name string `json:"name"`
Value int `json:"value"`
}
//------------------------------------------------------------
//{
//"dataType":"TEXT",
//"length":255
//}
type ThingModelTemplateText struct {
Length int `json:"length"`
}
//------------------------------------------------------------
//{
//"dataType":"Date",
//"length":255
//}
type ThingModelTemplateDate struct {
Length string `json:"length"`
}
//------------------------------------------------------------
//[
//{
//"dataType":"ENUM",
//"name":"电源",
//"value":0
//},
//{
//"dataType":"ENUM",
//"name":"电池",
//"value":1
//}
//]
type ThingModelTemplateEnum struct {
Name string `json:"name"`
Value int `json:"value"`
}
type ThingModelTemplateStruct struct {
ChildDataType string `json:"childDataType"`
ChildName string `json:"childName"`
Identifier string `json:"identifier"`
ChildSpecsDTO interface{} `json:"childSpecsDTO"`
}
//------------------------------------------------------------
// INT DOUBLE FLOAT TEXT ARRAY=> dataSpecs
//BOOL ENUM STRUCT=> dataSpecsList
type ThingModelTemplateProperties struct {
Name string `json:"name"`
Identifier string `json:"identifier"`
DataType string `json:"dataType"`
Description string `json:"description"`
Required bool `json:"required"`
RwFlag string `json:"rwFlag"`
DataSpecs interface{} `json:"dataSpecs"`
DataSpecsList interface{} `json:"dataSpecsList"`
}
func (t *ThingModelTemplateProperties) TransformModelTypeSpec() (typeSpec models.TypeSpec) {
return getThingModelTemplateTypeSpec(t.DataType, t.DataSpecs, t.DataSpecsList)
}
func getModelSpecByDataType(specType constants.SpecsType, dto interface{}) string {
switch specType {
case constants.SpecsTypeInt, constants.SpecsTypeFloat:
thingModelTemplateIntOrFloat := new(ThingModelTemplateIntOrFloat)
b, _ := json.Marshal(dto)
err := json.Unmarshal(b, thingModelTemplateIntOrFloat)
if err != nil {
return ""
}
var modelTypeSpecIntOrFloat models.TypeSpecIntOrFloat
modelTypeSpecIntOrFloat.Max = thingModelTemplateIntOrFloat.Max
modelTypeSpecIntOrFloat.Min = thingModelTemplateIntOrFloat.Min
modelTypeSpecIntOrFloat.Step = thingModelTemplateIntOrFloat.Step
modelTypeSpecIntOrFloat.Unit = thingModelTemplateIntOrFloat.Unit
modelTypeSpecIntOrFloat.UnitName = thingModelTemplateIntOrFloat.UnitName
return modelTypeSpecIntOrFloat.TransformTostring()
case constants.SpecsTypeText:
thingModelTemplateText := new(ThingModelTemplateText)
b, _ := json.Marshal(dto)
err := json.Unmarshal(b, thingModelTemplateText)
if err != nil {
return ""
}
var modelTypeSpecText models.TypeSpecText
modelTypeSpecText.Length = strconv.Itoa(thingModelTemplateText.Length)
return modelTypeSpecText.TransformTostring()
case constants.SpecsTypeDate:
var modelTypeSpecText models.TypeSpecDate
return modelTypeSpecText.TransformTostring()
case constants.SpecsTypeBool:
thingModelTemplateBool := new([]ThingModelTemplateBool)
b, _ := json.Marshal(dto)
err := json.Unmarshal(b, thingModelTemplateBool)
if err != nil {
return ""
}
var modelTypeSpecBool models.TypeSpecBool
modelTypeSpecBool = make(map[string]string)
if thingModelTemplateBool != nil {
for _, templateBool := range *thingModelTemplateBool {
modelTypeSpecBool[strconv.Itoa(templateBool.Value)] = templateBool.Name
}
}
return modelTypeSpecBool.TransformTostring()
case constants.SpecsTypeEnum:
thingModelTemplateEnum := new([]ThingModelTemplateEnum)
b, _ := json.Marshal(dto)
err := json.Unmarshal(b, thingModelTemplateEnum)
if err != nil {
return ""
}
var modelTypeSpecEunm models.TypeSpecEnum
modelTypeSpecEunm = make(map[string]string)
if thingModelTemplateEnum != nil {
for _, templateEunm := range *thingModelTemplateEnum {
modelTypeSpecEunm[strconv.Itoa(templateEunm.Value)] = templateEunm.Name
}
}
return modelTypeSpecEunm.TransformTostring()
case constants.SpecsTypeArray:
thingModelTemplateArray := new(ThingModelTemplateArray)
b, _ := json.Marshal(dto)
err := json.Unmarshal(b, thingModelTemplateArray)
if err != nil {
return ""
}
var modelTypeSpecArray models.TypeSpecArray
modelTypeSpecArray.Size = strconv.Itoa(thingModelTemplateArray.Size)
modelTypeSpecArray.Item = models.Item{
Type: thingModelTemplateArray.ChildDataType,
}
return modelTypeSpecArray.TransformTostring()
}
return ""
}
func transformSpecType(specType string) constants.SpecsType {
var specs constants.SpecsType
switch specType {
case "INT":
specs = constants.SpecsTypeInt
case "DOUBLE", "FLOAT":
specs = constants.SpecsTypeFloat
case "TEXT":
specs = constants.SpecsTypeText
case "ARRAY":
specs = constants.SpecsTypeArray
case "BOOL":
specs = constants.SpecsTypeBool
case "ENUM":
specs = constants.SpecsTypeEnum
case "STRUCT":
specs = constants.SpecsTypeStruct
case "DATE":
specs = constants.SpecsTypeDate
}
return specs
}
//ASYNC SYNC
type ThingModelTemplateServices struct {
ServiceName string `json:"serviceName"`
Identifier string `json:"identifier"`
Description string `json:"description"`
Required bool `json:"required"`
CallType constants.CallType `json:"callType"`
InputParams []ThingModelTemplateServicesInputParam `json:"inputParams"`
OutParams []ThingModelTemplateServicesOutParam `json:"outParams"`
}
type ThingModelTemplateServicesInputParam struct {
Name string `json:"name"`
Identifier string `json:"identifier"`
DataType string `json:"dataType"`
DataSpecs interface{} `json:"dataSpecs"`
DataSpecsList interface{} `json:"dataSpecsList"`
}
type ThingModelTemplateServicesOutParam struct {
Name string `json:"name"`
Identifier string `json:"identifier"`
DataType string `json:"dataType"`
DataSpecs interface{} `json:"dataSpecs"`
DataSpecsList interface{} `json:"dataSpecsList"`
}
func (t *ThingModelTemplateServices) TransformModelInPutParams() (inPutParams models.InPutParams) {
for _, datum := range t.InputParams {
var inputOutput models.InputOutput
inputOutput.Code = datum.Identifier
inputOutput.Name = datum.Name
inputOutput.TypeSpec = getThingModelTemplateTypeSpec(datum.DataType, datum.DataSpecs, datum.DataSpecsList)
inPutParams = append(inPutParams, inputOutput)
}
return
}
func (t *ThingModelTemplateServices) TransformModelOutPutParams() (outPutParams models.OutPutParams) {
for _, datum := range t.OutParams {
var inputOutput models.InputOutput
inputOutput.Code = datum.Identifier
inputOutput.Name = datum.Name
inputOutput.TypeSpec = getThingModelTemplateTypeSpec(datum.DataType, datum.DataSpecs, datum.DataSpecsList)
outPutParams = append(outPutParams, inputOutput)
}
return
}
type ThingModelTemplateEvents struct {
EventName string `json:"eventName"`
EventType string `json:"eventType"`
Identifier string `json:"identifier"`
Description string `json:"description"`
Required bool `json:"required"`
OutputData []ThingModelTemplateEventsOutputData `json:"outputData"`
}
type ThingModelTemplateEventsOutputData struct {
Name string `json:"name"`
Identifier string `json:"identifier"`
DataType string `json:"dataType"`
Required bool `json:"required"`
DataSpecs interface{} `json:"dataSpecs"`
DataSpecsList interface{} `json:"dataSpecsList"`
}
func (t *ThingModelTemplateEvents) TransformModelOutputParams() (outPutParams models.OutPutParams) {
for _, datum := range t.OutputData {
var inputOutput models.InputOutput
inputOutput.Code = datum.Identifier
inputOutput.Name = datum.Name
inputOutput.TypeSpec = getThingModelTemplateTypeSpec(datum.DataType, datum.DataSpecs, datum.DataSpecsList)
outPutParams = append(outPutParams, inputOutput)
}
return outPutParams
}
func getThingModelTemplateTypeSpec(dataType string, dataSpecs, dataSpecsList interface{}) (typeSpec models.TypeSpec) {
typeSpec.Type = transformSpecType(dataType)
switch typeSpec.Type {
case constants.SpecsTypeInt, constants.SpecsTypeFloat:
thingModelTemplateIntOrFloat := new(ThingModelTemplateIntOrFloat)
b, _ := json.Marshal(dataSpecs)
err := json.Unmarshal(b, thingModelTemplateIntOrFloat)
if err != nil {
return
}
var modelTypeSpecIntOrFloat models.TypeSpecIntOrFloat
modelTypeSpecIntOrFloat.Max = thingModelTemplateIntOrFloat.Max
modelTypeSpecIntOrFloat.Min = thingModelTemplateIntOrFloat.Min
modelTypeSpecIntOrFloat.Step = thingModelTemplateIntOrFloat.Step
modelTypeSpecIntOrFloat.Unit = thingModelTemplateIntOrFloat.Unit
modelTypeSpecIntOrFloat.UnitName = thingModelTemplateIntOrFloat.UnitName
typeSpec.Specs = modelTypeSpecIntOrFloat.TransformTostring()
case constants.SpecsTypeText:
thingModelTemplateText := new(ThingModelTemplateText)
b, _ := json.Marshal(dataSpecs)
err := json.Unmarshal(b, thingModelTemplateText)
if err != nil {
return
}
var modelTypeSpecText models.TypeSpecText
modelTypeSpecText.Length = strconv.Itoa(thingModelTemplateText.Length)
typeSpec.Specs = modelTypeSpecText.TransformTostring()
case constants.SpecsTypeDate:
var modelTypeSpecText models.TypeSpecDate
typeSpec.Specs = modelTypeSpecText.TransformTostring()
case constants.SpecsTypeBool:
thingModelTemplateBool := new([]ThingModelTemplateBool)
b, _ := json.Marshal(dataSpecsList)
err := json.Unmarshal(b, thingModelTemplateBool)
if err != nil {
return
}
var modelTypeSpecBool models.TypeSpecBool
modelTypeSpecBool = make(map[string]string)
if thingModelTemplateBool != nil {
for _, templateBool := range *thingModelTemplateBool {
modelTypeSpecBool[strconv.Itoa(templateBool.Value)] = templateBool.Name
}
}
typeSpec.Specs = modelTypeSpecBool.TransformTostring()
case constants.SpecsTypeEnum:
thingModelTemplateEnum := new([]ThingModelTemplateEnum)
b, _ := json.Marshal(dataSpecsList)
err := json.Unmarshal(b, thingModelTemplateEnum)
if err != nil {
return
}
var modelTypeSpecEunm models.TypeSpecEnum
modelTypeSpecEunm = make(map[string]string)
if thingModelTemplateEnum != nil {
for _, templateEunm := range *thingModelTemplateEnum {
modelTypeSpecEunm[strconv.Itoa(templateEunm.Value)] = templateEunm.Name
}
}
typeSpec.Specs = modelTypeSpecEunm.TransformTostring()
case constants.SpecsTypeArray:
thingModelTemplateArray := new(ThingModelTemplateArray)
b, _ := json.Marshal(dataSpecs)
err := json.Unmarshal(b, thingModelTemplateArray)
if err != nil {
return
}
var modelTypeSpecArray models.TypeSpecArray
modelTypeSpecArray.Size = strconv.Itoa(thingModelTemplateArray.Size)
modelTypeSpecArray.Item = models.Item{
Type: strings.ToLower(thingModelTemplateArray.ChildDataType),
}
typeSpec.Specs = modelTypeSpecArray.TransformTostring()
case constants.SpecsTypeStruct:
thingModelTemplateStruct := new([]ThingModelTemplateStruct)
b, _ := json.Marshal(dataSpecsList)
err := json.Unmarshal(b, thingModelTemplateStruct)
if err != nil {
return
}
var modelTypeSpecStruct []models.TypeSpecStruct
if thingModelTemplateStruct != nil {
for _, templateStruct := range *thingModelTemplateStruct {
modelTypeSpecStruct = append(modelTypeSpecStruct, models.TypeSpecStruct{
Code: templateStruct.Identifier,
Name: templateStruct.ChildName,
DataType: models.TypeSpec{
Type: transformSpecType(templateStruct.ChildDataType),
Specs: getModelSpecByDataType(transformSpecType(templateStruct.ChildDataType), templateStruct.ChildSpecsDTO),
},
})
}
}
bm, _ := json.Marshal(modelTypeSpecStruct)
typeSpec.Specs = string(bm)
}
return
}
func GetModelPropertyEventActionByThingModelTemplate(thingModelJSON string) (properties []models.Properties, events []models.Events, actions []models.Actions) {
thingModelTemplate := new(ThingModelTemplate)
err := json.Unmarshal([]byte(thingModelJSON), thingModelTemplate)
if err == nil {
for _, property := range thingModelTemplate.Properties {
var accessMode string
if property.RwFlag == "READ_ONLY" {
accessMode = "R"
} else if property.RwFlag == "READ_WRITE" {
accessMode = "RW"
} else if property.RwFlag == "WRITE_ONLY" {
accessMode = "W"
}
properties = append(properties, models.Properties{
Id: utils.RandomNum(),
Name: property.Name,
Code: property.Identifier,
AccessMode: accessMode,
Require: property.Required,
Description: property.Description,
TypeSpec: property.TransformModelTypeSpec(),
Tag: string(constants.TagNameSystem),
Timestamps: models.Timestamps{
Created: time.Now().UnixMilli(),
},
})
}
for _, event := range thingModelTemplate.Events {
var eventType constants.EventType
if event.EventType == "ALERT_EVENT_TYPE" {
eventType = constants.EventTypeAlert
} else if event.EventType == "INFO_EVENT_TYPE" {
eventType = constants.EventTypeInfo
} else if event.EventType == "ERROR_EVENT_TYPE" {
eventType = constants.EventTypeError
}
events = append(events, models.Events{
Id: utils.RandomNum(),
Name: event.EventName,
EventType: string(eventType),
Code: event.Identifier,
Require: event.Required,
Description: event.Description,
OutputParams: event.TransformModelOutputParams(),
Tag: string(constants.TagNameSystem),
Timestamps: models.Timestamps{
Created: time.Now().UnixMilli(),
},
})
}
for _, service := range thingModelTemplate.Services {
actions = append(actions, models.Actions{
Id: utils.RandomNum(),
Name: service.ServiceName,
Code: service.Identifier,
CallType: service.CallType,
Require: service.Required,
Description: service.Description,
InputParams: service.TransformModelInPutParams(),
OutputParams: service.TransformModelOutPutParams(),
Tag: string(constants.TagNameSystem),
Timestamps: models.Timestamps{
Created: time.Now().UnixMilli(),
},
})
}
}
return
}
//func OpenApiGetModelPropertyEventActionByThingModelTemplate(req OpenApiAddRequest) (properties []models.Properties, events []models.Events, actions []models.Actions) {
// for _, property := range req.Properties {
// properties = append(properties, models.Properties{
// Id: utils.RandomNum(),
// Name: property.Name,
// Code: property.Code,
// AccessMode: property.AccessMode,
// Require: property.Required,
// Description: property.Description,
// TypeSpec: models.TypeSpec(property.TypeSpec),
// Tag: string(constants.TagNameCustom),
// Timestamps: models.Timestamps{
// Created: time.Now().UnixMilli(),
// },
// })
// }
//
// for _, event := range req.Events {
// var outPutParams models.OutPutParams
// for _, param := range event.OutputParams {
// outPutParams = append(outPutParams, models.InputOutput{
// Code: param.Code,
// Name: param.Name,
// TypeSpec: models.TypeSpec{
// Type: param.TypeSpec.Type,
// Specs: param.TypeSpec.Specs,
// },
// })
// }
// events = append(events, models.Events{
// Id: utils.RandomNum(),
// Name: event.Name,
// EventType: event.EventType,
// Code: event.Code,
// Require: event.Required,
// Description: event.Description,
// OutputParams: outPutParams,
// Tag: string(constants.TagNameCustom),
// Timestamps: models.Timestamps{
// Created: time.Now().UnixMilli(),
// },
// })
// }
//
// for _, action := range req.Actions {
// var inPutParams models.InPutParams
// var outPutParams models.OutPutParams
// for _, param := range action.InputParams {
// inPutParams = append(inPutParams, models.InputOutput{
// Code: param.Code,
// Name: param.Name,
// TypeSpec: models.TypeSpec{
// Type: param.TypeSpec.Type,
// Specs: param.TypeSpec.Specs,
// },
// })
// }
// for _, param := range action.OutputParams {
// outPutParams = append(outPutParams, models.InputOutput{
// Code: param.Code,
// Name: param.Name,
// TypeSpec: models.TypeSpec{
// Type: param.TypeSpec.Type,
// Specs: param.TypeSpec.Specs,
// },
// })
// }
// actions = append(actions, models.Actions{
// Id: utils.RandomNum(),
// Name: action.Name,
// Code: action.Code,
// CallType: action.CallType,
// Require: action.Required,
// Description: action.Description,
// InputParams: inPutParams,
// OutputParams: outPutParams,
// Tag: string(constants.TagNameCustom),
// Timestamps: models.Timestamps{
// Created: time.Now().UnixMilli(),
// },
// })
// }
// return
//}