init

datamodels/model.go

@@ -0,0 +1,21 @@
+package datamodels
+
+import "time"
+
+type Model struct {
+	ModelId     int64     `json:"modelId"         xorm:"'model_id'        bigint     pk comment('主键ID')         "`
+	ModelTitle  string    `json:"modelTitle"      xorm:"'model_title'     varchar(50)   comment('模型名称')     "`
+	ModelDesc   string    `json:"modelDesc"       xorm:"'model_desc'      varchar(50)   comment('描述')            "`
+	IsFixed     int64     `json:"isFixed"         xorm:"'is_fixed'        int           comment('是否可修改')         "`
+	CreatedBy   int64     `json:"createdBy"       xorm:"'created_by'"`
+	CreatedAt   time.Time `json:"createdAt"       xorm:"'created_at'"`
+	UpdatedBy   int64     `json:"updatedBy"       xorm:"'updated_by'"`
+	UpdatedAt   time.Time `json:"updatedAt"       xorm:"'updated_at'"`
+	DeletedFlag int64     `json:"deletedFlag"     xorm:"'deleted_flag'"`
+	DeletedBy   int64     `json:"deletedBy"       xorm:"'deleted_by'"`
+	DeletedAt   time.Time `json:"deletedAt"       xorm:"'deleted_at'"`
+}
+
+func (t *Model) TableName() string {
+	return "ds_model"
+}

datamodels/object.go

@@ -0,0 +1,24 @@
+package datamodels
+
+import "time"
+
+type Object struct {
+	ModelId     int64     `json:"modelId"         xorm:"'model_id'        bigint      pk comment('主键ID')         "`
+	ObjectId    int64     `json:"objectId"        xorm:"'object_id'       bigint      pk comment('主键ID')         "`
+	ObjectType  int64     `json:"objectType"      xorm:"'object_type'     bigint         comment('Type')           "`
+	ObjectTitle string    `json:"objectTitle"     xorm:"'object_title'    varchar(127)   comment('模型名称')        "`
+	ObjectCode  string    `json:"objectCode"      xorm:"'object_code'     varchar(127)   comment('模型名称')        "`
+	Comment     string    `json:"comment"         xorm:"'comment'         varchar(255)   comment('描述')            "`
+	IsFixed     int64     `json:"isFixed"         xorm:"'is_fixed'        int            comment('是否可修改')       "`
+	CreatedBy   int64     `json:"createdBy"       xorm:"'created_by'"`
+	CreatedAt   time.Time `json:"createdAt"       xorm:"'created_at'"`
+	UpdatedBy   int64     `json:"updatedBy"       xorm:"'updated_by'"`
+	UpdatedAt   time.Time `json:"updatedAt"       xorm:"'updated_at'"`
+	DeletedFlag int64     `json:"deletedFlag"     xorm:"'deleted_flag'"`
+	DeletedBy   int64     `json:"deletedBy"       xorm:"'deleted_by'"`
+	DeletedAt   time.Time `json:"deletedAt"       xorm:"'deleted_at'"`
+}
+
+func (t *Object) TableName() string {
+	return "ds_object"
+}

datamodels/object_attr.go

@@ -0,0 +1,30 @@
+package datamodels
+
+import "time"
+
+type ObjectAttr struct {
+	ModelId      int64     `json:"modelId"         xorm:"'model_id'         bigint      pk comment('主键ID')         "`
+	ObjectId     int64     `json:"objectId"        xorm:"'object_id'        bigint      pk comment('主键ID')         "`
+	AttrId       int64     `json:"attrId"          xorm:"'attr_id'          bigint      pk comment('主键ID')         "`
+	AttrTitle    string    `json:"attrTitle"       xorm:"'attr_title'      varchar(127)   comment('AttrTitle')       "`
+	AttrCode     string    `json:"attrCode"        xorm:"'attr_code'       varchar(127)   comment('AttrCode')        "`
+	AttrType     int64     `json:"attrType"        xorm:"'attr_type'       bigint         comment('Type')            "`
+	AttrLength   int64     `json:"attrLength"      xorm:"'attr_length'      bigint        comment('attrLength')      "`
+	AttrDecimals int64     `json:"attrDecimals"    xorm:"'attr_decimals'    bigint        comment('attrDecimals')    "`
+	Comment      string    `json:"comment"         xorm:"'comment'         varchar(255)   comment('描述')            "`
+	IsFixed      int64     `json:"isFixed"         xorm:"'is_fixed'        int            comment('是否可修改')       "`
+	IsNotNull    int64     `json:"isNotNull"       xorm:"'is_not_null'     int            comment('是否可修改')       "`
+	IsPKey       int64     `json:"isPKey"          xorm:"'is_pkey'         int            comment('是否可修改')       "`
+	SortNo       int64     `json:"sortNo"          xorm:"'sort_no'         int            comment('是否可修改')       "`
+	CreatedBy    int64     `json:"createdBy"       xorm:"'created_by'"`
+	CreatedAt    time.Time `json:"createdAt"       xorm:"'created_at'"`
+	UpdatedBy    int64     `json:"updatedBy"       xorm:"'updated_by'"`
+	UpdatedAt    time.Time `json:"updatedAt"       xorm:"'updated_at'"`
+	DeletedFlag  int64     `json:"deletedFlag"     xorm:"'deleted_flag'"`
+	DeletedBy    int64     `json:"deletedBy"       xorm:"'deleted_by'"`
+	DeletedAt    time.Time `json:"deletedAt"       xorm:"'deleted_at'"`
+}
+
+func (t *ObjectAttr) TableName() string {
+	return "ds_object_attr"
+}

repositories/apps/app_cat_repo.go

