init

datamodels/group.go

@@ -8,7 +8,6 @@ type Group struct {
 	GroupId          int64     `json:"groupId"         xorm:"'group_id'            bigint not null pk     comment('群组ID')      " `
 	GroupName        string    `json:"groupName"       xorm:"'group_name'          varchar(127) not null  comment('群组名称')    " `
 	GroupCatId       int64     `json:"groupCatId"      xorm:"'group_cat_id'        bigint not null        comment('群组类型ID')  " `
-	GroupCatTitle    string    `json:"groupCatTitle"   xorm:"'group_cat_title'     varchar(127) not null  comment('群组类型名称') " `
 	
 	GroupPath        string    `json:"groupPath"       xorm:"'group_path'          varchar(255) not null  comment('群组PATH')    " `
 	GroupDesc        string    `json:"groupDesc"       xorm:"'group_desc'          varchar(255) not null  comment('群组DESC')    " `

repositories/daas/db_type.go

@@ -22,20 +22,20 @@ func (d *DbTypeRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, e
     limit     := m["limit"].(int)
     page      := m["page"].(int)
     
-    sqlSelect := ` SELECT A.*               `
-    sqlFrom   := ` FROM   ds_model   AS A   `
-    sqlWhere  := ` WHERE A.deleted_flag = 0 `
+    sqlSelect := ` SELECT A.*                `
+    sqlFrom   := ` FROM   ds_db_type AS A    `
+    sqlWhere  := ` WHERE  A.deleted_flag = 0 `
     if keywords, ok := m["keywords"]; ok {
-        sqlWhere += ` AND A.model_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+        sqlWhere += ` AND A.db_type_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
     }
     
-    sqlCount  := ` SELECT COUNT(*) `
+    sqlCount    := ` SELECT COUNT(*) `
     total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.DbType))
     if err1 != nil {
         return nil, err1
     }
     
-    sqlOrderBy := " ORDER BY model_id ASC "
+    sqlOrderBy := " ORDER BY db_type_id ASC "
     pageStart  := (page - 1) * limit
     sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
     
