package node_attr

import (
	"scd_check_tools/logger"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"reflect"
	"runtime"
	"strings"

	"github.com/astaxie/beego/orm"
)

type AttrsMgr struct {
	ScdId   int64
	objlist map[string][]string
}

func (c *AttrsMgr) Ready() {
	c.objlist = map[string][]string{}
}

func (c *AttrsMgr) Flush() {
	if len(c.objlist) > 0 {
		db := orm.NewOrm()
		//db.Begin()
		var err error
		for k, lst := range c.objlist {
			length := len(lst)
			//log.Println(fmt.Sprintf("%s 节点属性记录数:%d", k, length))
			if length <= 5000 {
				//fmt.Println(fmt.Sprintf("%+v", lst))
				_, err = db.Raw("insert into " + k + "values" + strings.Join(lst, ",")).Exec()
				if err != nil {
					log.Println(k)
					log.Println(err)
				}
			} else {
				i := 5000
				i2 := 0
				for {
					if i2 > length {
						break
					}
					vls := strings.Join(lst[i2:i2+i], ",")
					if vls == "" {
						break
					}
					_, err = db.Raw("insert into " + k + "values" + vls).Exec()
					if err != nil {
						log.Println(k)
						log.Println(err)
					}
					i2 = i2 + i
					if length-i2 < i {
						i = length - i2
					}
				}
			}

			c.objlist[k] = nil
		}
		//db.Commit()
		c.objlist = nil
		runtime.GC()
	}
}

func (c *AttrsMgr) UpdateAttrs(attrObj map[string]interface{}) error {
	nodeid := attrObj["nodeid"].(int64)
	nodename := attrObj["nodename"].(string)
	atts := attrObj["attrs"].(map[string]interface{})
	v := reflect.ValueOf(c)
	inparam := make([]reflect.Value, 0)
	inparam = append(inparam, reflect.ValueOf(nodeid))
	inparam = append(inparam, reflect.ValueOf(atts))
	//smv节点需要单独处理。整个文件中有2个smv节点，其中一个为connectedap下的；另一个在IED的Services节点下
	if nodename == "SMV" {
		parentNodeName := attrObj["parentNodeName"].(string)
		if parentNodeName == "ConnectedAP" {
			nodename = "connectedap_smv"
		}
	}
	method := "Make_attr_" + strings.ToLower(nodename)
	mv := v.MethodByName(method)
	if !mv.IsValid() {
		log.Println("未指定节点的" + nodename + "属性模型对象")
		//通用处理
		return errors.New("NO-NODE")
	}
	resultObj := mv.Call(inparam)
	err, _ := resultObj[2].Interface().(error)
	if err != nil {
		logger.Logger.Error(err)
		return err
	}
	cols := resultObj[0].Interface().(string)
	value := resultObj[1].Interface().(string)
	lst := c.objlist[cols]
	if lst != nil {
		c.objlist[cols] = append(lst, value)
	} else {
		c.objlist[cols] = []string{value}
	}
	return nil
}

//将节点属性转换为指定的对象
//需要在定义对象时标识对应的json属性名
//目标对象需要以传址方式传递
func (c *AttrsMgr) attr_trans(atts map[string]interface{}, obj interface{}) error {
	jsonstr, err := json.Marshal(atts)
	if err != nil {
		log.Println(err)
		return err
	}
	err = json.Unmarshal(jsonstr, &obj)
	if err != nil {
		log.Println(err)
		return err
	}
	return nil
}