@@ -1,110 +0,0 @@
-package apps
-
-import (
-    "fmt"
-    "time"
-    "xorm.io/xorm"
-    "xps/datamodels"
-    "xps/viewmodels"
-)
-
-type AppCatRepo struct {
-    engine *xorm.Engine
-}
-
-func NewAppCatRepo(engine *xorm.Engine) *AppCatRepo {
-    return &AppCatRepo{
-        engine: engine,
-    }
-}
-
-func (d *AppCatRepo) GetByPage(m map[string]interface{})(*viewmodels.PageResult, error) {
-    keywords := m["keywords"].(string)
-    limit    := m["limit"].(int)
-    page     := m["page"].(int)
-    
-    sqlSelect := `SELECT A.*`
-    sqlFrom   := `FROM   app_cat   AS A `
-    sqlWhere  := `WHERE A.deleted_flag = 0 `
-    if keywords != "" {
-        sqlWhere += ` AND A.app_cat_title like ` + "'%" + keywords + "%'"
-    }
-    
-    sqlCount := `SELECT COUNT(*) `
-    total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.AppCat))
-    if err1 != nil {
-        return nil, err1
-    }
-    
-    sqlOrderBy := " ORDER BY app_cat_id DESC "
-    pageStart := (page - 1) * limit
-    sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
-    
-    datalist := make([]datamodels.AppCat, 0)
-    err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
-    if err2 != nil {
-        return nil, err2
-    }
-    
-    pageResult := &viewmodels.PageResult{}
-    pageResult.Data     = datalist
-    pageResult.Total    = total
-    pageResult.PageSize = limit
-    pageResult.Page     = page
-    return pageResult, nil
-}
-
-func (d *AppCatRepo) GetByList(m map[string]interface{})([]viewmodels.AppCatInfo, error) {
-    keywords := m["keywords"].(string)
-    
-    sqlSelect := `SELECT A.* `
-    sqlFrom   := `FROM  app_cat   AS A    `
-    sqlWhere  := `WHERE A.deleted_flag = 0 `
-    if keywords != "" {
-        sqlWhere += ` AND   A.app_cat_title like ` + "'%" + keywords + "%'"
-    }
-    
-    sqlOrderBy := " ORDER BY app_cat_id DESC "
-    datalist   := make([]viewmodels.AppCatInfo, 0)
-    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
-    if err != nil {
-        return nil, err
-    }
-    return datalist, nil
-}
-
-func (d *AppCatRepo) GetById(ocId int64, appCatId int64)(*viewmodels.AppCatInfo, error){
-    data := &viewmodels.AppCatInfo{}
-    ok, err := d.engine.Where("app_cat_id = ?", appCatId).Get(data)
-    if !ok && err == nil {
-        return nil, err
-    } else {
-        return data, nil
-    }
-}
-
-func (d *AppCatRepo) Create(data *datamodels.AppCat) error {
-    data.CreatedAt = time.Now()
-    _, err := d.engine.Insert(data)
-    return err
-}
-
-func (d *AppCatRepo) Update(data *datamodels.AppCat) error {
-    appCatId := data.AppCatId
-    
-    data.UpdatedAt = time.Now()
-    _, err := d.engine.Where("app_cat_id = ?", appCatId).Update(data)
-    return err
-}
-
-func (d *AppCatRepo) Delete(m map[string]interface{}) error {
-    appCatId   := m["appCatId"].(int64)
-    deletedBy  := m["deletedBy"].(int64)
-    
-    data := &datamodels.AppCat{}
-    data.DeletedFlag = 1
-    data.DeletedBy   = deletedBy
-    data.DeletedAt   = time.Now()
-    _, err := d.engine.Where("app_cat_id = ?", appCatId).Update(data)
-    return err
-}

repositories/model/model_repo.go

@@ -0,0 +1,110 @@
+package model
+
+import (
+	"fmt"
+	"time"
+	"xorm.io/xorm"
+	"xps/datamodels"
+	"xps/viewmodels"
+)
+
+type ModelRepo struct {
+	engine *xorm.Engine
+}
+
+func NewModelRepo(engine *xorm.Engine) *ModelRepo {
+	return &ModelRepo{
+		engine: engine,
+	}
+}
+
+func (d *ModelRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	keywords := m["keywords"].(string)
+	limit := m["limit"].(int)
+	page := m["page"].(int)
+
+	sqlSelect := `SELECT A.*`
+	sqlFrom := `FROM   ds_model   AS A `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND A.model_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlCount := `SELECT COUNT(*) `
+	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.Model))
+	if err1 != nil {
+		return nil, err1
+	}
+
+	sqlOrderBy := " ORDER BY model_id DESC "
+	pageStart := (page - 1) * limit
+	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+
+	datalist := make([]datamodels.Model, 0)
+	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
+	if err2 != nil {
+		return nil, err2
+	}
+
+	pageResult := &viewmodels.PageResult{}
+	pageResult.Data = datalist
+	pageResult.Total = total
+	pageResult.PageSize = limit
+	pageResult.Page = page
+	return pageResult, nil
+}
+
+func (d *ModelRepo) GetByList(m map[string]interface{}) ([]viewmodels.ModelInfo, error) {
+	keywords := m["keywords"].(string)
+
+	sqlSelect := `SELECT A.* `
+	sqlFrom := `FROM  ds_model   AS A    `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND   A.model_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlOrderBy := " ORDER BY model_id DESC "
+	datalist := make([]viewmodels.ModelInfo, 0)
+	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+	if err != nil {
+		return nil, err
+	}
+	return datalist, nil
+}
+
+func (d *ModelRepo) GetById(modelId int64) (*viewmodels.ModelInfo, error) {
+	data := &viewmodels.ModelInfo{}
+	ok, err := d.engine.Where("model_id = ?", modelId).Get(data)
+	if !ok && err == nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
+}
+
+func (d *ModelRepo) Create(data *datamodels.Model) error {
+	data.CreatedAt = time.Now()
+	_, err := d.engine.Insert(data)
+	return err
+}
+
+func (d *ModelRepo) Update(data *datamodels.Model) error {
+	modelId := data.ModelId
+
+	data.UpdatedAt = time.Now()
+	_, err := d.engine.Where("model_id = ?", modelId).Update(data)
+	return err
+}
+
+func (d *ModelRepo) Delete(m map[string]interface{}) error {
+	modelId := m["modelId"].(int64)
+	deletedBy := m["deletedBy"].(int64)
+
+	data := &datamodels.Model{}
+	data.DeletedFlag = 1
+	data.DeletedBy = deletedBy
+	data.DeletedAt = time.Now()
+	_, err := d.engine.Where("model_id = ?", modelId).Update(data)
+	return err
+}