@@ -55,24 +55,25 @@ func (d *DbTypeRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, e
 
 func (d *DbTypeRepo) GetList(m map[string]interface{}) ([]viewmodels.DbTypeInfo, error) {
     sqlSelect := ` SELECT A.*               `
-    sqlFrom   := ` FROM  ds_model   AS A    `
+    sqlFrom   := ` FROM  ds_db_type   AS A    `
     sqlWhere  := ` WHERE A.deleted_flag = 0 `
     if keywords, ok := m["keywords"]; ok {
-        sqlWhere += ` AND   A.model_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+        sqlWhere += ` AND A.db_type_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
     }
     
-    sqlOrderBy := " ORDER BY model_id ASC "
+    sqlOrderBy := " ORDER BY db_type_id ASC "
     datalist := make([]viewmodels.DbTypeInfo, 0)
     err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
     if err != nil {
         return nil, err
+    } else {
+        return datalist, nil
     }
-    return datalist, nil
 }
 
-func (d *DbTypeRepo) GetById(modelId int64) (*viewmodels.DbTypeInfo, error) {
+func (d *DbTypeRepo) GetById(dbTypeId int64) (*viewmodels.DbTypeInfo, error) {
     data := &viewmodels.DbTypeInfo{}
-    ok, err := d.engine.Where("model_id = ?", modelId).Get(data)
+    ok, err := d.engine.Where("db_type_id = ?", dbTypeId).Get(data)
     if !ok && err == nil {
         return nil, err
     } else {
@@ -87,21 +88,21 @@ func (d *DbTypeRepo) Create(data *datamodels.DbType) error {
 }
 
 func (d *DbTypeRepo) Update(data *datamodels.DbType) error {
-    modelId := data.DbTypeId
+    dbTypeId := data.DbTypeId
     
     data.UpdatedAt = time.Now()
-    _, err := d.engine.Where("model_id = ?", modelId).Update(data)
+    _, err := d.engine.Where("db_type_id = ?", dbTypeId).Update(data)
     return err
 }
 
 func (d *DbTypeRepo) Delete(m map[string]interface{}) error {
-    modelId   := m["modelId"].(int64)
+    dbTypeId  := m["dbTypeId"].(int64)
     deletedBy := m["deletedBy"].(int64)
     
     data := &datamodels.DbType{}
     data.DeletedFlag = 1
-    data.DeletedBy = deletedBy
-    data.DeletedAt = time.Now()
-    _, err := d.engine.Where("model_id = ?", modelId).Update(data)
+    data.DeletedBy   = deletedBy
+    data.DeletedAt   = time.Now()
+    _, err := d.engine.Where("db_type_id = ?", dbTypeId).Update(data)
     return err
 }

repositories/system/oc_repo.go

@@ -42,17 +42,16 @@ func (d *OcRepo) GetById(ocId int64) (*viewmodels.OcInfo, error) {
 
 	if !has || err != nil {
 		return nil, err
+	} else {
+		return data, nil
 	}
-
-	return data, nil
-
 }
 
 func (d *OcRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error) {
 	limit     := m["limit"].(int)
 	page      := m["page"].(int)
 	
-	sqlSelect := `  SELECT  A.oc_id,
+	sqlSelect := ` SELECT  A.oc_id,
 							A.oc_name,
 							A.oc_type_id,
 							A.root_id,
@@ -65,8 +64,7 @@ func (d *OcRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error
 							A.node_level,
 							A.is_leaf,
 							A.status,
-							A.if_lic
-                  `
+							A.if_lic   `
 	sqlFrom  := ` FROM      oc       AS A
                   LEFT JOIN account  AS B ON(A.oc_admin_id = B.account_id) `
 	sqlWhere := ` WHERE A.deleted_flag = 0 `
@@ -81,11 +79,11 @@ func (d *OcRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error
 		return nil, err1
 	}
 
-	pageStart := (page - 1) * limit
+	pageStart  := (page - 1) * limit
 	sqlOrderBy := " ORDER BY oc_id ASC "
-	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d  ", limit, pageStart)
+	sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d  ", limit, pageStart)
 	
-	var datalist []viewmodels.OcInfo
+	datalist := make([]viewmodels.OcInfo, 0)
 	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
 	if err2 != nil {
 		return nil, err2
@@ -115,16 +113,15 @@ func (d *OcRepo) GetList(m map[string]interface{})([]viewmodels.OcInfo, error) {
 							A.status,
 							A.if_lic
                   `
-	sqlFrom := ` FROM      oc       AS A
-                 LEFT JOIN account  AS B ON(A.oc_admin_id = B.account_id)
-               `
+	sqlFrom  := ` FROM      oc       AS A
+                  LEFT JOIN account  AS B ON(A.oc_admin_id = B.account_id) `
 	sqlWhere := ` WHERE A.deleted_flag = 0 `
 	
 	if keywords, ok := m["keywords"]; ok {
 		sqlWhere += ` AND   A.oc_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
-
 	sqlOrderBy := " ORDER BY oc_id ASC "
+	
 	datalist := make([]viewmodels.OcInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
 	if err != nil {
@@ -201,7 +198,7 @@ func (d *OcRepo) GetAdmin(ocId int64)(*datamodels.Account, error) {
 	sqlSelect := ` SELECT A.*       ,
                           B.*            `
 	sqlFrom   := ` FROM       oc           AS A
-                   LEFT  JOIN account      AS B ON(A.oc_id     = B.oc_id   AND A.admin_id = B.account_id) `
+                   LEFT  JOIN account      AS B ON(A.oc_id = B.oc_id AND A.admin_id = B.account_id) `
 	sqlWhere  := ` WHERE A.deleted_flag = 0  AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
 	
 	data := &datamodels.Account{}

repositories/system/position_repo.go

@@ -23,14 +23,14 @@ func (d *PositionRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult
 	limit    := m["limit"].(int)
 	page     := m["page"].(int)
 
-	sqlSelect := ` SELECT A.* `
+	sqlSelect := ` SELECT A.*               `
 	sqlFrom   := ` FROM   s_position AS A   `
 	sqlWhere  := fmt.Sprintf(` WHERE A.deleted_flag = 0 and A.oc_id = %d`, ocId)
 	if keywords, ok := m["keywords"]; ok {
-		sqlWhere += ` AND   A.position_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+		sqlWhere += ` AND A.position_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount := `SELECT COUNT(*) `
+	sqlCount := ` SELECT COUNT(*)   `
 	total, err := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count()
 	if err != nil {
 		return nil, err
@@ -55,16 +55,16 @@ func (d *PositionRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult
 }
 
 func (d *PositionRepo) GetList(m map[string]interface{}) ([]viewmodels.PositionInfo, error) {
-	ocId     := m["ocId"].(int64)
+	ocId      := m["ocId"].(int64)
 
 	sqlSelect := ` SELECT A.* `
 	sqlFrom   := ` FROM   s_position AS A   `
 	sqlWhere  := fmt.Sprintf(` WHERE A.deleted_flag = 0 and A.oc_id = %d`, ocId)
 	if keywords, ok := m["keywords"]; ok {
-		sqlWhere += ` AND   A.position_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+		sqlWhere += ` AND A.position_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
-
 	sqlOrderBy := " ORDER BY position_id ASC "
+	
 	datalist := make([]viewmodels.PositionInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
 	if err != nil {
@@ -81,8 +81,9 @@ func (d *PositionRepo) GetById(ocId int64, positionId int64) (*viewmodels.Positi
 	ok, err := d.engine.Get(data)
 	if !ok || err != nil {
 		return nil, err
+	} else {
+		return data, nil
 	}
-	return data, nil
 }
 
 func (d *PositionRepo) Create(data *datamodels.Position) error {

repositories/system/role_member_repo.go

@@ -2,7 +2,6 @@ package system
 
 import (
 	"fmt"
-	"log"
 	"xorm.io/core"
 	"xorm.io/xorm"
 	"xps/datamodels"
@@ -19,52 +18,51 @@ func NewRoleMemberRepo(engine *xorm.Engine) *RoleMemberRepo {
 	}
 }
 
-func (d *RoleMemberRepo) GetAll(ocId int64, keyword string) []viewmodels.RoleMemberInfo {
+func (d *RoleMemberRepo) GetList(m map[string]interface{})([]viewmodels.RoleMemberInfo, error){
+	ocId := m["ocId"].(int64)
 	
+	sqlSelect := ` SELECT    A.rm_id,
+                             A.role_id,
+                             B.role_name,
+                             A.account_id,
+                             C.account_name `
+	sqlFrom   := ` FROM      s_role_member AS A
+                   LEFT JOIN s_role        AS B ON (A.role_id    = B.role_id)
+                   LEFT JOIN account       AS C ON (A.account_id = C.account_id AND A.oc_id = C.oc_id) `
+	sqlWhere  := ` WHERE A.oc_id = ` + fmt.Sprintf("%d", ocId)
 	
-	sqlSelect := `SELECT A.rm_id,
-                         A.role_id,
-                         B.role_name,
-                         A.account_id,
-                         C.account_name `
-	sqlFrom := `FROM      s_role_member AS A 
-                  LEFT JOIN s_role        AS B ON (A.role_id    = B.role_id)
-                  LEFT JOIN account       AS C ON (A.account_id = C.account_id AND A.oc_id = C.oc_id)
-                 `
-	sqlWhere := `WHERE A.oc_id = ` + fmt.Sprintf("%d", ocId)
-	
-	if keyword != "" {
-		sqlWhere += ` AND   B.role_name like ` + "'%" + keyword + "%'"
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   B.role_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 	
 	datalist := make([]viewmodels.RoleMemberInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("role_id DESC").Find(&datalist)
 	if err != nil {
-		log.Fatal(err)
+		return nil, err
+	} else {
+		return datalist, nil
 	}
-	
-	return datalist
 }
 
-func (d *RoleMemberRepo) GetAccountFirstRole(ocId int64, accountId int64) (*viewmodels.RoleMemberInfo, error) {
-	sqlSelect := `SELECT A.rm_id,
+func (d *RoleMemberRepo) GetAccountFirstRole(ocId int64, accountId int64)(*viewmodels.RoleMemberInfo, error){
+	sqlSelect := `  SELECT A.rm_id,
                          A.role_id,
                          B.role_name,
                          A.account_id,
                          C.account_name  `
-	sqlFrom := `  FROM      s_role_member AS A
-                  LEFT JOIN s_role        AS B ON (A.role_id    = B.role_id)
-                  LEFT JOIN account       AS C ON (A.account_id = C.account_id AND A.oc_id = C.oc_id) `
-	sqlWhere := ` WHERE A.oc_id    = ` + fmt.Sprintf("%d", ocId)
-	sqlWhere += ` AND A.account_id = ` + fmt.Sprintf("%d", accountId)
+	sqlFrom   := `  FROM      s_role_member AS A
+                    LEFT JOIN s_role        AS B ON (A.role_id    = B.role_id)
+                    LEFT JOIN account       AS C ON (A.account_id = C.account_id AND A.oc_id = C.oc_id) `
+	sqlWhere  := `  WHERE A.oc_id    = ` + fmt.Sprintf("%d", ocId)
+	sqlWhere  += `  AND A.account_id = ` + fmt.Sprintf("%d", accountId)
 	
 	roleMemberInfo := &viewmodels.RoleMemberInfo{}
 	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(roleMemberInfo)
 	if !has || err != nil {
 		return nil, err
+	} else {
+		return roleMemberInfo, nil
 	}
-	
-	return roleMemberInfo, nil
 }
 
 func (d *RoleMemberRepo) Update(ocId int64, rmId int64, rm *datamodels.RoleMember) error {

repositories/system/task_cat_repo.go

@@ -19,9 +19,9 @@ func NewTaskCatRepo(engine *xorm.Engine) *TaskCatRepo {
 }
 
 func (d *TaskCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
-	ocId  := m["ocId"].(int64)
-	limit := m["limit"].(int)
-	page  := m["page"].(int)
+	ocId      := m["ocId"].(int64)
+	limit     := m["limit"].(int)
+	page      := m["page"].(int)
 
 	sqlSelect := ` SELECT A.*             `
 	sqlFrom   := ` FROM   task_cat   AS A `
@@ -31,7 +31,7 @@ func (d *TaskCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 		sqlWhere += ` AND   A.task_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount := `SELECT COUNT(*) `
+	sqlCount    := ` SELECT COUNT(*)   `
 	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.TaskCat))
 	if err1 != nil {
 		return nil, err1
@@ -41,7 +41,7 @@ func (d *TaskCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 	pageStart  := (page - 1) * limit
 	sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
 
-	datalist := make([]datamodels.TaskCat, 0)
+	datalist   := make([]datamodels.TaskCat, 0)
 	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
 	if err2 != nil {
 		return nil, err2
@@ -71,8 +71,9 @@ func (d *TaskCatRepo) GetList(m map[string]interface{}) ([]viewmodels.TaskCatInf
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
 	if err != nil {
 		return nil, err
+	} else {
+		return datalist, nil
 	}
-	return datalist, nil
 }
 
 func (d *TaskCatRepo) GetById(ocId int64, taskCatId int64) (*viewmodels.TaskCatInfo, error) {

repositories/system/user_repo.go

@@ -115,17 +115,17 @@ func (d *UserRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, err
     sqlWhere := ` WHERE B.deleted_flag = 0 AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
     
     if keywords, ok := m["keywords"]; ok {
-        sqlWhere+= " AND ( B.account_real_name LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
-        sqlWhere+= " OR    B.account_name      LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
-        sqlWhere+= " OR    B.account_phone     LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
-        sqlWhere+= " OR    D.position_name     LIKE '%" + fmt.Sprintf("%s",keywords) + "%' )"
+        sqlWhere += " AND ( B.account_real_name LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
+        sqlWhere += " OR    B.account_name      LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
+        sqlWhere += " OR    B.account_phone     LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
+        sqlWhere += " OR    D.position_name     LIKE '%" + fmt.Sprintf("%s",keywords) + "%' )"
     }
     
     nodeLeft,  ok1 := m["nodeLeft"]
     nodeRight, ok2 := m["nodeRight"]
     if ok1 && ok2 {
-        sqlWhere+= ` AND C.node_left  >= ` + fmt.Sprintf("%d", nodeLeft)
-        sqlWhere+= ` AND C.node_right <= ` + fmt.Sprintf("%d", nodeRight)
+        sqlWhere += ` AND C.node_left  >= ` + fmt.Sprintf("%d", nodeLeft)
+        sqlWhere += ` AND C.node_right <= ` + fmt.Sprintf("%d", nodeRight)
     }
     
     sqlCount := `SELECT COUNT(*) `
@@ -203,16 +203,16 @@ func (d *UserRepo) GetList(m map[string]interface{})([]viewmodels.UserInfo, erro
     sqlWhere := ` WHERE B.deleted_flag = 0 AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
     
     if keywords, ok := m["keywords"]; ok {
-        sqlWhere+= " AND ( B.account_real_name LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
-        sqlWhere+= " OR    B.account_name      LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
-        sqlWhere+= " OR    B.account_phone     LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
-        sqlWhere+= " OR    D.position_name     LIKE '%" + fmt.Sprintf("%s",keywords) + "%' )"
+        sqlWhere += " AND ( B.account_real_name LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
+        sqlWhere += " OR    B.account_name      LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
+        sqlWhere += " OR    B.account_phone     LIKE '%" + fmt.Sprintf("%s",keywords) + "%'  "
+        sqlWhere += " OR    D.position_name     LIKE '%" + fmt.Sprintf("%s",keywords) + "%' )"
     }
     nodeLeft,  ok1 := m["nodeLeft"]
     nodeRight, ok2 := m["nodeRight"]
     if ok1 && ok2 {
-        sqlWhere+= ` AND C.node_left  >= ` + fmt.Sprintf("%d", nodeLeft)
-        sqlWhere+= ` AND C.node_right <= ` + fmt.Sprintf("%d", nodeRight)
+        sqlWhere += ` AND C.node_left  >= ` + fmt.Sprintf("%d", nodeLeft)
+        sqlWhere += ` AND C.node_right <= ` + fmt.Sprintf("%d", nodeRight)
     }
     sqlOrderBy := " ORDER BY A.account_id, A.group_id "
 

service/daas/base_service.go

@@ -0,0 +1,29 @@
+package daas
+
+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/daas/db_type_service.go

@@ -0,0 +1,52 @@
+package daas
+
+import (
+    "xps/datamodels"
+    "xps/datasource"
+    "xps/repositories/daas"
+    "xps/viewmodels"
+)
+
+type DbTypeService interface {
+    GetList(m map[string]interface{}) ([]viewmodels.DbTypeInfo, error)
+    GetPage(m map[string]interface{}) (*viewmodels.PageResult, error)
+    GetById(modelId int64) (*viewmodels.DbTypeInfo, error)
+    Create(d *datamodels.DbType) error
+    Update(d *datamodels.DbType) error
+    Delete(m map[string]interface{}) error
+}
+
+type dbTypeService struct {
+    repo *daas.DbTypeRepo
+}
+
+func NewDbTypeService() DbTypeService {
+    return &dbTypeService{
+        repo: daas.NewDbTypeRepo(datasource.InstanceMaster()),
+    }
+}
+
+func (s *dbTypeService) GetList(m map[string]interface{}) ([]viewmodels.DbTypeInfo, error) {
+    return s.repo.GetList(m)
+}
+
+func (s *dbTypeService) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
+    return s.repo.GetPage(m)
+}
+
+func (s *dbTypeService) GetById(modelId int64) (*viewmodels.DbTypeInfo, error) {
+    return s.repo.GetById(modelId)
+}
+
+func (s *dbTypeService) Create(DbType *datamodels.DbType) error {
+    DbType.DbTypeId = NewID()
+    return s.repo.Create(DbType)
+}
+
+func (s *dbTypeService) Update(DbType *datamodels.DbType) error {
+    return s.repo.Update(DbType)
+}
+
+func (s *dbTypeService) Delete(m map[string]interface{}) error {
+    return s.repo.Delete(m)
+}

web/controllers/base_controller.go

@@ -85,7 +85,10 @@ func (b *Base) buildParams() map[string]interface{} {
 	}
 	params["page"] = page
 	keywords := b.Ctx.URLParamDefault("keywords", "")
-	params["keywords"] = keywords
+	if keywords != "" {
+		params["keywords"] = keywords
+	}
+	
 	return params
 }
 

web/controllers/db_type_controller.go

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

web/router/routes.go

@@ -5,6 +5,7 @@ import (
 	"github.com/kataras/iris/v12"
 	"github.com/kataras/iris/v12/mvc"
 	"xps/bootstrap"
+	"xps/service/daas"
 	"xps/service/model"
 	"xps/service/system"
 	"xps/web/controllers"
@@ -145,22 +146,32 @@ func Configure(b *bootstrap.Bootstrapper) {
 	}
 
 	// Model
-	dsModel := b.Party("/model", crs).AllowMethods(iris.MethodOptions)
+	modelParty := b.Party("/model", crs).AllowMethods(iris.MethodOptions)
 	{
-		dsModel.Use(middleware.AuthToken)
+		modelParty.Use(middleware.AuthToken)
 		modelService := model.NewModelService()
-		modelApp := mvc.New(dsModel.Party(""))
+		modelApp := mvc.New(modelParty.Party(""))
 		modelApp.Register(modelService)
 		modelApp.Handle(new(controllers.ModelController))
 
 		objectService := model.NewObjectService()
-		objectApp := mvc.New(dsModel.Party("/object"))
+		objectApp := mvc.New(modelParty.Party("/object"))
 		objectApp.Register(objectService)
 		objectApp.Handle(new(controllers.ObjectController))
 
 		objectAttrService := model.NewObjectAttrService()
-		objectAttrApp := mvc.New(dsModel.Party("/object/attribute"))
+		objectAttrApp := mvc.New(modelParty.Party("/object/attribute"))
 		objectAttrApp.Register(objectAttrService)
 		objectAttrApp.Handle(new(controllers.ObjectAttrController))
 	}
+	
+	// DaaS
+	daasParty := b.Party("/daas", crs).AllowMethods(iris.MethodOptions)
+	{
+		daasParty.Use(middleware.AuthToken)
+		dbTypeService := daas.NewDbTypeService()
+		dbTypeApp := mvc.New(daasParty.Party("/dbType"))
+		dbTypeApp.Register(dbTypeService)
+		dbTypeApp.Handle(new(controllers.DbTypeController))
+	}
 }