init

datamodels/db_type.go

@@ -2,22 +2,23 @@ package datamodels
 
 import "time"
 
-type DBType struct {
-    DbTypeId     int64     `json:"dbTypeId"         xorm:"'db_type_id'        bigint     pk comment('主键ID')      "`
-    DbTypeTitle  string    `json:"dbTypeTitle"      xorm:"'db-type_title'     varchar(50)   comment('模型名称')     "`
+type DbType struct {
+    DbTypeId     int64     `json:"dbTypeId"         xorm:"'db_type_id'        bigint      pk comment('主键ID')      "`
+    DbTypeTitle  string    `json:"dbTypeTitle"      xorm:"'db_type_title'     varchar(50)    comment('模型名称')     "`
     GetTables    string    `json:"getTables"        xorm:"'get_tables'        varchar(255)   comment('描述')        "`
     GetTableDef  string    `json:"getTableDef"      xorm:"'get_table_def'     varchar(255)   comment('描述')        "`
-    DbTypeDesc   string    `json:"dbTypeDesc"       xorm:"'db-type_desc'      varchar(255)   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'"`
+    DbTypeDesc   string    `json:"dbTypeDesc"       xorm:"'db_type_desc'      varchar(255)   comment('模型名称')     "`
+    DbTypeLink   string    `json:"dbTypeLink"       xorm:"'db_type_link'      varchar(255)   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 *DBType) TableName() string {
+func (t *DbType) TableName() string {
     return "ds_db_type"
 }
 

repositories/daas/db_type.go

@@ -0,0 +1,107 @@
+package daas
+
+import (
+    "fmt"
+    "time"
+    "xorm.io/xorm"
+    "xps/datamodels"
+    "xps/viewmodels"
+)
+
+type DbTypeRepo struct {
+    engine *xorm.Engine
+}
+
+func NewDbTypeRepo(engine *xorm.Engine) *DbTypeRepo {
+    return &DbTypeRepo{
+        engine: engine,
+    }
+}
+
+func (d *DbTypeRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error) {
+    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, ok := m["keywords"]; ok {
+        sqlWhere += ` AND A.model_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+    }
+    
+    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 "
+    pageStart  := (page - 1) * limit
+    sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+    
+    datalist   := make([]datamodels.DbType, 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 *DbTypeRepo) GetList(m map[string]interface{}) ([]viewmodels.DbTypeInfo, error) {
+    sqlSelect := ` SELECT A.*               `
+    sqlFrom   := ` FROM  ds_model   AS A    `
+    sqlWhere  := ` WHERE A.deleted_flag = 0 `
+    if keywords, ok := m["keywords"]; ok {
+        sqlWhere += ` AND   A.model_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
+    }
+    
+    sqlOrderBy := " ORDER BY model_id ASC "
+    datalist := make([]viewmodels.DbTypeInfo, 0)
+    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
+    if err != nil {
+        return nil, err
+    }
+    return datalist, nil
+}
+
+func (d *DbTypeRepo) GetById(modelId int64) (*viewmodels.DbTypeInfo, error) {
+    data := &viewmodels.DbTypeInfo{}
+    ok, err := d.engine.Where("model_id = ?", modelId).Get(data)
+    if !ok && err == nil {
+        return nil, err
+    } else {
+        return data, nil
+    }
+}
+
+func (d *DbTypeRepo) Create(data *datamodels.DbType) error {
+    data.CreatedAt = time.Now()
+    _, err := d.engine.Insert(data)
+    return err
+}
+
+func (d *DbTypeRepo) Update(data *datamodels.DbType) error {
+    modelId := data.DbTypeId
+    
+    data.UpdatedAt = time.Now()
+    _, err := d.engine.Where("model_id = ?", modelId).Update(data)
+    return err
+}
+
+func (d *DbTypeRepo) Delete(m map[string]interface{}) error {
+    modelId   := m["modelId"].(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)
+    return err
+}

repositories/model/model_repo.go

@@ -19,18 +19,17 @@ func NewModelRepo(engine *xorm.Engine) *ModelRepo {
 }
 
 func (d *ModelRepo) GetPage(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 + "%'"
+	sqlSelect := ` SELECT A.*                `
+	sqlFrom   := ` FROM   ds_model   AS A    `
+	sqlWhere  := ` WHERE  A.deleted_flag = 0 `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.model_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount  := `SELECT COUNT(*) `
+	sqlCount  := ` SELECT COUNT(*)           `
 	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.Model))
 	if err1 != nil {
 		return nil, err1
@@ -47,25 +46,23 @@ func (d *ModelRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, e
 	}
 
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
 }
 
 func (d *ModelRepo) GetList(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 + "%'"
+	sqlSelect := ` SELECT A.*               `
+	sqlFrom   := ` FROM  ds_model   AS A    `
+	sqlWhere  := ` WHERE A.deleted_flag = 0 `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.model_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlOrderBy := " ORDER BY model_id ASC "
-	datalist := make([]viewmodels.ModelInfo, 0)
+	datalist   := make([]viewmodels.ModelInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
 	if err != nil {
 		return nil, err
@@ -98,7 +95,7 @@ func (d *ModelRepo) Update(data *datamodels.Model) error {
 }
 
 func (d *ModelRepo) Delete(m map[string]interface{}) error {
-	modelId := m["modelId"].(int64)
+	modelId   := m["modelId"].(int64)
 	deletedBy := m["deletedBy"].(int64)
 
 	data := &datamodels.Model{}

repositories/model/object_attr_repo.go

@@ -19,18 +19,17 @@ func NewObjectAttrRepo(engine *xorm.Engine) *ObjectAttrRepo {
 }
 
 func (d *ObjectAttrRepo) GetPage(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 + "%'"
+	sqlSelect := ` SELECT A.*                   `
+	sqlFrom   := ` FROM   ds_object_attr   AS A `
+	sqlWhere  := ` WHERE A.deleted_flag = 0     `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.attr_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount  := `SELECT COUNT(*) `
+	sqlCount  := ` SELECT COUNT(*)              `
 	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.ObjectAttr))
 	if err1 != nil {
 		return nil, err1
@@ -47,20 +46,19 @@ func (d *ObjectAttrRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResu
 	}
 
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
 }
 
 func (d *ObjectAttrRepo) GetList(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 + "%'"
+	sqlSelect  := ` SELECT A.*                 `
+	sqlFrom    := ` FROM  ds_object_attr AS A  `
+	sqlWhere   := ` WHERE A.deleted_flag = 0   `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.attr_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 	sqlOrderBy := " ORDER BY model_id DESC "
 	
@@ -114,8 +112,8 @@ func (d *ObjectAttrRepo) Delete(m map[string]interface{}) error {
 
 	data := &datamodels.ObjectAttr{}
 	data.DeletedFlag = 1
-	data.DeletedBy = deletedBy
-	data.DeletedAt = time.Now()
+	data.DeletedBy   = deletedBy
+	data.DeletedAt   = time.Now()
 	_, err := d.engine.
 		Where("model_id = ?", modelId).
 		Where("object_id = ?", objectId).

repositories/model/object_repo.go

@@ -19,26 +19,25 @@ func NewObjectRepo(engine *xorm.Engine) *ObjectRepo {
 }
 
 func (d *ObjectRepo) GetPage(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 + "%'"
+	sqlSelect := ` SELECT A.*                `
+	sqlFrom   := ` FROM   ds_object   AS A   `
+	sqlWhere  := ` WHERE A.deleted_flag = 0  `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.object_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount := `SELECT COUNT(*) `
+	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)
+	
+	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)
@@ -47,10 +46,10 @@ func (d *ObjectRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 	}
 
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
 }
 

repositories/system/app_cat_repo.go

@@ -29,7 +29,7 @@ func (d *AppCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 		sqlWhere += " AND A.app_cat_title like '%" + fmt.Sprintf("%s", keywords) + "%' "
 	}
 
-	sqlCount := ` SELECT COUNT(*) `
+	sqlCount := ` SELECT COUNT(*)            `
 	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.AppCat))
 	if err1 != nil {
 		return nil, err1
@@ -54,12 +54,11 @@ func (d *AppCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 }
 
 func (d *AppCatRepo) GetList(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 + "%'"
+	sqlSelect  := ` SELECT A.*                `
+	sqlFrom    := ` FROM  app_cat AS A        `
+	sqlWhere   := ` WHERE A.deleted_flag = 0  `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.app_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlOrderBy := " ORDER BY app_cat_id DESC "
@@ -67,8 +66,9 @@ func (d *AppCatRepo) GetList(m map[string]interface{}) ([]viewmodels.AppCatInfo,
 	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 *AppCatRepo) GetById(appCatId int64) (*viewmodels.AppCatInfo, error) {

repositories/system/app_permit_repo.go

@@ -66,7 +66,7 @@ func (d *AppPermitRepo) GetListByKey(appKey string, roleId int64)([]viewmodels.A
                    JOIN  app         AS B ON (A.app_id = B.app_id) `
 	sqlWhere  := ` WHERE A.deleted_flag = 0 `
 	sqlWhere  += ` AND B.app_key = '` + appKey + "'"
-	sqlWhere  += ` AND A.role_id = ` + fmt.Sprintf("%d", roleId)
+	sqlWhere  += ` AND A.role_id =  ` + fmt.Sprintf("%d", roleId)
 	sqlOrderBy := " ORDER BY A.app_id, A.role_id, A.parent_id, A.sort_no "
 	
 	datalist := make([]viewmodels.AppPermitInfo, 0)

repositories/system/ent_cat_repo.go

@@ -22,14 +22,14 @@ func (d *EntCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 	limit := m["limit"].(int)
 	page  := m["page"].(int)
 
-	sqlSelect := `SELECT A.*`
-	sqlFrom   := `FROM   ent_cat AS A `
-	sqlWhere  := `WHERE A.deleted_flag = 0 `
+	sqlSelect := ` SELECT A.*               `
+	sqlFrom   := ` FROM   ent_cat AS A      `
+	sqlWhere  := ` WHERE A.deleted_flag = 0 `
 	if keywords, ok:= m["keywords"]; ok {
 		sqlWhere += " AND A.ent_cat_title like '%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount := `SELECT COUNT(*) `
+	sqlCount := ` SELECT COUNT(*)          `
 	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.EntCat))
 	if err1 != nil {
 		return nil, err1
@@ -54,9 +54,9 @@ func (d *EntCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 }
 
 func (d *EntCatRepo) GetList(m map[string]interface{}) ([]viewmodels.EntCatInfo, error) {
-	sqlSelect := `SELECT A.* `
-	sqlFrom   := `FROM  ent_cat   AS A    `
-	sqlWhere  := `WHERE A.deleted_flag = 0 `
+	sqlSelect := ` SELECT A.*               `
+	sqlFrom   := ` FROM  ent_cat   AS A     `
+	sqlWhere  := ` WHERE A.deleted_flag = 0 `
 	if keywords, ok := m["keywords"]; ok {
 		sqlWhere += " AND A.ent_cat_title like " + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}

repositories/system/group_cat_repo.go

@@ -19,28 +19,27 @@ func NewGroupCatRepo(engine *xorm.Engine) *GroupCatRepo {
 }
 
 func (d *GroupCatRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error) {
-	ocId     := m["ocId"].(int64)
-	keywords := m["keywords"].(string)
-	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   s_group_cat   AS A `
-	sqlWhere  := `WHERE A.deleted_flag = 0  and A.oc_id = ` + fmt.Sprintf("%d", ocId)
-
-	if keywords != "" {
-		sqlWhere += ` AND   A.group_cat_title like ` + "'%" + keywords + "%'"
+	sqlSelect := ` SELECT A.*                 `
+	sqlFrom   := ` FROM   s_group_cat   AS A  `
+	sqlWhere  := ` WHERE  A.deleted_flag = 0 AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
+	
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.group_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount := `SELECT COUNT(*) `
+	sqlCount := ` SELECT COUNT(*)            `
 	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count(new(datamodels.GroupCat))
 	if err1 != nil {
 		return nil, err1
 	}
 	
 	sqlOrderBy := " ORDER BY group_cat_id DESC "
-	pageStart := (page - 1) * limit
-	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+	pageStart  := (page - 1) * limit
+	sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
 	
 	datalist := make([]datamodels.GroupCat, 0)
 	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
@@ -58,14 +57,13 @@ func (d *GroupCatRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult,
 }
 
 func (d *GroupCatRepo) GetList(m map[string]interface{})([]viewmodels.GroupCatInfo, error) {
-	ocId     := m["ocId"].(int64)
-	keywords := m["keywords"].(string)
+	ocId      := m["ocId"].(int64)
 	
-	sqlSelect := `SELECT A.* `
-	sqlFrom   := `FROM  s_group_cat   AS A    `
-	sqlWhere  := `WHERE A.deleted_flag = 0  AND A.oc_id =` + fmt.Sprintf("%d", ocId)
-	if keywords != "" {
-		sqlWhere += ` AND   A.group_cat_title like ` + "'%" + keywords + "%'"
+	sqlSelect := ` SELECT A.*                 `
+	sqlFrom   := ` FROM   s_group_cat   AS A  `
+	sqlWhere  := ` WHERE  A.deleted_flag = 0  AND A.oc_id =` + fmt.Sprintf("%d", ocId)
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.group_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlOrderBy := " ORDER BY group_cat_id DESC "
@@ -73,8 +71,9 @@ func (d *GroupCatRepo) GetList(m map[string]interface{})([]viewmodels.GroupCatIn
 	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 *GroupCatRepo) GetById(ocId int64, groupCatId int64)(*viewmodels.GroupCatInfo, error){

repositories/system/group_member_position_repo.go

@@ -29,23 +29,21 @@ func (d *GroupMemberPositionRepo) GetById(ocId int64, gmpid int64)(*datamodels.G
 }
 
 func (d *GroupMemberPositionRepo) GetFirstPositionByGroupIdAndAccountId(ocId, groupId, accountId int64) (*viewmodels.GroupMemberPositionInfo, error) {
-	sqlSelect := ` SELECT
-                          A.oc_id,
-                          A.gmp_id,
-                          A.group_id,
-                          B.group_name,
-                          A.account_id,
-                          C.account_name,
-                          A.position_id,
-                          D.position_name 
-                 `
+	sqlSelect := ` SELECT    A.oc_id,
+                             A.gmp_id,
+                             A.group_id,
+                             B.group_name,
+                             A.account_id,
+                             C.account_name,
+                             A.position_id,
+                             D.position_name  `
 	sqlFrom  :=  ` FROM      s_group_member_position AS A
                    LEFT JOIN s_group       AS B ON ( A.oc_id = B.oc_id AND A.group_id    = B.group_id   )
                    LEFT JOIN account       AS C ON ( A.oc_id = C.oc_id AND A.account_id  = C.account_id ) 
                    LEFT JOIN s_position    AS D ON ( A.oc_id = D.oc_id AND A.position_id = D.position_id) `
-	sqlWhere := `  WHERE A.oc_id     = ` + fmt.Sprintf("%d", ocId)
-	sqlWhere += `  AND  A.group_id   = ` + fmt.Sprintf("%d", groupId)
-	sqlWhere += `  AND  A.account_id = ` + fmt.Sprintf("%d", accountId)
+	sqlWhere := `  WHERE A.oc_id      = ` + fmt.Sprintf("%d", ocId)
+	sqlWhere += `  AND   A.group_id   = ` + fmt.Sprintf("%d", groupId)
+	sqlWhere += `  AND   A.account_id = ` + fmt.Sprintf("%d", accountId)
 	
 	roleMemberPositionInfo := &viewmodels.GroupMemberPositionInfo{}
 	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(roleMemberPositionInfo)
@@ -105,8 +103,9 @@ func (d *GroupMemberPositionRepo) GetList(m map[string]interface{})([]viewmodels
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("group_id DESC").Find(&datalist)
 	if err != nil {
 		return nil, err
+	} else {
+		return datalist, nil
 	}
-	return datalist, nil
 }
 
 func (d *GroupMemberPositionRepo) Create(data *datamodels.GroupMemberPosition) error {

repositories/system/group_member_repo.go

@@ -2,208 +2,182 @@ package system
 
 import (
 	"fmt"
-	"log"
 	"xorm.io/xorm"
 	"xps/datamodels"
 	"xps/viewmodels"
 )
 
-// Role repository data struct
 type GroupMemberRepo struct {
 	engine *xorm.Engine
 }
 
-// New role repository instance
 func NewGroupMemberRepo(engine *xorm.Engine) *GroupMemberRepo {
 	return &GroupMemberRepo{
 		engine: engine,
 	}
 }
 
-// Get role by id
-func (d *GroupMemberRepo) GetById(ocId int64, gmId int64) *datamodels.GroupMember {
+func (d *GroupMemberRepo) GetById(ocId int64, gmId int64)(*datamodels.GroupMember, error){
 	data := &datamodels.GroupMember{GmId: gmId}
 	ok, err := d.engine.Get(data)
 	if ok && err == nil {
-		return data
+		return data, nil
 	} else {
-		data.GroupId = 0
-		return data
+		return nil, err
 	}
 }
 
 func (d *GroupMemberRepo) GetList(m map[string]interface{})([]viewmodels.GroupMemberInfo, error) {
     ocId      := m["ocId"].(int64)
-	keywords  := m["keywords"].(string)
-	sqlSelect := `SELECT A.gm_id,
-                         A.group_id,
-                         A.group_name,
-                         A.account_id,
-                         A.group_member_remark `
-	sqlFrom   := `FROM      s_group_member AS A
-                  LEFT JOIN s_group        AS B ON (A.group_id = B.group_id) `
-	sqlWhere  := `WHERE  A.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)
-	if keywords != "" {
-		sqlWhere += ` AND   B.group_name like ` + "'%" + keywords + "%'"
+	sqlSelect := ` SELECT    A.gm_id,
+                             A.group_id,
+                             A.group_name,
+                             A.account_id,
+                             A.group_member_remark `
+	sqlFrom   := ` FROM      s_group_member AS A
+                   LEFT JOIN s_group        AS B ON (A.group_id = B.group_id) `
+	sqlWhere  := ` WHERE  A.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   B.group_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 	datalist := make([]viewmodels.GroupMemberInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("group_id DESC").Find(&datalist)
 	if err != nil {
 		return nil, err
+	} else {
+		return datalist, nil
 	}
-
-	return datalist, nil
 }
 
-func (d *GroupMemberRepo) GetMembersOfSubordinateGroupByPage(ocId, groupId, groupLeft, groupRight int64, keyword string) []viewmodels.GroupMemberInfo {
-	var datalist = make([]viewmodels.GroupMemberInfo, 0)
-
-	sqlSelect := `
-        SELECT
-            DISTINCT(A.account_id),
-            A.gm_id,
-            A.oc_id,
-            A.group_id,
-            A.created_by,
-            A.created_time,
-            A.updated_by,
-            A.updated_time,
-            A.deleted_flag,
-            A.deleted_by,
-            A.deleted_time,
-    
-            B.account_name,
-            B.account_real_name,
-            B.account_phone,
-            B.account_pic,
-            B.status,    
-            C.group_name,
-            C.node_left,
-            C.node_right,
-
-            D.gmp_id,
-            D.position_id,
-            D.position_name,
-			
-			E.gmpg_id,
-            E.grant_group_id,
-            F.group_name as grant_group_name
-
-        `
-	sqlFrom := `
-        FROM
-            s_group_member                      AS A
-        LEFT JOIN account                       AS B ON (A.oc_id = B.oc_id AND A.account_id = B.account_id)
-        LEFT JOIN s_group                       AS C ON (A.oc_id = C.oc_id AND A.group_id    = C.group_id)
-        LEFT JOIN s_group_member_position_grant AS E ON (B.oc_id = E.oc_id AND B.account_id = E.account_id)
-        LEFT JOIN s_group                       AS F ON(E.oc_id = F.oc_id AND E.grant_group_id = F.group_id)
-        LEFT JOIN (
-            SELECT
-                M.oc_id,
-                M.account_id,
-                M.gmp_id,
-                M.group_id,
-                M.position_id,
-                P.position_name,
-                N.gmpg_id,
-                N.grant_group_id,
-                GP.group_name as grant_group_name
-            FROM
-                s_group_member_position AS M
-            LEFT JOIN s_group_member_position_grant AS N ON (
-                    M.oc_id = N.oc_id
-                AND M.account_id = N.account_id
-                AND M.group_id = N.group_id
-                AND M.position_id = N.position_id)
-            LEFT JOIN s_position AS P  ON(M.oc_id = P.oc_id  AND M.position_id    = P.position_id)
-            LEFT JOIN s_group    AS GP ON(M.oc_id = GP.oc_id AND N.grant_group_id = GP.group_id)
-         )      AS  D ON (A.oc_id= D.oc_id AND A.account_id = D.account_id AND A.group_id = D.group_id)
-                 `
-	sqlWhere := `WHERE  B.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d", ocId)
-
-	if keyword != "" {
-		sqlWhere += ` AND ( B.account_real_name LIKE ` + "'%" + keyword + "%'"
-		sqlWhere += ` OR B.account_name             LIKE ` + "'%" + keyword + "%'"
-		sqlWhere += ` OR B.account_phone            LIKE ` + "'%" + keyword + "%'"
-		sqlWhere += ` OR D.position_title           LIKE ` + "'%" + keyword + "%'"
+func (d *GroupMemberRepo) GetMembersOfSubordinateGroupByPage(m map[string]interface{})([]viewmodels.GroupMemberInfo, error){
+	sqlSelect := ` SELECT   DISTINCT(A.account_id),
+				            A.gm_id,
+				            A.oc_id,
+				            A.group_id,
+				            A.created_by,
+				            A.created_time,
+				            A.updated_by,
+				            A.updated_time,
+				            A.deleted_flag,
+				            A.deleted_by,
+				            A.deleted_time,
+				            B.account_name,
+				            B.account_real_name,
+				            B.account_phone,
+				            B.account_pic,
+				            B.status,
+				            C.group_name,
+				            C.node_left,
+				            C.node_right,
+				            D.gmp_id,
+				            D.position_id,
+				            D.position_name,
+							E.gmpg_id,
+				            E.grant_group_id,
+				            F.group_name as grant_group_name `
+	sqlFrom := ` FROM
+		             s_group_member                      AS A
+		         LEFT JOIN account                       AS B ON (A.oc_id = B.oc_id AND A.account_id = B.account_id)
+		         LEFT JOIN s_group                       AS C ON (A.oc_id = C.oc_id AND A.group_id    = C.group_id)
+		         LEFT JOIN s_group_member_position_grant AS E ON (B.oc_id = E.oc_id AND B.account_id = E.account_id)
+		         LEFT JOIN s_group                       AS F ON(E.oc_id = F.oc_id AND E.grant_group_id = F.group_id)
+		         LEFT JOIN (
+		             SELECT
+		                M.oc_id,
+		                M.account_id,
+		                M.gmp_id,
+		                M.group_id,
+		                M.position_id,
+		                P.position_name,
+		                N.gmpg_id,
+		                N.grant_group_id,
+		                GP.group_name as grant_group_name
+		            FROM
+		                s_group_member_position AS M
+		            LEFT JOIN s_group_member_position_grant AS N ON (
+		                    M.oc_id = N.oc_id
+		                AND M.account_id = N.account_id
+		                AND M.group_id = N.group_id
+		                AND M.position_id = N.position_id)
+		            LEFT JOIN s_position AS P  ON(M.oc_id = P.oc_id  AND M.position_id    = P.position_id)
+		            LEFT JOIN s_group    AS GP ON(M.oc_id = GP.oc_id AND N.grant_group_id = GP.group_id)
+		         )      AS  D ON (A.oc_id= D.oc_id AND A.account_id = D.account_id AND A.group_id = D.group_id)
+		                 `
+	
+	ocId     := m["ocId"].(int64)
+	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_title           LIKE ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
-
-	if groupLeft > 0 && groupRight > 0 {
+	
+	groupLeft,  ok1 := m["groupLeft"]
+	groupRight, ok2 := m["groupRight"]
+	if ok1 && ok2 {
 		sqlWhere += ` AND C.node_left  >= ` + fmt.Sprintf("%d", groupLeft)
 		sqlWhere += ` AND C.node_right <= ` + fmt.Sprintf("%d", groupRight)
 	}
-
+	
+	datalist := make([]viewmodels.GroupMemberInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("A.group_id DESC").Find(&datalist)
 	if err != nil {
-		log.Fatal(err)
+		return nil, err
+	} else {
+		return datalist, nil
 	}
-
-	return datalist
 }
 
 func (d *GroupMemberRepo) GetFirstGroupByAccountId(ocId int64, aid int64) (*viewmodels.GroupMemberInfo, error) {
-	var groupMemberInfo = &viewmodels.GroupMemberInfo{}
-
-	sqlSelect := `
-        SELECT
-            A.gm_id,
-            A.oc_id,
-            A.account_id,
-            A.group_id,
-            B.group_name,
-            B.node_left,
-            B.node_right
-        `
-	sqlFrom := `
-        FROM
-            s_group_member    AS A
-        LEFT JOIN s_group     AS B ON (A.oc_id = B.oc_id AND A.group_id    = B.group_id)
-        `
+	sqlSelect := ` SELECT   A.gm_id,
+				            A.oc_id,
+				            A.account_id,
+				            A.group_id,
+				            B.group_name,
+				            B.node_left,
+				            B.node_right `
+	sqlFrom := `  FROM      s_group_member AS A
+		          LEFT JOIN s_group        AS B ON (A.oc_id = B.oc_id AND A.group_id = B.group_id) `
 	sqlWhere := ` WHERE  A.oc_id      = ` + fmt.Sprintf("%d", ocId)
 	sqlWhere += ` AND    A.account_id = ` + fmt.Sprintf("%d", aid)
-
+	
+	groupMemberInfo := &viewmodels.GroupMemberInfo{}
 	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("A.group_id DESC").Limit(1).Get(groupMemberInfo)
 	if !has || err != nil {
-		log.Fatal(err)
 		return nil, err
+	} else {
+		return groupMemberInfo, nil
 	}
-
-	return groupMemberInfo, nil
 }
 
-// Create
 func (d *GroupMemberRepo) Create(data *datamodels.GroupMember) error {
 	_, err := d.engine.Insert(data)
 	return err
 }
 
-// Update
-func (d *GroupMemberRepo) Update(ocId int64, gmId int64, data *datamodels.GroupMember) error {
+func (d *GroupMemberRepo) Update(ocId, gmId int64, data *datamodels.GroupMember) error {
 	_, err := d.engine.Where("oc_id = ?", ocId).Where("gm_id =?", gmId).Update(data)
 	return err
 }
 
-// Delete
-func (d *GroupMemberRepo) Delete(ocId int64, gmId int64) error {
+func (d *GroupMemberRepo) Delete(ocId, gmId int64) error {
 	_, err := d.engine.Where("oc_id = ?", ocId).Where("gm_id =?", gmId).Delete(new(datamodels.GroupMember))
 	return err
 }
 
-// Delete
-func (d *GroupMemberRepo) DeleteByGroupId(ocId int64, groupId int64) error {
+func (d *GroupMemberRepo) DeleteByGroupId(ocId, groupId int64) error {
 	_, err := d.engine.Where("oc_id = ?", ocId).
 		Where("group_id = ?", groupId).
 		Delete(new(datamodels.GroupMember))
-
 	return err
 }
 
-// Delete
-func (d *GroupMemberRepo) DeleteByAccountId(ocId int64, accountId int64) error {
+func (d *GroupMemberRepo) DeleteByAccountId(ocId , accountId int64) error {
 	_, err := d.engine.Where("oc_id = ?", ocId).
 		Where("account_id = ?", accountId).
 		Delete(new(datamodels.GroupMember))
-	
 	return err
 }
 

repositories/system/group_repo.go

@@ -53,9 +53,6 @@ func (d *GroupRepo) GetById(ocId int64 ,groupId int64)(*viewmodels.GroupInfo, er
 }
 
 func (d *GroupRepo) GetList(m map[string]interface{})([]viewmodels.GroupInfo, error) {
-    ocId     := m["ocId"].(int64)
-    keywords := m["keywords"].(string)
-    
     sqlSelect := ` SELECT A.oc_id,
                           A.group_id ,
                           A.group_name,
@@ -73,12 +70,14 @@ func (d *GroupRepo) GetList(m map[string]interface{})([]viewmodels.GroupInfo, er
                           A.node_level,
                           A.is_leaf,
                           A.is_fixed           `
-    sqlFrom  :=  ` FROM       s_group      AS A
-                   LEFT JOIN  s_group_cat  AS B ON (A.oc_id = B.oc_id AND A.group_cat_id     = B.group_cat_id)
-                   LEFT JOIN  s_group      AS C ON (A.oc_id = C.oc_id AND A.parent_id  = C.group_id )`
-    sqlWhere :=  ` WHERE A.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d" ,ocId)
-    if keywords != "" {
-        sqlWhere+= ` AND A.group_name like `+"'%"+keywords+"%'"
+    sqlFrom  := ` FROM       s_group      AS A
+                  LEFT JOIN  s_group_cat  AS B ON (A.oc_id = B.oc_id AND A.group_cat_id     = B.group_cat_id)
+                  LEFT JOIN  s_group      AS C ON (A.oc_id = C.oc_id AND A.parent_id  = C.group_id )`
+    
+    ocId     := m["ocId"].(int64)
+    sqlWhere := ` WHERE A.deleted_flag = 0 and A.oc_id = ` + fmt.Sprintf("%d" ,ocId)
+    if keywords, ok := m["keywords"]; ok {
+        sqlWhere+= ` AND A.group_name like `+"'%"+ fmt.Sprintf("%s", keywords) +"%'"
     }
     
     datalist := make([]viewmodels.GroupInfo, 0)
@@ -89,12 +88,11 @@ func (d *GroupRepo) GetList(m map[string]interface{})([]viewmodels.GroupInfo, er
     return datalist, nil
 }
 
-
-// Delete
 func (d *GroupRepo) Delete(m map[string]interface{}) error {
     ocId       := m["ocId"].(int64)
     groupId    := m["groupId"].(int64)
     deletedBy  := m["deletedBy"].(int64)
+    
     group := &datamodels.Group{}
     group.OcId        = ocId
     group.GroupId     = groupId
@@ -129,7 +127,6 @@ func (d *GroupRepo) Create(data *datamodels.Group) error {
 }
 
 func (d *GroupRepo) IncrementGroupLeft(ocId int64 ,steps int64 ,nodeLeft int64) error {
-    
     sql  := fmt.Sprintf("UPDATE s_group SET node_left = node_left + %d  WHERE oc_id =%d AND node_left >= %d AND deleted_flag = 0" ,steps ,ocId ,nodeLeft)
     _, err :=d.engine.Exec(sql)
     

repositories/system/oc_repo.go

@@ -19,7 +19,7 @@ func NewOcRepo(engine *xorm.Engine) *OcRepo {
 }
 
 func (d *OcRepo) GetById(ocId int64) (*viewmodels.OcInfo, error) {
-	sqlSelect := `  SELECT  A.oc_id,
+	sqlSelect := ` SELECT  A.oc_id,
 							A.oc_name,
 							A.oc_type_id,
 							A.root_id,
@@ -32,11 +32,9 @@ func (d *OcRepo) GetById(ocId int64) (*viewmodels.OcInfo, error) {
 							A.node_level,
 							A.is_leaf,
 							A.status,
-							A.if_lic
-                  `
-	sqlFrom := ` FROM      oc       AS A
-                 LEFT JOIN account  AS B ON(A.admin_id = B.account_id)
-               `
+							A.if_lic    `
+	sqlFrom  := ` FROM      oc       AS A
+                  LEFT JOIN account  AS B ON(A.admin_id = B.account_id) `
 	sqlWhere := ` WHERE A.deleted_flag = 0  AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
 	
 	data := &viewmodels.OcInfo{}
@@ -51,11 +49,9 @@ func (d *OcRepo) GetById(ocId int64) (*viewmodels.OcInfo, error) {
 }
 
 func (d *OcRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error) {
-	keywords := m["keywords"].(string)
-	limit    := m["limit"].(int)
-	page     := m["page"].(int)
-
-
+	limit     := m["limit"].(int)
+	page      := m["page"].(int)
+	
 	sqlSelect := `  SELECT  A.oc_id,
 							A.oc_name,
 							A.oc_type_id,
@@ -71,16 +67,15 @@ func (d *OcRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, 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 != "" {
-		sqlWhere += ` AND   A.oc_name like ` + "'%" + keywords + "%'"
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.oc_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
-	sqlCount := `SELECT COUNT(*) `
+	sqlCount := ` SELECT COUNT(*)  `
 	total, err1 := d.engine.SQL(sqlCount + sqlFrom + sqlWhere).Count()
 	if err1 != nil {
 		return nil, err1
@@ -97,16 +92,14 @@ func (d *OcRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error
 	}
 	
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
-
 }
 
 func (d *OcRepo) GetList(m map[string]interface{})([]viewmodels.OcInfo, error) {
-	keywords := m["keywords"].(string)
 	sqlSelect := `  SELECT  A.oc_id,
 							A.oc_name,
 							A.oc_type_id,
@@ -126,9 +119,9 @@ func (d *OcRepo) GetList(m map[string]interface{})([]viewmodels.OcInfo, error) {
                  LEFT JOIN account  AS B ON(A.oc_admin_id = B.account_id)
                `
 	sqlWhere := ` WHERE A.deleted_flag = 0 `
-
-	if keywords != "" {
-		sqlWhere += ` AND   A.oc_name like ` + "'%" + keywords + "%'"
+	
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.oc_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlOrderBy := " ORDER BY oc_id ASC "
@@ -136,8 +129,9 @@ func (d *OcRepo) GetList(m map[string]interface{})([]viewmodels.OcInfo, error) {
 	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 *OcRepo) Delete(m map[string]interface{}) error {

repositories/system/partner_cat_repo.go

@@ -19,15 +19,14 @@ func NewPartnerCatRepo(engine *xorm.Engine) *PartnerCatRepo {
 }
 
 func (d *PartnerCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
-	keywords := m["keywords"].(string)
 	limit := m["limit"].(int)
-	page := m["page"].(int)
+	page  := m["page"].(int)
 
-	sqlSelect := `SELECT A.*`
-	sqlFrom := `FROM   partner_cat   AS A `
-	sqlWhere := `WHERE A.deleted_flag = 0 `
-	if keywords != "" {
-		sqlWhere += ` AND A.partner_cat_title like ` + "'%" + keywords + "%'"
+	sqlSelect := ` SELECT A.*`
+	sqlFrom   := ` FROM   partner_cat   AS A `
+	sqlWhere  := ` WHERE  A.deleted_flag = 0 `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.partner_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlCount := `SELECT COUNT(*) `
@@ -47,21 +46,19 @@ func (d *PartnerCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResu
 	}
 
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
 }
 
 func (d *PartnerCatRepo) GetList(m map[string]interface{}) ([]viewmodels.PartnerCatInfo, error) {
-	keywords := m["keywords"].(string)
-
-	sqlSelect := `SELECT A.* `
-	sqlFrom := `FROM  partner_cat   AS A    `
-	sqlWhere := `WHERE A.deleted_flag = 0 `
-	if keywords != "" {
-		sqlWhere += ` AND   A.partner_cat_title like ` + "'%" + keywords + "%'"
+	sqlSelect := ` SELECT A.*                  `
+	sqlFrom   := ` FROM   partner_cat   AS A   `
+	sqlWhere  := ` WHERE A.deleted_flag = 0    `
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.partner_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlOrderBy := " ORDER BY partner_cat_id DESC "
@@ -69,8 +66,9 @@ func (d *PartnerCatRepo) GetList(m map[string]interface{}) ([]viewmodels.Partner
 	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 *PartnerCatRepo) GetById(partnerCatId int64) (*viewmodels.PartnerCatInfo, error) {
@@ -103,8 +101,8 @@ func (d *PartnerCatRepo) Delete(m map[string]interface{}) error {
 
 	data := &datamodels.PartnerCat{}
 	data.DeletedFlag = 1
-	data.DeletedBy = deletedBy
-	data.DeletedAt = time.Now()
+	data.DeletedBy   = deletedBy
+	data.DeletedAt   = time.Now()
 	_, err := d.engine.Where("partner_cat_id = ?", partnerCatId).Update(data)
 	return err
 }

repositories/system/position_repo.go

@@ -20,15 +20,14 @@ func NewPositionRepo(engine *xorm.Engine) *PositionRepo {
 
 func (d *PositionRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
 	ocId     := m["ocId"].(int64)
-	keywords := m["keywords"].(string)
 	limit    := m["limit"].(int)
 	page     := m["page"].(int)
 
 	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 != "" {
-		sqlWhere += ` AND   A.position_name like ` + "'%" + keywords + "%'"
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.position_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlCount := `SELECT COUNT(*) `
@@ -37,9 +36,9 @@ func (d *PositionRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult
 		return nil, err
 	}
 
-	var pageStart = (limit - 1) * limit
+	pageStart  := (limit - 1) * limit
 	sqlOrderBy := " ORDER BY position_id ASC "
-	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d  ", limit, pageStart)
+	sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d  ", limit, pageStart)
 	
 	datalist := []viewmodels.PositionInfo{}
 	err = d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
@@ -48,22 +47,21 @@ func (d *PositionRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult
 	}
 	
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
 }
 
 func (d *PositionRepo) GetList(m map[string]interface{}) ([]viewmodels.PositionInfo, error) {
 	ocId     := m["ocId"].(int64)
-	keywords := m["keywords"].(string)
 
 	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 != "" {
-		sqlWhere += ` AND   A.position_name like ` + "'%" + keywords + "%'"
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.position_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlOrderBy := " ORDER BY position_id ASC "
@@ -71,8 +69,9 @@ func (d *PositionRepo) GetList(m map[string]interface{}) ([]viewmodels.PositionI
 	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 *PositionRepo) GetById(ocId int64, positionId int64) (*viewmodels.PositionInfo, error) {

repositories/system/role_member_repo.go

@@ -20,7 +20,7 @@ func NewRoleMemberRepo(engine *xorm.Engine) *RoleMemberRepo {
 }
 
 func (d *RoleMemberRepo) GetAll(ocId int64, keyword string) []viewmodels.RoleMemberInfo {
-	var datalist = make([]viewmodels.RoleMemberInfo, 0)
+	
 	
 	sqlSelect := `SELECT A.rm_id,
                          A.role_id,
@@ -37,6 +37,7 @@ func (d *RoleMemberRepo) GetAll(ocId int64, keyword string) []viewmodels.RoleMem
 		sqlWhere += ` AND   B.role_name like ` + "'%" + keyword + "%'"
 	}
 	
+	datalist := make([]viewmodels.RoleMemberInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("role_id DESC").Find(&datalist)
 	if err != nil {
 		log.Fatal(err)
@@ -46,8 +47,6 @@ func (d *RoleMemberRepo) GetAll(ocId int64, keyword string) []viewmodels.RoleMem
 }
 
 func (d *RoleMemberRepo) GetAccountFirstRole(ocId int64, accountId int64) (*viewmodels.RoleMemberInfo, error) {
-	var roleMemberInfo = &viewmodels.RoleMemberInfo{}
-	
 	sqlSelect := `SELECT A.rm_id,
                          A.role_id,
                          B.role_name,
@@ -55,11 +54,11 @@ func (d *RoleMemberRepo) GetAccountFirstRole(ocId int64, accountId int64) (*view
                          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)
+                  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

repositories/system/role_repo.go

@@ -19,10 +19,8 @@ func NewRoleRepo(engine *xorm.Engine) *RoleRepo {
 }
 
 func (d *RoleRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error){
-	keywords  := m["keywords"].(string)
 	limit     := m["limit"].(int)
 	page      := m["page"].(int)
-	
 	sqlSelect := ` SELECT A.role_id ,
                           A.role_name,
                           A.role_desc,
@@ -32,11 +30,11 @@ func (d *RoleRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, er
                           A.status,
                           A.is_fixed `
 	sqlFrom   := ` FROM      s_role       AS A
-                   LEFT JOIN s_role_type  AS B ON (A.role_type_id = B.role_type_id )`
-	sqlWhere  := `WHERE A.deleted_flag = 0`
+                   LEFT JOIN s_role_type  AS B ON (A.role_type_id = B.role_type_id ) `
+	sqlWhere  := ` WHERE A.deleted_flag = 0 `
 
-	if keywords != "" {
-		sqlWhere += ` AND   A.role_name like ` + "'%" + keywords + "%'"
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.role_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlCount := `SELECT COUNT(*) `
@@ -46,8 +44,8 @@ func (d *RoleRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, er
 	}
 	
 	sqlOrderBy := " ORDER BY role_id ASC "
-	pageStart := (limit - 1) * limit
-	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+	pageStart  := (limit - 1) * limit
+	sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
 	
 	datalist   := make([]viewmodels.RoleInfo, 0)
 	err = d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
@@ -56,16 +54,14 @@ func (d *RoleRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, er
 	}
 	
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
 }
 
 func (d *RoleRepo) GetList(m map[string]interface{}) ([]viewmodels.RoleInfo, error) {
-	keywords := m["keywords"].(string)
-
 	sqlSelect := ` SELECT  A.role_id ,
                            A.role_name,
                            A.role_desc,
@@ -77,8 +73,8 @@ func (d *RoleRepo) GetList(m map[string]interface{}) ([]viewmodels.RoleInfo, err
 	sqlFrom := ` FROM      s_role       AS A
                  LEFT JOIN s_role_type  AS B ON (A.role_type_id = B.role_type_id )`
 	sqlWhere := `WHERE A.deleted_flag = 0 `
-	if keywords != "" {
-		sqlWhere += ` AND A.role_name like ` + "'%" + keywords + "%'"
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.role_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 	sqlOrderBy := " ORDER BY role_id ASC "
 	

repositories/system/task_cat_repo.go

@@ -19,17 +19,16 @@ func NewTaskCatRepo(engine *xorm.Engine) *TaskCatRepo {
 }
 
 func (d *TaskCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult, error) {
-	ocId := m["ocId"].(int64)
-	keywords := m["keywords"].(string)
+	ocId  := m["ocId"].(int64)
 	limit := m["limit"].(int)
-	page := m["page"].(int)
-
-	sqlSelect := `SELECT A.*`
-	sqlFrom := `FROM   task_cat   AS A `
-	sqlWhere := `WHERE A.deleted_flag = 0  and A.oc_id = ` + fmt.Sprintf("%d", ocId)
-
-	if keywords != "" {
-		sqlWhere += ` AND   A.task_cat_title like ` + "'%" + keywords + "%'"
+	page  := m["page"].(int)
+
+	sqlSelect := ` SELECT A.*             `
+	sqlFrom   := ` FROM   task_cat   AS A `
+	sqlWhere  := ` WHERE  A.deleted_flag = 0  and A.oc_id = ` + fmt.Sprintf("%d", ocId)
+	
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND   A.task_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlCount := `SELECT COUNT(*) `
@@ -39,8 +38,8 @@ func (d *TaskCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 	}
 
 	sqlOrderBy := " ORDER BY task_cat_id DESC "
-	pageStart := (page - 1) * limit
-	sqlLimit := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
+	pageStart  := (page - 1) * limit
+	sqlLimit   := fmt.Sprintf(" LIMIT %d OFFSET %d ", limit, pageStart)
 
 	datalist := make([]datamodels.TaskCat, 0)
 	err2 := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy + sqlLimit).Find(&datalist)
@@ -49,27 +48,26 @@ func (d *TaskCatRepo) GetPage(m map[string]interface{}) (*viewmodels.PageResult,
 	}
 
 	pageResult := &viewmodels.PageResult{}
-	pageResult.Data = datalist
-	pageResult.Total = total
+	pageResult.Data     = datalist
+	pageResult.Total    = total
 	pageResult.PageSize = limit
-	pageResult.Page = page
+	pageResult.Page     = page
 	return pageResult, nil
 
 }
 
 func (d *TaskCatRepo) GetList(m map[string]interface{}) ([]viewmodels.TaskCatInfo, error) {
 	ocId := m["ocId"].(int64)
-	keywords := m["keywords"].(string)
 
 	sqlSelect := ` SELECT A.* `
-	sqlFrom := ` FROM  task_cat   AS A    `
-	sqlWhere := ` WHERE A.deleted_flag = 0  AND A.oc_id =` + fmt.Sprintf("%d", ocId)
-	if keywords != "" {
-		sqlWhere += ` AND   A.task_cat_title like ` + "'%" + keywords + "%'"
+	sqlFrom   := ` FROM  task_cat   AS A    `
+	sqlWhere  := ` WHERE A.deleted_flag = 0  AND A.oc_id =` + fmt.Sprintf("%d", ocId)
+	if keywords, ok := m["keywords"]; ok {
+		sqlWhere += ` AND A.task_cat_title like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
 	}
 
 	sqlOrderBy := " ORDER BY task_cat_id DESC "
-	datalist := make([]viewmodels.TaskCatInfo, 0)
+	datalist   := make([]viewmodels.TaskCatInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
 	if err != nil {
 		return nil, err
@@ -94,7 +92,7 @@ func (d *TaskCatRepo) Create(data *datamodels.TaskCat) error {
 }
 
 func (d *TaskCatRepo) Update(data *datamodels.TaskCat) error {
-	ocId := data.OcId
+	ocId      := data.OcId
 	taskCatId := data.TaskCatId
 
 	data.UpdatedAt = time.Now()
@@ -103,7 +101,7 @@ func (d *TaskCatRepo) Update(data *datamodels.TaskCat) error {
 }
 
 func (d *TaskCatRepo) Delete(m map[string]interface{}) error {
-	ocId := m["ocId"].(int64)
+	ocId      := m["ocId"].(int64)
 	taskCatId := m["taskCatId"].(int64)
 	deletedBy := m["deletedBy"].(int64)
 

repositories/system/user_repo.go

@@ -19,29 +19,29 @@ func NewUserRepo(engine *xorm.Engine) *UserRepo {
 }
 
 func (d *UserRepo) GetById(ocId int64, userId int64)(*viewmodels.UserInfo, error){
-    sqlSelect := ` SELECT A.gm_id,
-                        A.oc_id,
-                        A.group_id,
-                        A.account_id,
-                        B.account_name,
-                        B.account_real_name,
-                        B.account_staff_no,
-                        B.account_phone,
-                        B.account_type,
-                        B.account_avatar,
-                        B.account_photo,
-                        B.account_loc,
-                        B.status,
-                        B.is_fixed,
-                        C.group_name,
-                        C.node_left,
-                        C.node_right,
-                        E.gmp_id,
-                        E.position_id,
-                        H.position_name,
-                        F.gmpg_id,
-                        F.grant_group_id,
-                        G.group_name  AS grant_group_name`
+    sqlSelect := ` SELECT   A.gm_id,
+                            A.oc_id,
+                            A.group_id,
+                            A.account_id,
+                            B.account_name,
+                            B.account_real_name,
+                            B.account_staff_no,
+                            B.account_phone,
+                            B.account_type,
+                            B.account_avatar,
+                            B.account_photo,
+                            B.account_loc,
+                            B.status,
+                            B.is_fixed,
+                            C.group_name,
+                            C.node_left,
+                            C.node_right,
+                            E.gmp_id,
+                            E.position_id,
+                            H.position_name,
+                            F.gmpg_id,
+                            F.grant_group_id,
+                            G.group_name  AS grant_group_name  `
     sqlFrom := `  FROM  s_group_member                        AS  A
                   LEFT  JOIN account                          AS  B  ON ( A.oc_id = B.oc_id AND A.account_id  = B.account_id  )
                   LEFT  JOIN s_group                          AS  C  ON ( A.oc_id = C.oc_id AND A.group_id    = C.group_id )
@@ -56,8 +56,9 @@ func (d *UserRepo) GetById(ocId int64, userId int64)(*viewmodels.UserInfo, error
     has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(data)
     if !has || err != nil {
         return nil, err
+    } else {
+        return data, nil
     }
-    return data, nil
 }
 
 func (d *UserRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, error){
@@ -154,52 +155,51 @@ func (d *UserRepo) GetPage(m map[string]interface{})(*viewmodels.PageResult, err
 
 func (d *UserRepo) GetList(m map[string]interface{})([]viewmodels.UserInfo, error){
     ocId      := m["ocId"].(int64)
-    sqlSelect := `SELECT
-                    DISTINCT(A.account_id),
-                    A.gm_id,
-                    A.oc_id,
-                    A.group_id,
-                    B.account_name,
-                    B.account_real_name,
-                    B.account_phone,
-                    B.account_staff_no,
-                    B.account_avatar,
-                    B.status,
-                    B.is_fixed,
-                    C.group_name,
-                    C.node_left,
-                    C.node_right,
-                    D.gmp_id,
-                    D.position_id,
-                    D.position_name,
-                    E.gmpg_id,
-                    E.grant_group_id,
-                    F.group_name as grant_group_name  `
-    sqlFrom := `FROM      s_group_member                AS A
-                LEFT JOIN account                       AS B ON (A.oc_id = B.oc_id AND A.account_id     = B.account_id)
-                LEFT JOIN s_group                       AS C ON (A.oc_id = C.oc_id AND A.group_id       = C.group_id)
-                LEFT JOIN s_group_member_position_grant AS E ON (B.oc_id = E.oc_id AND B.account_id     = E.account_id)
-                LEFT JOIN s_group                       AS F ON (E.oc_id = F.oc_id AND E.grant_group_id = F.group_id)
-                LEFT JOIN (
-                    SELECT
-                        M.oc_id,
-                        M.account_id,
-                        M.gmp_id,
-                        M.group_id,
-                        M.position_id,
-                        P.position_name,
-                        N.gmpg_id,
-                        N.grant_group_id,
-                        GP.group_name as grant_group_name
-                    FROM      s_group_member_position       AS M
-                    LEFT JOIN s_group_member_position_grant AS N ON (
-                            M.oc_id       = N.oc_id
-                        AND M.account_id  = N.account_id
-                        AND M.group_id    = N.group_id
-                        AND M.position_id = N.position_id )
+    sqlSelect := ` SELECT   DISTINCT(A.account_id),
+                            A.gm_id,
+                            A.oc_id,
+                            A.group_id,
+                            B.account_name,
+                            B.account_real_name,
+                            B.account_phone,
+                            B.account_staff_no,
+                            B.account_avatar,
+                            B.status,
+                            B.is_fixed,
+                            C.group_name,
+                            C.node_left,
+                            C.node_right,
+                            D.gmp_id,
+                            D.position_id,
+                            D.position_name,
+                            E.gmpg_id,
+                            E.grant_group_id,
+                            F.group_name as grant_group_name  `
+    sqlFrom := `  FROM      s_group_member                AS A
+                  LEFT JOIN account                       AS B ON (A.oc_id = B.oc_id AND A.account_id     = B.account_id)
+                  LEFT JOIN s_group                       AS C ON (A.oc_id = C.oc_id AND A.group_id       = C.group_id)
+                  LEFT JOIN s_group_member_position_grant AS E ON (B.oc_id = E.oc_id AND B.account_id     = E.account_id)
+                  LEFT JOIN s_group                       AS F ON (E.oc_id = F.oc_id AND E.grant_group_id = F.group_id)
+                  LEFT JOIN (
+                      SELECT
+                          M.oc_id,
+                          M.account_id,
+                          M.gmp_id,
+                          M.group_id,
+                          M.position_id,
+                          P.position_name,
+                          N.gmpg_id,
+                          N.grant_group_id,
+                          GP.group_name as grant_group_name
+                      FROM      s_group_member_position       AS M
+                      LEFT JOIN s_group_member_position_grant AS N ON (
+                              M.oc_id       = N.oc_id
+                          AND M.account_id  = N.account_id
+                          AND M.group_id    = N.group_id
+                          AND M.position_id = N.position_id )
                     LEFT JOIN s_position AS P  ON(M.oc_id = P.oc_id  AND M.position_id    = P.position_id)
                     LEFT JOIN s_group    AS GP ON(M.oc_id = GP.oc_id AND N.grant_group_id = GP.group_id)
-                )      AS  D ON (A.oc_id = D.oc_id AND A.account_id = D.account_id AND A.group_id = D.group_id) `
+                 )  AS  D ON (A.oc_id = D.oc_id AND A.account_id = D.account_id AND A.group_id = D.group_id) `
     sqlWhere := ` WHERE B.deleted_flag = 0 AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
     
     if keywords, ok := m["keywords"]; ok {
@@ -220,7 +220,7 @@ func (d *UserRepo) GetList(m map[string]interface{})([]viewmodels.UserInfo, erro
     err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
     if err != nil {
         return nil, err
+    } else {
+        return datalist, nil
     }
-    
-    return datalist, nil
 }

viewmodels/app_permit_info.go

@@ -1,15 +1,18 @@
 package viewmodels
 
-// AppPermit Data Model
 type AppPermitInfo struct {
-	AppId       int64  `json:"appId"           form:"appId"           xorm:"'app_id'            bigint     pk comment('APP ID')"`
-	RoleId      int64  `json:"roleId"          form:"roleId"          xorm:"'role_id'           bigint     pk comment('Role ID')"`
-	PermitId    int64  `json:"permitId"        form:"permitId"        xorm:"'permit_id'         bigint     pk comment('Permit ID')  "`
-	PermitTitle string `json:"permitTitle"     form:"permitTitle"     xorm:"'permit_title'      varchar(127)  comment('标题')      "`
-	PermitCode  string `json:"permitCode"      form:"permitCode"      xorm:"'permit_code'       varchar(127)  comment('CODE')     "`
-	PermitDesc  string `json:"permitDesc"      form:"permitDesc"      xorm:"'permit_desc'       varchar(511)  comment('描述')      "`
-	PermitType  int64  `json:"permitType"      form:"permitType"      xorm:"'permit_type'       int           comment('Type') "`
-	RootId      int64  `json:"rootId"          form:"rootId"          xorm:"'root_id'           int           comment('Root Id') "`
-	ParentId    int64  `json:"parentId"        form:"parentId"        xorm:"'parent_id'         int           comment('Parent Id') "`
-	SortNo      int64  `json:"sortNo"          form:"sortNo"          xorm:"'sort_no'           int           comment('Sort No') "`
+	AppId       int64  `json:"appId"           xorm:"'app_id'            bigint     pk comment('APP ID')     "`
+	RoleId      int64  `json:"roleId"          xorm:"'role_id'           bigint     pk comment('Role ID')    "`
+	PermitId    int64  `json:"permitId"        xorm:"'permit_id'         bigint     pk comment('Permit ID')  "`
+	PermitTitle string `json:"permitTitle"     xorm:"'permit_title'      varchar(127)  comment('标题')        "`
+	PermitCode  string `json:"permitCode"      xorm:"'permit_code'       varchar(127)  comment('CODE')       "`
+	PermitDesc  string `json:"permitDesc"      xorm:"'permit_desc'       varchar(511)  comment('描述')        "`
+	PermitType  int64  `json:"permitType"      xorm:"'permit_type'       int           comment('Type')       "`
+	RootId      int64  `json:"rootId"          xorm:"'root_id'           int           comment('Root Id')    "`
+	ParentId    int64  `json:"parentId"        xorm:"'parent_id'         int           comment('Parent Id')  "`
+	SortNo      int64  `json:"sortNo"          xorm:"'sort_no'           int           comment('Sort No')    "`
+}
+
+func (t *AppPermitInfo) TableName() string {
+	return "app_permit"
 }

viewmodels/db_type_info.go

@@ -0,0 +1,15 @@
+package viewmodels
+
+type DbTypeInfo struct {
+    DbTypeId     int64     `json:"dbTypeId"         xorm:"'db_type_id'        bigint      pk comment('主键ID')      "`
+    DbTypeTitle  string    `json:"dbTypeTitle"      xorm:"'db_type_title'     varchar(50)    comment('模型名称')     "`
+    GetTables    string    `json:"getTables"        xorm:"'get_tables'        varchar(255)   comment('描述')        "`
+    GetTableDef  string    `json:"getTableDef"      xorm:"'get_table_def'     varchar(255)   comment('描述')        "`
+    DbTypeDesc   string    `json:"dbTypeDesc"       xorm:"'db_type_desc'      varchar(255)   comment('描述')        "`
+    DbTypeLink   string    `json:"dbTypeLink"       xorm:"'db_type_link'      varchar(255)   comment('描述')        "`
+}
+
+func (t *DbTypeInfo) TableName() string {
+    return "ds_db_type"
+}
+