repositories/model/object_attr_repo.go

@@ -0,0 +1,126 @@
+package model
+
+import (
+	"fmt"
+	"time"
+	"xorm.io/xorm"
+	"xps/datamodels"
+	"xps/viewmodels"
+)
+
+type ObjectAttrRepo struct {
+	engine *xorm.Engine
+}
+
+func NewObjectAttrRepo(engine *xorm.Engine) *ObjectAttrRepo {
+	return &ObjectAttrRepo{
+		engine: engine,
+	}
+}
+
+func (d *ObjectAttrRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	keywords := m["keywords"].(string)
+	limit := m["limit"].(int)
+	page := m["page"].(int)
+
+	sqlSelect := `SELECT A.*`
+	sqlFrom := `FROM   ds_object_attr   AS A `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND A.attr_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlCount := `SELECT COUNT(*) `
+	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.ObjectAttr))
+	if err1 != nil {
+		return nil, err1
+	}
+
+	sqlOrderBy := " ORDER BY object_id DESC "
+	pageStart := (page - 1) * limit
+	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+
+	datalist := make([]datamodels.ObjectAttr, 0)
+	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
+	if err2 != nil {
+		return nil, err2
+	}
+
+	pageResult := &viewmodels.PageResult{}
+	pageResult.Data = datalist
+	pageResult.Total = total
+	pageResult.PageSize = limit
+	pageResult.Page = page
+	return pageResult, nil
+}
+
+func (d *ObjectAttrRepo) GetByList(m map[string]interface{}) ([]viewmodels.ObjectAttrInfo, error) {
+	keywords := m["keywords"].(string)
+
+	sqlSelect := `SELECT A.* `
+	sqlFrom := `FROM  ds_object_attr   AS A    `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND   A.attr_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlOrderBy := " ORDER BY model_id DESC "
+	datalist := make([]viewmodels.ObjectAttrInfo, 0)
+	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+	if err != nil {
+		return nil, err
+	}
+	return datalist, nil
+}
+
+func (d *ObjectAttrRepo) GetById(modelId, objectId, attrId int64) (*viewmodels.ObjectAttrInfo, error) {
+	data := &viewmodels.ObjectAttrInfo{}
+	ok, err := d.engine.
+		Where("model_id = ?", modelId).
+		Where("object_id = ?", objectId).
+		Where("attr_id = ?", attrId).
+		Get(data)
+	if !ok && err == nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
+}
+
+func (d *ObjectAttrRepo) Create(data *datamodels.ObjectAttr) error {
+	data.CreatedAt = time.Now()
+	_, err := d.engine.Insert(data)
+	return err
+}
+
+func (d *ObjectAttrRepo) Update(data *datamodels.ObjectAttr) error {
+	modelId := data.ModelId
+	objectId := data.ObjectId
+	attrId := data.AttrId
+
+	data.UpdatedAt = time.Now()
+	_, err := d.engine.
+		Where("model_id = ?", modelId).
+		Where("object_id = ?", objectId).
+		Where("attr_id = ?", attrId).
+		Update(data)
+	return err
+}
+
+func (d *ObjectAttrRepo) Delete(m map[string]interface{}) error {
+	modelId := m["modelId"].(int64)
+	objectId := m["objectId"].(int64)
+	attrId := m["attrId"].(int64)
+	deletedBy := m["deletedBy"].(int64)
+
+	data := &datamodels.ObjectAttr{}
+	data.DeletedFlag = 1
+	data.DeletedBy = deletedBy
+	data.DeletedAt = time.Now()
+	_, err := d.engine.
+		Where("model_id = ?", modelId).
+		Where("object_id = ?", objectId).
+		Where("attr_id = ?", attrId).
+		Update(data)
+	return err
+}

repositories/model/object_repo.go