func (c *AttrsMgr) Make_attr_scl(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_scl_attrs{}
	obj.NodeId = nodeid
	//obj.AttrXmlns = tools.IsEmpty(atts["xmlns"])
	//obj.AttrXmlnsExt = atts["ext"].(string)
	//obj.AttrXsiSchemaLocation = atts["schemaLocation"].(string)
	//obj.AttrXmlnsXsi = atts["xsi"].(string)
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_scl_attrs(scd_id,node_id,attr_xmlns,attr_xmlns_ext,attr_xmlns_xsi,attr_xsi_schema_location)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrXmlns, obj.AttrXmlnsExt, obj.AttrXmlnsXsi, obj.AttrXsiSchemaLocation}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_private(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_private_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_private_attrs(scd_id,node_id,attr_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_voltage(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_voltage_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_voltage_attrs(scd_id,node_id,attr_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_bay(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_bay_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_bay_attrs(scd_id,node_id,attr_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_header(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_header_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_header_attrs(scd_id,node_id,attr_id,attr_namestructure,attr_reversion,attr_toolid,attr_version)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrId, obj.AttrNamestructure, obj.AttrReversion, obj.AttrToolid, obj.AttrVersion}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_substation(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_substation_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_substation_attrs(scd_id,node_id,attr_name,attr_desc)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrName, obj.AttrDesc}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_hitem(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_hitem_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_hitem_attrs(scd_id,node_id,attr_version,attr_revision,attr_what,attr_when,attr_who,attr_why)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrVersion, obj.AttrReversion, obj.AttrWhat, obj.AttrWhen, obj.AttrWho, obj.AttrWhy}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_communication(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_communication_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_communication_attrs(scd_id,node_id,attr_desc)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_subnetwork(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_subnetwork_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_subnetwork_attrs(scd_id,node_id,attr_desc,attr_name,attr_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName, obj.AttrType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_bitrate(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_bitrate_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_bitrate_attrs(scd_id,node_id,attr_multiplier,attr_unit)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMultiplier, obj.AttrUnit}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_connectedap(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_connectedap_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_connectedap_attrs(scd_id,node_id,attr_ap_name,attr_desc,attr_ied_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrApName, obj.AttrDesc, obj.AttrIedName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_p(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_p_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_p_attrs(scd_id,node_id,attr_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_physconn(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_physconn_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_physconn_attrs(scd_id,node_id,attr_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_gse(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_gse_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_gse_attrs(scd_id,node_id,attr_cb_name,attr_ld_inst,attr_desc)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrCbName, obj.AttrLdInst, obj.AttrDesc}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_mintime(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_mintime_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_mintime_attrs(scd_id,node_id,attr_unit,attr_multiplier)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrUnit, obj.AttrMultiplier}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_maxtime(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_maxtime_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_maxtime_attrs(scd_id,node_id,attr_unit,attr_multiplier)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrUnit, obj.AttrMultiplier}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_ied(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_ied_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_ied_attrs(scd_id,node_id,attr_config_version,attr_desc,attr_eng_right,attr_manufacturer,attr_name,attr_original_scl_revision,attr_original_scl_version,attr_owner,attr_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrConfigVersion, obj.AttrDesc, obj.AttrEngRight, obj.AttrManufacturer, obj.AttrName, obj.AttrOriginalSclRevision, obj.AttrOriginalSclVersion, obj.AttrOwner, obj.AttrType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_dynassociation(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_dynassociation_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_dynassociation_attrs(scd_id,node_id,attr_max)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_confdataset(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_confdataset_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_confdataset_attrs(scd_id,node_id,attr_max,attr_fccb,attr_max_attributes,attr_modify)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax, obj.AttrFccb, obj.AttrMaxAttributes, obj.AttrModify}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_dyndataset(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_dyndataset_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_dyndataset_attrs(scd_id,node_id,attr_max,attr_max_attributes)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax, obj.AttrMaxAttributes}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_confreportcontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_confreportcontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_confreportcontrol_attrs(scd_id,node_id,attr_max,attr_buf_conf,attr_buf_mode)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax, obj.AttrBufConf, obj.AttrBufMode}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_conflogcontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_conflogcontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_conflogcontrol_attrs(scd_id,node_id,attr_max)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_reportsettings(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_reportsettings_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_reportsettings_attrs(scd_id,node_id,attr_cb_name,attr_buf_time,attr_dat_set,attr_intg_pd,attr_opt_fields,attr_rpt_id,attr_trg_ops)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrCbName, obj.AttrBufTime, obj.AttrDatSet, obj.AttrIntgPd, obj.AttrOptFields, obj.AttrRptId, obj.AttrTrgOps}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}

func (c *AttrsMgr) Make_attr_logsettings(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_logsettings_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_logsettings_attrs(scd_id,node_id,attr_cb_name,attr_dat_set,attr_intg_pd,attr_log_ena,attr_trg_ops)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrCbName, obj.AttrDatSet, obj.AttrIntgPd, obj.AttrLogEna, obj.AttrTrgOps}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_gsesettings(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_gsesettings_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_gsesettings_attrs(scd_id,node_id,attr_app_id,attr_cb_name,attr_data_label,attr_dat_set)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrAppId, obj.AttrCbName, obj.AttrDataLabel, obj.AttrDatSet}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_smvsettings(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_smvsettings_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_smvsettings_attrs(scd_id,node_id,attr_sv_id,attr_smp_rate,attr_cb_name,attr_opt_fields,attr_dat_set)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrSvId, obj.AttrSmpRate, obj.AttrCbName, obj.AttrOptFields, obj.AttrDatSet}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_goose(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_goose_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_goose_attrs(scd_id,node_id,attr_max)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_gsse(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_gsse_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "Make_attr_gsse(node_id,attr_max)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_conflns(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_conflns_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_conflns_attrs(scd_id,node_id,attr_fix_ln_inst,attr_fix_prefix)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrFixLnInst, obj.AttrFixPrefix}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_clientservices(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_clientservices_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_clientservices_attrs(scd_id,node_id,attr_buf_report,attr_fccb,attr_goose,attr_gsse,attr_read_log,attr_sv,attr_unbuf_report)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrBufReport, obj.AttrFccb, obj.AttrGoose, obj.AttrGsse, obj.AttrReadLog, obj.AttrSv, obj.AttrUnbufReport}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_accesspoint(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_accesspoint_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_accesspoint_attrs(scd_id,node_id,attr_clock,attr_desc,attr_name,attr_router)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrClock, obj.AttrDesc, obj.AttrName, obj.AttrRouter}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_server(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_server_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_server_attrs(scd_id,node_id,attr_name,attr_timeout)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrName, obj.AttrTimeout}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_authentication(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_authentication_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_authentication_attrs(scd_id,node_id,attr_certificate,attr_none,attr_password,attr_strong,attr_weak)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrCertificate, obj.AttrNone, obj.AttrPassword, obj.AttrStrong, obj.AttrWeak}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_ldevice(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_ldevice_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_ldevice_attrs(scd_id,node_id,attr_desc,attr_inst,attr_ld_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrInst, obj.AttrLdName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_ln0(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_ln0_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_ln0_attrs(scd_id,node_id,attr_desc,attr_inst,attr_ln_class,attr_ln_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrInst, obj.AttrLnClass, obj.AttrLnType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_dataset(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_dataset_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_dataset_attrs(scd_id,node_id,attr_desc,attr_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_fcda(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_fcda_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_fcda_attrs(scd_id,node_id,attr_da_name,attr_do_name,attr_fc,attr_ix,attr_ld_inst,attr_ln_class,attr_ln_inst,attr_prefix)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDaName, obj.AttrDoName, obj.AttrFc, obj.AttrIx, obj.AttrLdInst, obj.AttrLnClass, obj.AttrLnInst, obj.AttrPrefix}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_fccb(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_fccb_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_fccb_attrs(scd_id,node_id,attr_cb_name,attr_da_name,attr_fc,attr_ld_inst,attr_ln_class,attr_ln_inst,attr_must_understand,attr_prefix)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrCbName, obj.AttrDaName, obj.AttrFc, obj.AttrLdInst, obj.AttrLnClass, obj.AttrLnInst, obj.AttrMustUnderstand, obj.AttrPrefix}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_reportcontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_reportcontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_reportcontrol_attrs(scd_id,node_id,attr_buffered,attr_buf_time,attr_conf_rev,attr_dat_set,attr_desc,attr_indexed,attr_intg_pd,attr_name,attr_rpt_id)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrBuffered, obj.AttrBufTime, obj.AttrConfRev, obj.AttrDatSet, obj.AttrDesc, obj.AttrIndexed, obj.AttrIntgPd, obj.AttrName, obj.AttrRptId}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}

func (c *AttrsMgr) Make_attr_trgops(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_trgops_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_trgops_attrs(scd_id,node_id,attr_dchg,attr_dupd,attr_gi,attr_include_all,attr_period,attr_qchg)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDchg, obj.AttrDupd, obj.AttrGi, obj.AttrIncludeAll, obj.AttrPeriod, obj.AttrQchg}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_optfields(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_optfields_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_optfields_attrs(scd_id,node_id,attr_buf_ovfl,attr_config_ref,attr_data_ref,attr_data_set,attr_entry_id,attr_reason_code,attr_seq_num,attr_time_stamp)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrBufOvfl, obj.AttrConfigRef, obj.AttrDataRef, obj.AttrDataSet, obj.AttrEntryID, obj.AttrReasonCode, obj.AttrSeqNum, obj.AttrTimeStamp}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_rptenabled(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_rptenabled_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_rptenabled_attrs(scd_id,node_id,attr_desc,attr_max)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrMax}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_clientln(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_clientln_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_clientln_attrs(scd_id,node_id,attr_desc,attr_ied_name,attr_ld_inst,attr_ln_class,attr_ln_inst,attr_prefix)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrIedName, obj.AttrLdInst, obj.AttrLnClass, obj.AttrLnInst, obj.AttrPrefix}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_logcontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_logcontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_logcontrol_attrs(scd_id,node_id,attr_dat_set,attr_desc,attr_intg_pd,attr_ld_inst,attr_ln_class,attr_ln_inst,attr_log_ena,attr_log_name,attr_name,attr_prefix,attr_reason_code)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDatSet, obj.AttrDesc, obj.AttrIntgPd, obj.AttrLdInst, obj.AttrLnClass, obj.AttrLnInst, obj.AttrLogEna, obj.AttrLogName, obj.AttrName, obj.AttrPrefix, obj.AttrReasonCode}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_doi(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_doi_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_doi_attrs(scd_id,node_id,attr_access_control,attr_desc,attr_ix,attr_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrAccessControl, obj.AttrDesc, obj.AttrIx, obj.AttrName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_sdi(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_sdi_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_sdi_attrs(scd_id,node_id,attr_desc,attr_ix,attr_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrIx, obj.AttrName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_dai(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_dai_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_dai_attrs(scd_id,node_id,attr_desc,attr_ix,attr_name,attr_saddr,attr_val_kind)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrIx, obj.AttrName, obj.AttrSaddr, obj.AttrValKind}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_val(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_val_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_val_attrs(scd_id,node_id,attr_sgroup)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrSgroup}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_inputs(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_inputs_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_inputs_attrs(scd_id,node_id,attr_desc)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_extref(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_extref_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_extref_attrs(scd_id,node_id,attr_da_name,attr_desc,attr_do_name,attr_ied_name,attr_int_addr,attr_ld_inst,attr_ln_class,attr_ln_inst,attr_prefix)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDaName, obj.AttrDesc, obj.AttrDoName, obj.AttrIedName, obj.AttrIntAddr, obj.AttrLdInst, obj.AttrLnClass, obj.AttrLnInst, obj.AttrPrefix}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_log(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_log_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_log_attrs(scd_id,node_id,attr_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_gsecontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_gsecontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_gsecontrol_attrs(scd_id,node_id,attr_appid,attr_conf_rev,attr_dat_set,attr_desc,attr_name,attr_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrAppid, obj.AttrConfRev, obj.AttrDatSet, obj.AttrDesc, obj.AttrName, obj.AttrType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_sampledvaluecontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_sampledvaluecontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_sampledvaluecontrol_attrs(scd_id,node_id,attr_smv_id,attr_conf_rev,attr_dat_set,attr_desc,attr_name,attr_multicast,attr_smp_rate,attr_nof_asdu)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrSmvId, obj.AttrConfRev, obj.AttrDatSet, obj.AttrDesc, obj.AttrName, obj.AttrMulticast, obj.AttrSmpRate, obj.AttrNofAsdu}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}

func (c *AttrsMgr) Make_attr_smvopts(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_smvopts_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_smvopts_attrs(scd_id,node_id,attr_data_ref,attr_refresh_time,attr_sample_rate,attr_sample_synchronized,attr_security)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDataRef, obj.AttrRefreshTime, obj.AttrSampleRate, obj.AttrSampleSynchronized, obj.AttrSecurity}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_settingcontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_settingcontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_settingcontrol_attrs(scd_id,node_id,attr_act_sg,attr_desc,attr_num_of_sgs)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrActSg, obj.AttrDesc, obj.AttrNumOfSgs}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_sclcontrol(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_sclcontrol_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_sclcontrol_attrs(scd_id,node_id,attr_desc)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_ln(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_ln_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_ln_attrs(scd_id,node_id,attr_desc,attr_inst,attr_ln_class,attr_ln_type,attr_prefix,join_str)"
	if err == nil {
		joinStr := obj.AttrPrefix + obj.AttrLnClass + obj.AttrInst
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrInst, obj.AttrLnClass, obj.AttrLnType, obj.AttrPrefix, joinStr}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_association(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_association_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_association_attrs(scd_id,node_id,attr_association_id,attr_desc,attr_ied_name,attr_kind,attr_ld_inst,attr_ln_class,attr_ln_inst,attr_prefix)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrAssociationId, obj.AttrDesc, obj.AttrIedName, obj.AttrKind, obj.AttrLdInst, obj.AttrLnClass, obj.AttrLnInst, obj.AttrPrefix}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_serverat(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_serverat_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_serverat_attrs(scd_id,node_id,attr_desc,attr_ap_name)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrApName}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_goosesecurity(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_goosesecurity_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_goosesecurity_attrs(scd_id,node_id,attr_desc,attr_name,attr_serial_number,attr_xfer_nmber)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName, obj.AttrSerialNumber, obj.AttrXferNumber}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_sunject(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_sunject_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_sunject_attrs(scd_id,node_id,attr_common_name,attr_id_hierarchy)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrCommonName, obj.AttrIdHierarchy}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_issuername(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_issuername_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_issuername_attrs(scd_id,node_id,attr_common_name,attr_id_hierarchy)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrCommonName, obj.AttrIdHierarchy}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_smvsecurity(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_smvsecurity_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_smvsecurity_attrs(scd_id,node_id,attr_desc,attr_name,attr_serial_number,attr_xfer_number)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName, obj.AttrSerialNumber, obj.AttrXferNumber}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_lnodetype(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_lnodetype_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_lnodetype_attrs(scd_id,node_id,attr_desc,attr_id,attr_ied_type,attr_ln_class)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrId, obj.AttrIedType, obj.AttrLnClass}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_do(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_do_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_do_attrs(scd_id,node_id,attr_desc,attr_name,attr_transient,attr_type,attr_access_control)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName, obj.AttrTransient, obj.AttrType, obj.AttrAccessControl}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}

func (c *AttrsMgr) Make_attr_dotype(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_dotype_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_dotype_attrs(scd_id,node_id,attr_desc,attr_id,attr_cdc,attr_ied_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrId, obj.AttrCdc, obj.AttrIedType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_sdo(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_sdo_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_sdo_attrs(scd_id,node_id,attr_desc,attr_name,attr_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName, obj.AttrType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_da(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_da_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_da_attrs(scd_id,node_id,attr_desc,attr_name,attr_count,attr_dchg,attr_dupd,attr_fc,attr_qchg,attr_saddr,attr_type,attr_val_kind,attr_btype)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName, obj.AttrCount, obj.AttrDchg, obj.AttrDupd, obj.AttrFc, obj.AttrQchg, obj.AttrSaddr, obj.AttrType, obj.AttrValKind, obj.AttrBtype}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_datype(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_datype_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_datype_attrs(scd_id,node_id,attr_desc,attr_id,attr_ied_type)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrId, obj.AttrIedType}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_bda(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_bda_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_bda_attrs(scd_id,node_id,attr_desc,attr_name,attr_count,attr_saddr,attr_type,attr_val_kind,attr_btype)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrName, obj.AttrCount, obj.AttrSaddr, obj.AttrType, obj.AttrValKind, obj.AttrBtype}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_enumtype(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_enumtype_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_enumtype_attrs(scd_id,node_id,attr_desc,attr_id)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrId}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_enumval(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_enumval_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_enumval_attrs(scd_id,node_id,attr_desc,attr_ord)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrOrd}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}

//smv节点需要单独处理。整个文件中有2个smv节点，其中一个为connectedap下的；另一个在IED的Services节点下
func (c *AttrsMgr) Make_attr_connectedap_smv(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_connectedap_smv_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_connectedap_smv_attrs(scd_id,node_id,attr_desc,attr_cb_name,attr_ld_inst)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrDesc, obj.AttrCbName, obj.AttrLdInst}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}
func (c *AttrsMgr) Make_attr_smv(nodeid int64, attrs map[string]interface{}) (string, string, error) {
	obj := T_scd_smv_attrs{}
	obj.NodeId = nodeid
	err := c.attr_trans(attrs, &obj)
	sqlTableCols := "t_scd_smv_attrs(scd_id,node_id,attr_max)"
	if err == nil {
		sqlValue := []string{fmt.Sprintf("%d", c.ScdId), fmt.Sprintf("%d", nodeid), obj.AttrMax}
		return sqlTableCols, "('" + strings.Join(sqlValue, "','") + "')", nil
	}
	return "", "", err
}