@@ -0,0 +1,122 @@
+package model
+
+import (
+	"fmt"
+	"time"
+	"xorm.io/xorm"
+	"xps/datamodels"
+	"xps/viewmodels"
+)
+
+type ObjectRepo struct {
+	engine *xorm.Engine
+}
+
+func NewObjectRepo(engine *xorm.Engine) *ObjectRepo {
+	return &ObjectRepo{
+		engine: engine,
+	}
+}
+
+func (d *ObjectRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	keywords := m["keywords"].(string)
+	limit := m["limit"].(int)
+	page := m["page"].(int)
+
+	sqlSelect := `SELECT A.*`
+	sqlFrom := `FROM   ds_object   AS A `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND A.object_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlCount := `SELECT COUNT(*) `
+	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.Object))
+	if err1 != nil {
+		return nil, err1
+	}
+
+	sqlOrderBy := " ORDER BY object_id DESC "
+	pageStart := (page - 1) * limit
+	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+
+	datalist := make([]datamodels.Object, 0)
+	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
+	if err2 != nil {
+		return nil, err2
+	}
+
+	pageResult := &viewmodels.PageResult{}
+	pageResult.Data = datalist
+	pageResult.Total = total
+	pageResult.PageSize = limit
+	pageResult.Page = page
+	return pageResult, nil
+}
+
+func (d *ObjectRepo) GetByList(m map[string]interface{}) ([]viewmodels.ObjectInfo, error) {
+	modelId := m["modelId"].(int64)
+	keywords := m["keywords"].(string)
+
+	sqlSelect := `SELECT A.* `
+	sqlFrom := `FROM  ds_object   AS A    `
+	sqlWhere := `WHERE A.deleted_flag = 0 AND A.model_id =` + fmt.Sprintf("%d", modelId)
+	if keywords != "" {
+		sqlWhere += ` AND A.object_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlOrderBy := " ORDER BY model_id ASC "
+	datalist := make([]viewmodels.ObjectInfo, 0)
+	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+	if err != nil {
+		return nil, err
+	}
+	return datalist, nil
+}
+
+func (d *ObjectRepo) GetById(modelId, objectId int64) (*viewmodels.ObjectInfo, error) {
+	data := &viewmodels.ObjectInfo{}
+	ok, err := d.engine.
+		Where("model_id = ?", modelId).
+		Where("object_id = ?", objectId).
+		Get(data)
+	if !ok && err == nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
+}
+
+func (d *ObjectRepo) Create(data *datamodels.Object) error {
+	data.CreatedAt = time.Now()
+	_, err := d.engine.Insert(data)
+	return err
+}
+
+func (d *ObjectRepo) Update(data *datamodels.Object) error {
+	modelId := data.ObjectId
+	objectId := data.ObjectId
+
+	data.UpdatedAt = time.Now()
+	_, err := d.engine.
+		Where("model_id = ?", modelId).
+		Where("object_id = ?", objectId).
+		Update(data)
+	return err
+}
+
+func (d *ObjectRepo) Delete(m map[string]interface{}) error {
+	modelId := m["modelId"].(int64)
+	objectId := m["objectId"].(int64)
+	deletedBy := m["deletedBy"].(int64)
+
+	data := &datamodels.Object{}
+	data.DeletedFlag = 1
+	data.DeletedBy = deletedBy
+	data.DeletedAt = time.Now()
+	_, err := d.engine.
+		Where("model_id = ?", modelId).
+		Where("object_id = ?", objectId).
+		Update(data)
+	return err
+}

repositories/system/app_cat_repo.go

@@ -0,0 +1,110 @@
+package system
+
+import (
+	"fmt"
+	"time"
+	"xorm.io/xorm"
+	"xps/datamodels"
+	"xps/viewmodels"
+)
+
+type AppCatRepo struct {
+	engine *xorm.Engine
+}
+
+func NewAppCatRepo(engine *xorm.Engine) *AppCatRepo {
+	return &AppCatRepo{
+		engine: engine,
+	}
+}
+
+func (d *AppCatRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	keywords := m["keywords"].(string)
+	limit := m["limit"].(int)
+	page := m["page"].(int)
+
+	sqlSelect := `SELECT A.*`
+	sqlFrom := `FROM   app_cat   AS A `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND A.app_cat_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlCount := `SELECT COUNT(*) `
+	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.AppCat))
+	if err1 != nil {
+		return nil, err1
+	}
+
+	sqlOrderBy := " ORDER BY app_cat_id DESC "
+	pageStart := (page - 1) * limit
+	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+
+	datalist := make([]datamodels.AppCat, 0)
+	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
+	if err2 != nil {
+		return nil, err2
+	}
+
+	pageResult := &viewmodels.PageResult{}
+	pageResult.Data = datalist
+	pageResult.Total = total
+	pageResult.PageSize = limit
+	pageResult.Page = page
+	return pageResult, nil
+}
+
+func (d *AppCatRepo) GetByList(m map[string]interface{}) ([]viewmodels.AppCatInfo, error) {
+	keywords := m["keywords"].(string)
+
+	sqlSelect := `SELECT A.* `
+	sqlFrom := `FROM  app_cat   AS A    `
+	sqlWhere := `WHERE A.deleted_flag = 0 `
+	if keywords != "" {
+		sqlWhere += ` AND   A.app_cat_title like ` + "'%" + keywords + "%'"
+	}
+
+	sqlOrderBy := " ORDER BY app_cat_id DESC "
+	datalist := make([]viewmodels.AppCatInfo, 0)
+	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+	if err != nil {
+		return nil, err
+	}
+	return datalist, nil
+}
+
+func (d *AppCatRepo) GetById(ocId int64, appCatId int64) (*viewmodels.AppCatInfo, error) {
+	data := &viewmodels.AppCatInfo{}
+	ok, err := d.engine.Where("app_cat_id = ?", appCatId).Get(data)
+	if !ok && err == nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
+}
+
+func (d *AppCatRepo) Create(data *datamodels.AppCat) error {
+	data.CreatedAt = time.Now()
+	_, err := d.engine.Insert(data)
+	return err
+}
+
+func (d *AppCatRepo) Update(data *datamodels.AppCat) error {
+	appCatId := data.AppCatId
+
+	data.UpdatedAt = time.Now()
+	_, err := d.engine.Where("app_cat_id = ?", appCatId).Update(data)
+	return err
+}
+
+func (d *AppCatRepo) Delete(m map[string]interface{}) error {
+	appCatId := m["appCatId"].(int64)
+	deletedBy := m["deletedBy"].(int64)
+
+	data := &datamodels.AppCat{}
+	data.DeletedFlag = 1
+	data.DeletedBy = deletedBy
+	data.DeletedAt = time.Now()
+	_, err := d.engine.Where("app_cat_id = ?", appCatId).Update(data)
+	return err
+}

service/model/base_service.go

@@ -0,0 +1,29 @@
+package model
+
+import (
+	"log"
+	"xps/cache"
+	"xps/datasource"
+	"xps/viewmodels"
+)
+
+func NewID() int64 {
+	engine := datasource.InstanceIDServer()
+	ret, err := engine.Exec("replace into uid_sequence(stub) values('a')")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	uid, err := ret.LastInsertId()
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	return uid
+}
+
+func GetCurUser(userId int64) *viewmodels.UserData {
+	userData, err := cache.GetUserData(userId)
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	return userData
+}

service/model/model_service.go

@@ -0,0 +1,52 @@
+package model
+
+import (
+	"xps/datamodels"
+	"xps/datasource"
+	"xps/repositories/model"
+	"xps/viewmodels"
+)
+
+type ModelService interface {
+	GetByList(m map[string]interface{}) ([]viewmodels.ModelInfo, error)
+	GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+	GetById(modelId int64) (*viewmodels.ModelInfo, error)
+	Create(d *datamodels.Model) error
+	Update(d *datamodels.Model) error
+	Delete(m map[string]interface{}) error
+}
+
+type modelService struct {
+	repo *model.ModelRepo
+}
+
+func NewModelService() ModelService {
+	return &modelService{
+		repo: model.NewModelRepo(datasource.InstanceMaster()),
+	}
+}
+
+func (s *modelService) GetByList(m map[string]interface{}) ([]viewmodels.ModelInfo, error) {
+	return s.repo.GetByList(m)
+}
+
+func (s *modelService) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	return s.repo.GetByPage(m)
+}
+
+func (s *modelService) GetById(modelId int64) (*viewmodels.ModelInfo, error) {
+	return s.repo.GetById(modelId)
+}
+
+func (s *modelService) Create(Model *datamodels.Model) error {
+	Model.ModelId = NewID()
+	return s.repo.Create(Model)
+}
+
+func (s *modelService) Update(Model *datamodels.Model) error {
+	return s.repo.Update(Model)
+}
+
+func (s *modelService) Delete(m map[string]interface{}) error {
+	return s.repo.Delete(m)
+}

service/model/object_attr_service.go

@@ -0,0 +1,52 @@
+package model
+
+import (
+	"xps/datamodels"
+	"xps/datasource"
+	"xps/repositories/model"
+	"xps/viewmodels"
+)
+
+type ObjectAttrService interface {
+	GetByList(m map[string]interface{}) ([]viewmodels.ObjectAttrInfo, error)
+	GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+	GetById(modelId, objectId, attrId int64) (*viewmodels.ObjectAttrInfo, error)
+	Create(d *datamodels.ObjectAttr) error
+	Update(d *datamodels.ObjectAttr) error
+	Delete(m map[string]interface{}) error
+}
+
+type objectAttrService struct {
+	repo *model.ObjectAttrRepo
+}
+
+func NewObjectAttrService() ObjectAttrService {
+	return &objectAttrService{
+		repo: model.NewObjectAttrRepo(datasource.InstanceMaster()),
+	}
+}
+
+func (s *objectAttrService) GetByList(m map[string]interface{}) ([]viewmodels.ObjectAttrInfo, error) {
+	return s.repo.GetByList(m)
+}
+
+func (s *objectAttrService) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	return s.repo.GetByPage(m)
+}
+
+func (s *objectAttrService) GetById(modelId, objectId, attrId int64) (*viewmodels.ObjectAttrInfo, error) {
+	return s.repo.GetById(modelId, objectId, attrId)
+}
+
+func (s *objectAttrService) Create(ObjectAttr *datamodels.ObjectAttr) error {
+	ObjectAttr.AttrId = NewID()
+	return s.repo.Create(ObjectAttr)
+}
+
+func (s *objectAttrService) Update(ObjectAttr *datamodels.ObjectAttr) error {
+	return s.repo.Update(ObjectAttr)
+}
+
+func (s *objectAttrService) Delete(m map[string]interface{}) error {
+	return s.repo.Delete(m)
+}

service/model/object_service.go

@@ -0,0 +1,52 @@
+package model
+
+import (
+	"xps/datamodels"
+	"xps/datasource"
+	"xps/repositories/model"
+	"xps/viewmodels"
+)
+
+type ObjectService interface {
+	GetByList(m map[string]interface{}) ([]viewmodels.ObjectInfo, error)
+	GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+	GetById(modelId, objectId int64) (*viewmodels.ObjectInfo, error)
+	Create(d *datamodels.Object) error
+	Update(d *datamodels.Object) error
+	Delete(m map[string]interface{}) error
+}
+
+type objectService struct {
+	repo *model.ObjectRepo
+}
+
+func NewObjectService() ObjectService {
+	return &objectService{
+		repo: model.NewObjectRepo(datasource.InstanceMaster()),
+	}
+}
+
+func (s *objectService) GetByList(m map[string]interface{}) ([]viewmodels.ObjectInfo, error) {
+	return s.repo.GetByList(m)
+}
+
+func (s *objectService) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+	return s.repo.GetByPage(m)
+}
+
+func (s *objectService) GetById(modelId, objectId int64) (*viewmodels.ObjectInfo, error) {
+	return s.repo.GetById(modelId, objectId)
+}
+
+func (s *objectService) Create(Object *datamodels.Object) error {
+	Object.ObjectId = NewID()
+	return s.repo.Create(Object)
+}
+
+func (s *objectService) Update(Object *datamodels.Object) error {
+	return s.repo.Update(Object)
+}
+
+func (s *objectService) Delete(m map[string]interface{}) error {
+	return s.repo.Delete(m)
+}

service/system/app_cat_service.go

@@ -1,52 +1,52 @@
 package system
 
 import (
-    "xps/datamodels"
-    "xps/datasource"
-    "xps/repositories/apps"
-    "xps/viewmodels"
+	"xps/datamodels"
+	"xps/datasource"
+	"xps/repositories/system"
+	"xps/viewmodels"
 )
 
 type AppCatService interface {
-    GetByList(m map[string]interface{}) ([]viewmodels.AppCatInfo, error)
-    GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error)
-    GetById(ocId int64, appCatId int64) (*viewmodels.AppCatInfo, error)
-    Create(d *datamodels.AppCat) error
-    Update(d *datamodels.AppCat) error
-    Delete(m map[string]interface{}) error
+	GetByList(m map[string]interface{}) ([]viewmodels.AppCatInfo, error)
+	GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+	GetById(ocId int64, appCatId int64) (*viewmodels.AppCatInfo, error)
+	Create(d *datamodels.AppCat) error
+	Update(d *datamodels.AppCat) error
+	Delete(m map[string]interface{}) error
 }
 
 type appCatService struct {
-    repo *apps.AppCatRepo
+	repo *system.AppCatRepo
 }
 
 func NewAppCatService() AppCatService {
-    return &appCatService{
-        repo: apps.NewAppCatRepo(datasource.InstanceMaster()),
-    }
+	return &appCatService{
+		repo: system.NewAppCatRepo(datasource.InstanceMaster()),
+	}
 }
 
 func (s *appCatService) GetByList(m map[string]interface{}) ([]viewmodels.AppCatInfo, error) {
-    return s.repo.GetByList(m)
+	return s.repo.GetByList(m)
 }
 
 func (s *appCatService) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
-    return s.repo.GetByPage(m)
+	return s.repo.GetByPage(m)
 }
 
 func (s *appCatService) GetById(ocId int64, appCatId int64) (*viewmodels.AppCatInfo, error) {
-    return s.repo.GetById(ocId, appCatId)
+	return s.repo.GetById(ocId, appCatId)
 }
 
 func (s *appCatService) Create(AppCat *datamodels.AppCat) error {
-    AppCat.AppCatId = NewID()
-    return s.repo.Create(AppCat)
+	AppCat.AppCatId = NewID()
+	return s.repo.Create(AppCat)
 }
 
 func (s *appCatService) Update(AppCat *datamodels.AppCat) error {
-    return s.repo.Update(AppCat)
+	return s.repo.Update(AppCat)
 }
 
 func (s *appCatService) Delete(m map[string]interface{}) error {
-    return s.repo.Delete(m)
+	return s.repo.Delete(m)
 }

viewmodels/model_info.go

@@ -0,0 +1,12 @@
+package viewmodels
+
+type ModelInfo struct {
+	ModelId    int64  `json:"modelId"         xorm:"'model_id'        bigint     pk comment('主键ID')         "`
+	ModelTitle string `json:"modelTitle"      xorm:"'model_title'     varchar(50)   comment('模型名称')     "`
+	ModelDesc  string `json:"modelDesc"       xorm:"'model_desc'      varchar(50)   comment('描述')            "`
+	IsFixed    int64  `json:"isFixed"         xorm:"'is_fixed'        int           comment('是否可修改')         "`
+}
+
+func (t *ModelInfo) TableName() string {
+	return "ds_model"
+}

viewmodels/object_attr_info.go

@@ -0,0 +1,21 @@
+package viewmodels
+
+type ObjectAttrInfo struct {
+	ModelId      int64  `json:"modelId"         xorm:"'model_id'         bigint      pk comment('主键ID')         "`
+	ObjectId     int64  `json:"objectId"        xorm:"'object_id'        bigint      pk comment('主键ID')         "`
+	AttrId       int64  `json:"attrId"          xorm:"'attr_id'          bigint      pk comment('主键ID')         "`
+	AttrTitle    string `json:"attrTitle"       xorm:"'attr_title'      varchar(127)   comment('AttrTitle')       "`
+	AttrCode     string `json:"attrCode"        xorm:"'attr_code'       varchar(127)   comment('AttrCode')        "`
+	AttrType     int64  `json:"attrType"        xorm:"'attr_type'       bigint         comment('Type')            "`
+	AttrLength   int64  `json:"attrLength"      xorm:"'attr_length'      bigint        comment('attrLength')      "`
+	AttrDecimals int64  `json:"attrDecimals"    xorm:"'attr_decimals'    bigint        comment('attrDecimals')    "`
+	Comment      string `json:"comment"         xorm:"'comment'         varchar(255)   comment('描述')            "`
+	IsFixed      int64  `json:"isFixed"         xorm:"'is_fixed'        int            comment('是否可修改')       "`
+	IsNotNull    int64  `json:"isNotNull"       xorm:"'is_not_null'     int            comment('是否可修改')       "`
+	IsPKey       int64  `json:"isPKey"          xorm:"'is_pkey'         int            comment('是否可修改')       "`
+	SortNo       int64  `json:"sortNo"          xorm:"'sort_no'         int            comment('是否可修改')       "`
+}
+
+func (t *ObjectAttrInfo) TableName() string {
+	return "ds_object_attr"
+}

viewmodels/object_info.go

@@ -0,0 +1,15 @@
+package viewmodels
+
+type ObjectInfo struct {
+	ModelId     int64  `json:"modelId"         xorm:"'model_id'        bigint      pk comment('主键ID')         "`
+	ObjectId    int64  `json:"objectId"        xorm:"'object_id'       bigint      pk comment('主键ID')         "`
+	ObjectType  int64  `json:"objectType"      xorm:"'object_type'     bigint         comment('Type')           "`
+	ObjectTitle string `json:"objectTitle"     xorm:"'object_title'    varchar(127)   comment('模型名称')        "`
+	ObjectCode  string `json:"objectCode"      xorm:"'object_code'     varchar(127)   comment('模型名称')        "`
+	Comment     string `json:"comment"         xorm:"'comment'         varchar(255)   comment('描述')            "`
+	IsFixed     int64  `json:"isFixed"         xorm:"'is_fixed'        int            comment('是否可修改')       "`
+}
+
+func (t *ObjectInfo) TableName() string {
+	return "ds_object"
+}

web/controllers/base_controller.go

@@ -45,29 +45,37 @@ func (b *Base) GetOcTypeId() int64 {
 }
 
 func (b *Base) buildParams() map[string]interface{} {
-	var conditions QueryConditions
-	err := b.Ctx.ReadURL(&conditions)
-	if err != nil {
-		_ =b.Ctx.JSON(ResultErr(err.Error(), nil))
-	}
 	ocId, err := b.Ctx.Values().GetInt64("ocId")
 	if err != nil {
-		_ =b.Ctx.JSON(ResultErr(err.Error(), nil))
+		_ = b.Ctx.JSON(ResultErr(err.Error(), nil))
 		b.Ctx.Next()
 	}
 	userId, err := b.Ctx.Values().GetInt64("userId")
 	if err != nil {
-		_ =b.Ctx.JSON(ResultErr(err.Error(), nil))
+		_ = b.Ctx.JSON(ResultErr(err.Error(), nil))
 		b.Ctx.Next()
 	}
-
 	params := make(map[string]interface{})
-	params["ocId"]     = ocId
-	params["groupId"]  = conditions.GroupId
-	params["userId"]   = userId
-	params["limit"]    = conditions.Limit
-	params["page"]     = conditions.Page
-	params["keywords"] = conditions.Keywords
+	params["ocId"] = ocId
+	params["userId"] = userId
+	groupId := b.Ctx.URLParamInt64Default("groupId", 0)
+	if groupId > 0 {
+		params["groupId"] = groupId
+	}
+
+	limit := b.Ctx.URLParamIntDefault("limit", 0)
+	if limit <= 0 {
+		limit = 10
+	}
+	params["limit"] = limit
+
+	page := b.Ctx.URLParamIntDefault("page", 0)
+	if page <= 0 {
+		page = 1
+	}
+	params["page"] = page
+	keywords := b.Ctx.URLParamDefault("keywords", "")
+	params["keywords"] = keywords
 	return params
 }
 
@@ -109,8 +117,8 @@ func ResultErr(msg string, objects interface{}) (r *JsonResult) {
 	return
 }
 
-func GetCurUser(userId int64) *viewmodels.UserData{
-	userData, err  := cache.GetUserData(userId)
+func GetCurUser(userId int64) *viewmodels.UserData {
+	userData, err := cache.GetUserData(userId)
 	if err != nil {
 		log.Fatal(err.Error())
 	}

web/controllers/model_controller.go

@@ -0,0 +1,98 @@
+package controllers
+
+import (
+	"github.com/kataras/iris/v12/mvc"
+	"xps/datamodels"
+	"xps/service/model"
+)
+
+type ModelController struct {
+	Base
+	Service model.ModelService
+}
+
+func (c *ModelController) BeforeActivation(b mvc.BeforeActivation) {
+	b.Handle("GET", "/", "GetByList")
+	b.Handle("GET", "/page", "GetByPage")
+	b.Handle("GET", "/{modelId:int64}", "GetById")
+	b.Handle("POST", "/add", "Create")
+	b.Handle("PUT", "/update", "Update")
+	b.Handle("DELETE", "/{modelId:int64}", "DeleteByID")
+}
+
+func (c *ModelController) GetByList() *JsonResult {
+	params := c.buildParams()
+	data, err := c.Service.GetByList(params)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	}
+	return ResultOk("获取成功", data)
+}
+
+func (c *ModelController) GetByPage() *JsonResult {
+	params := c.buildParams()
+	data, err := c.Service.GetByPage(params)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}
+
+func (c *ModelController) GetById(modelId int64) *JsonResult {
+	data, err := c.Service.GetById(modelId)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}
+
+func (c *ModelController) Create() *JsonResult {
+	userId := c.GetCurUserId()
+
+	model := datamodels.Model{}
+	model.CreatedBy = userId
+	err := c.Ctx.ReadJSON(&model)
+	if err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+
+	err = c.Service.Create(&model)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("新增成功", nil)
+	}
+}
+
+func (c *ModelController) Update() *JsonResult {
+	userId := c.GetCurUserId()
+
+	model := datamodels.Model{}
+	if err := c.Ctx.ReadJSON(&model); err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+
+	model.UpdatedBy = userId
+	err := c.Service.Update(&model)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("更新成功", nil)
+	}
+}
+
+func (c *ModelController) DeleteByID(modelId int64) *JsonResult {
+	userId := c.GetCurUserId()
+
+	var m = make(map[string]interface{})
+	m["modelId"] = modelId
+	m["deletedBy"] = userId
+	err := c.Service.Delete(m)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("删除成功", nil)
+	}
+}

web/controllers/object_attr_controller.go

@@ -0,0 +1,100 @@
+package controllers
+
+import (
+	"github.com/kataras/iris/v12/mvc"
+	"xps/datamodels"
+	"xps/service/model"
+)
+
+type ObjectAttrController struct {
+	Base
+	Service model.ObjectAttrService
+}
+
+func (c *ObjectAttrController) BeforeActivation(b mvc.BeforeActivation) {
+	b.Handle("GET", "/", "GetByList")
+	b.Handle("GET", "/page", "GetByPage")
+	b.Handle("GET", "/{modelId:int64}/{objectId:int64}/{attrId:int64}", "GetById")
+	b.Handle("POST", "/add", "Create")
+	b.Handle("PUT", "/update", "Update")
+	b.Handle("DELETE", "/{modelId:int64}/{objectId:int64}/{attrId:int64}", "DeleteByID")
+}
+
+func (c *ObjectAttrController) GetByList() *JsonResult {
+	params := c.buildParams()
+	data, err := c.Service.GetByList(params)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	}
+	return ResultOk("获取成功", data)
+}
+
+func (c *ObjectAttrController) GetByPage() *JsonResult {
+	params := c.buildParams()
+	data, err := c.Service.GetByPage(params)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}
+
+func (c *ObjectAttrController) GetById(modelId, objectId, attrId int64) *JsonResult {
+	data, err := c.Service.GetById(modelId, objectId, attrId)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}
+
+func (c *ObjectAttrController) Create() *JsonResult {
+	userId := c.GetCurUserId()
+
+	attr := datamodels.ObjectAttr{}
+	attr.CreatedBy = userId
+	err := c.Ctx.ReadJSON(&attr)
+	if err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+
+	err = c.Service.Create(&attr)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("新增成功", nil)
+	}
+}
+
+func (c *ObjectAttrController) Update() *JsonResult {
+	userId := c.GetCurUserId()
+
+	attr := datamodels.ObjectAttr{}
+	if err := c.Ctx.ReadJSON(&attr); err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+
+	attr.UpdatedBy = userId
+	err := c.Service.Update(&attr)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("更新成功", nil)
+	}
+}
+
+func (c *ObjectAttrController) DeleteByID(modelId, objectId, attrId int64) *JsonResult {
+	userId := c.GetCurUserId()
+
+	var m = make(map[string]interface{})
+	m["modelId"] = modelId
+	m["objectId"] = objectId
+	m["attrId"] = attrId
+	m["deletedBy"] = userId
+	err := c.Service.Delete(m)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("删除成功", nil)
+	}
+}

web/controllers/object_controller.go

@@ -0,0 +1,109 @@
+package controllers
+
+import (
+	"github.com/kataras/iris/v12/mvc"
+	"xps/datamodels"
+	"xps/service/model"
+)
+
+type ObjectController struct {
+	Base
+	Service model.ObjectService
+}
+
+func (c *ObjectController) BeforeActivation(b mvc.BeforeActivation) {
+	b.Handle("GET", "/", "GetByList")
+	b.Handle("GET", "/page", "GetByPage")
+	b.Handle("GET", "/{modelId:int64}/{objectId:int64}", "GetById")
+	b.Handle("POST", "/add", "Create")
+	b.Handle("PUT", "/update", "Update")
+	b.Handle("DELETE", "/{modelId:int64}/{objectId:int64}", "DeleteByID")
+}
+
+func (c *ObjectController) GetByList() *JsonResult {
+	params := c.buildParams()
+	modelId := c.Ctx.URLParamInt64Default("modelId", 0)
+	if modelId <= 0 {
+		return ResultErr("参数不完整", nil)
+	}
+	params["modelId"] = modelId
+	data, err := c.Service.GetByList(params)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	}
+	return ResultOk("获取成功", data)
+}
+
+func (c *ObjectController) GetByPage() *JsonResult {
+	params := c.buildParams()
+	modelId := c.Ctx.URLParamInt64Default("modelId", 0)
+	if modelId <= 0 {
+		return ResultErr("参数不完整", nil)
+	}
+	params["modelId"] = modelId
+	data, err := c.Service.GetByPage(params)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}
+
+func (c *ObjectController) GetById(modelId, objectId int64) *JsonResult {
+	data, err := c.Service.GetById(modelId, objectId)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}
+
+func (c *ObjectController) Create() *JsonResult {
+	userId := c.GetCurUserId()
+
+	object := datamodels.Object{}
+	object.CreatedBy = userId
+	err := c.Ctx.ReadJSON(&object)
+	if err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+
+	err = c.Service.Create(&object)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("新增成功", nil)
+	}
+}
+
+func (c *ObjectController) Update() *JsonResult {
+	userId := c.GetCurUserId()
+
+	object := datamodels.Object{}
+	if err := c.Ctx.ReadJSON(&object); err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+
+	object.UpdatedBy = userId
+	err := c.Service.Update(&object)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("更新成功", nil)
+	}
+}
+
+func (c *ObjectController) DeleteByID(modelId, objectId int64) *JsonResult {
+	userId := c.GetCurUserId()
+
+	var m = make(map[string]interface{})
+	m["modelId"] = modelId
+	m["objectId"] = objectId
+	m["deletedBy"] = userId
+	err := c.Service.Delete(m)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("删除成功", nil)
+	}
+}

web/router/routes.go

@@ -5,6 +5,8 @@ import (
 	"github.com/kataras/iris/v12"
 	"github.com/kataras/iris/v12/mvc"
 	"xps/bootstrap"
+	"xps/service/model"
+	_ "xps/service/model"
 	"xps/service/system"
 	"xps/web/controllers"
 	"xps/web/middleware"
@@ -138,4 +140,24 @@ func Configure(b *bootstrap.Bootstrapper) {
 		partnerCatApp.Register(partnerCatService)
 		partnerCatApp.Handle(new(controllers.PartnerCatController))
 	}
+
+	// Model
+	dsModel := b.Party("/model", crs).AllowMethods(iris.MethodOptions)
+	{
+		dsModel.Use(middleware.AuthToken)
+		modelService := model.NewModelService()
+		modelApp := mvc.New(dsModel.Party(""))
+		modelApp.Register(modelService)
+		modelApp.Handle(new(controllers.ModelController))
+
+		objectService := model.NewObjectService()
+		objectApp := mvc.New(dsModel.Party("/object"))
+		objectApp.Register(objectService)
+		objectApp.Handle(new(controllers.ObjectController))
+
+		objectAttrService := model.NewObjectAttrService()
+		objectAttrApp := mvc.New(dsModel.Party("/object/attribute"))
+		objectAttrApp.Register(objectAttrService)
+		objectAttrApp.Handle(new(controllers.ObjectAttrController))
+	}
 }