init

repositories/system/app_cat_repo.go

@@ -98,7 +98,7 @@ func (d *AppCatRepo) Update(data *datamodels.AppCat) error {
 }
 
 func (d *AppCatRepo) Delete(m map[string]interface{}) error {
-	appCatId := m["appCatId"].(int64)
+	appCatId  := m["appCatId"].(int64)
 	deletedBy := m["deletedBy"].(int64)
 
 	data := &datamodels.AppCat{}

repositories/system/app_permit_repo.go

@@ -2,8 +2,6 @@ package system
 
 import (
 	"fmt"
-	"log"
-	"time"
 	"xorm.io/xorm"
 	"xps/datamodels"
 	"xps/viewmodels"
@@ -13,64 +11,101 @@ type AppPermitRepo struct {
 	engine *xorm.Engine
 }
 
-// New Instance
 func NewAppPermitRepo(engine *xorm.Engine) *AppPermitRepo {
 	return &AppPermitRepo{
 		engine: engine,
 	}
 }
 
-func (d *AppPermitRepo) GetByList(appKey string, roleId int64, keywords string) []viewmodels.AppPermitInfo {
+func (d *AppPermitRepo) GetByList(m map[string]interface{})([]viewmodels.AppPermitInfo, error) {
+	roleId    := m["roleId"].(int64)
+	keywords  := m["keywords"].(string)
+	appKey    := m["appKey"].(string)
 
-	var datalist = make([]viewmodels.AppPermitInfo, 0)
 
-	sqlSelect := `SELECT A.app_id,
-                         A.role_id,
-                         A.permit_id,
-                         A.permit_title,
-                         A.permit_code,
-                         A.permit_desc,
-                         A.permit_type,
-                         A.root_id,
-                         A.parent_id,
-                         A.sort_no
-                 `
-	sqlFrom := `FROM app_permit  AS A
-                JOIN app         AS B ON (A.app_id = B.app_id)
-                `
-	sqlWhere := `WHERE A.deleted_flag = 0
-                 AND   B.app_key = '` + appKey + "'"
-	if keywords != "" {
-		sqlWhere += ` AND   A.role_id = ` + fmt.Sprintf("%d", roleId)
+	sqlSelect := ` SELECT A.app_id,
+                          A.role_id,
+                          A.permit_id,
+                          A.permit_title,
+                          A.permit_code,
+                          A.permit_desc,
+                          A.permit_type,
+                          A.root_id,
+                          A.parent_id,
+                          A.sort_no     `
+	sqlFrom   := ` FROM  app_permit  AS A
+                   JOIN  app         AS B ON (A.app_id = B.app_id) `
+	sqlWhere  := ` WHERE A.deleted_flag = 0 `
+	if appKey != "" {
+		sqlWhere +=  ` AND B.app_key = '` + appKey + "'"
+	}
+	if roleId >= 0 {
+		sqlWhere += ` AND A.role_id = ` + fmt.Sprintf("%d", roleId)
 	}
 	if keywords != "" {
-		sqlWhere += ` AND   A.permit_title like ` + "'%" + keywords + "%'"
+		sqlWhere += ` AND A.permit_title like ` + "'%" + keywords + "%'"
 	}
-
 	sqlOrderBy := " ORDER BY A.app_id, A.role_id, A.parent_id, A.sort_no "
-
+	
+	datalist := make([]viewmodels.AppPermitInfo, 0)
 	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere + sqlOrderBy).Find(&datalist)
 	if err != nil {
-		log.Fatal(err)
+		return nil, err
+	} else {
+		return datalist, nil
 	}
+}
 
-	return datalist
+func (d *AppPermitRepo) GetById(appId, roleId, permitId int64)(*viewmodels.AppPermitInfo, error) {
+	sqlSelect := ` SELECT A.app_id,
+                          A.role_id,
+                          A.permit_id,
+                          A.permit_title,
+                          A.permit_code,
+                          A.permit_desc,
+                          A.permit_type,
+                          A.root_id,
+                          A.parent_id,
+                          A.sort_no     `
+	sqlFrom   := ` FROM   app_permit  AS A
+                   JOIN   app         AS B ON (A.app_id = B.app_id) `
+	sqlWhere  := ` WHERE A.deleted_flag = 0 `
+	sqlWhere  += fmt.Sprintf(" AND A.app_id    = %d ", appId)
+	sqlWhere  += fmt.Sprintf(" AND A.role_id   = %d ", roleId)
+	sqlWhere  += fmt.Sprintf(" AND A.permit_id = %d ", permitId)
+	
+	data := &viewmodels.AppPermitInfo{}
+	_, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(data)
+	if err != nil {
+		return nil, err
+	} else {
+		return data, nil
+	}
 }
 
-// Delete
-func (d *AppPermitRepo) Delete(ocId int64, groupTypeId int64) error {
-	data := &datamodels.AppPermit{DeletedFlag: 1, DeletedAt: time.Now()}
-	_, err := d.engine.Where("oc_id = ?", ocId).Where("group_cat_id = ?", groupTypeId).Update(data)
+func (d *AppPermitRepo) Create(data *datamodels.AppPermit) error {
+	_, err := d.engine.Insert(data)
 	return err
 }
 
-// Update
-func (d *AppPermitRepo) Update(ocId int64, groupTypeId int64, data *datamodels.AppPermit) error {
-	_, err := d.engine.Where("oc_id = ?", ocId).Where("group_cat_id = ?", groupTypeId).Update(data)
+func (d *AppPermitRepo) Update(data *datamodels.AppPermit) error {
+	appId    := data.AppId
+	roleId   := data.RoleId
+	permitId := data.PermitId
+	_, err := d.engine.
+		Where("app_id = ?", appId).
+		Where("role_id = ?", roleId).
+		Where("permit_id = ?", permitId).
+		Update(data)
 	return err
 }
 
-func (d *AppPermitRepo) Create(data *datamodels.AppPermit) error {
-	_, err := d.engine.Insert(data)
+func (d *AppPermitRepo) Delete(appId, roleId, permitId int64) error {
+	data := &datamodels.AppPermit{}
+	_, err := d.engine.
+		Where("app_id = ?", appId).
+		Where("role_id = ?", roleId).
+		Where("permit_id = ?", permitId).
+		Delete(data)
 	return err
 }

repositories/system/role_repo.go

@@ -19,9 +19,9 @@ func NewRoleRepo(engine *xorm.Engine) *RoleRepo {
 }
 
 func (d *RoleRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult, error){
-	keywords   := m["keywords"].(string)
-	limit      := m["limit"].(int)
-	page       := m["page"].(int)
+	keywords  := m["keywords"].(string)
+	limit     := m["limit"].(int)
+	page      := m["page"].(int)
 	
 	sqlSelect := ` SELECT A.role_id ,
                           A.role_name,
@@ -64,30 +64,31 @@ func (d *RoleRepo) GetByPage(m map[string]interface{}) (*viewmodels.PageResult,
 }
 
 func (d *RoleRepo) GetByList(m map[string]interface{}) ([]viewmodels.RoleInfo, error) {
-	datalist := make([]viewmodels.RoleInfo, 0)
 	keywords := m["keywords"].(string)
 
-	sqlSelect := ` SELECT A.role_id ,
-                          A.role_name,
-                          A.role_desc,
-                          A.role_type_id,
-                          B.role_type_title,
-                          A.sort_no,
-                          A.status,
-                          A.is_fixed `
+	sqlSelect := ` SELECT  A.role_id ,
+                           A.role_name,
+                           A.role_desc,
+                           A.role_type_id,
+                           B.role_type_title,
+                           A.sort_no,
+                           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 `
 	if keywords != "" {
-		sqlWhere += ` AND   A.role_name like ` + "'%" + keywords + "%'"
+		sqlWhere += ` AND A.role_name like ` + "'%" + keywords + "%'"
 	}
 	sqlOrderBy := " ORDER BY role_id ASC "
+	
+	datalist := make([]viewmodels.RoleInfo, 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 *RoleRepo) GetById(roleId int64) (*viewmodels.RoleInfo, error) {
@@ -95,8 +96,9 @@ func (d *RoleRepo) GetById(roleId int64) (*viewmodels.RoleInfo, error) {
 	ok, err := d.engine.Get(data)
 	if !ok && err != nil {
 		return nil, err
+	} else {
+		return data, nil
 	}
-	return data, nil
 }
 
 func (d *RoleRepo) Create(data *datamodels.Role) error {

service/system/app_permit_service.go

@@ -1,29 +1,50 @@
 package system
 
 import (
+	"xps/datamodels"
 	"xps/datasource"
 	"xps/repositories/system"
 	"xps/viewmodels"
 )
 
-// AppPermit interface
 type AppPermitService interface {
-	GetByList(appKey string, roleId int64, keywords string) []viewmodels.AppPermitInfo
+	GetByList(m map[string]interface{})([]viewmodels.AppPermitInfo, error)
+	GetById(appId, roleId, permitId int64) (*viewmodels.AppPermitInfo, error)
+	Create(permit *datamodels.AppPermit) error
+	Update(permit *datamodels.AppPermit) error
+	Delete(m map[string]interface{}) error
 }
 
-// AppPermitService data struct definition
 type appPermitService struct {
 	repo *system.AppPermitRepo
 }
 
-// Create Instance
 func NewAppPermitService() AppPermitService {
 	return &appPermitService{
 		repo: system.NewAppPermitRepo(datasource.InstanceMaster()),
 	}
 }
 
-// GetAll
-func (s *appPermitService) GetByList(appKey string, roleId int64, keywords string) []viewmodels.AppPermitInfo {
-	return s.repo.GetByList(appKey, roleId, keywords)
+func (s *appPermitService) GetByList(m map[string]interface{})([]viewmodels.AppPermitInfo, error) {
+	return s.repo.GetByList(m)
+}
+
+func (s *appPermitService) GetById(appId, roleId, permitId int64) (*viewmodels.AppPermitInfo, error) {
+	return s.repo.GetById(appId, roleId, permitId)
+}
+
+func (s *appPermitService) Create(permit *datamodels.AppPermit) error {
+	permit.AppId = NewID()
+	return s.repo.Create(permit)
+}
+
+func (s *appPermitService) Update(permit *datamodels.AppPermit) error {
+	return s.repo.Update(permit)
+}
+
+func (s *appPermitService) Delete(m map[string]interface{}) error {
+	appId       := m["appId"].(int64)
+	roleId      := m["roleId"].(int64)
+	permitId    := m["permitId"].(int64)
+	return s.repo.Delete(appId, roleId, permitId)
 }

web/controllers/app_cat_controller.go

@@ -12,11 +12,11 @@ type AppCatController struct {
 }
 
 func (c *AppCatController) BeforeActivation(b mvc.BeforeActivation) {
-    b.Handle("GET",     "/",                    "GetByList")
-    b.Handle("GET",     "/page",                "GetByPage")
-    b.Handle("GET",     "/{appCatId:int64}",    "GetById")
-    b.Handle("POST",    "/add",                 "Create")
-    b.Handle("PUT",     "/update",              "Update")
+    b.Handle("GET",     "/",                    "GetByList" )
+    b.Handle("GET",     "/page",                "GetByPage" )
+    b.Handle("GET",     "/{appCatId:int64}",    "GetById"   )
+    b.Handle("POST",    "/add",                 "Create"    )
+    b.Handle("PUT",     "/update",              "Update"    )
     b.Handle("DELETE",  "/{appCatId:int64}",    "DeleteByID")
 }
 

web/controllers/app_permit_controller.go

@@ -2,6 +2,7 @@ package controllers
 
 import (
 	"github.com/kataras/iris/v12/mvc"
+	"xps/datamodels"
 	"xps/service/system"
 )
 
@@ -11,17 +12,83 @@ type AppPermitController struct {
 }
 
 func (c *AppPermitController) BeforeActivation(b mvc.BeforeActivation) {
-	b.Handle("GET", "/", "GetByList")
+	b.Handle("GET",     "/",                                                "GetByList" )
+	b.Handle("GET",     "/{appId:int64}/{roleId:int64}/{permitId:int64}",   "GetById"   )
+	b.Handle("POST",    "/add",                                             "Create"    )
+	b.Handle("PUT",     "/update",                                          "Update"    )
+	b.Handle("DELETE",  "/{appId:int64}/{roleId:int64}/{permitId:int64}",   "DeleteByID")
 }
 
 func (c *AppPermitController) GetByList() *JsonResult {
-	var appKey = c.Ctx.Values().GetString("appKey")
-	var keywords string
+	appKey := c.Ctx.URLParamDefault("appKey", "")
+ 
+	params := c.buildParams()
+	params["appKey"] = appKey
+	data, err := c.Service.GetByList(params)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
+	}
+}
 
-	if c.Ctx.URLParamExists("keywords") {
-		keywords = c.Ctx.URLParam("keywords")
+
+func (c *AppPermitController) GetById(appId, roleId, permitId int64) *JsonResult {
+	data, err := c.Service.GetById(appId, roleId, permitId)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("获取成功", data)
 	}
+}
 
-	data := c.Service.GetByList(appKey, 1, keywords)
-	return ResultOk("获取成功", data)
+func (c *AppPermitController) Create() *JsonResult {
+	userId   := c.GetCurUserId()
+	
+	appPermit := datamodels.AppPermit{}
+	appPermit.CreatedBy = userId
+	err := c.Ctx.ReadJSON(&appPermit)
+	if err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+	
+	err = c.Service.Create(&appPermit)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("新增成功", nil)
+	}
+}
+
+func (c *AppPermitController) Update() *JsonResult {
+	userId   := c.GetCurUserId()
+	
+	appPermit := datamodels.AppPermit{}
+	if err := c.Ctx.ReadJSON(&appPermit); err != nil {
+		return ResultErr("读取数据失败", nil)
+	}
+	
+	appPermit.UpdatedBy = userId
+	err := c.Service.Update(&appPermit)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("更新成功", nil)
+	}
+}
+
+func (c *AppPermitController) DeleteByID(appId, roleId, permitId int64) *JsonResult {
+	userId := c.GetCurUserId()
+	
+	m  := make(map[string]interface{})
+	m["appId"]     = appId
+	m["roleId"]    = roleId
+	m["permitId"]  = permitId
+	m["deletedBy"] = userId
+	err := c.Service.Delete(m)
+	if err != nil {
+		return ResultErr(err.Error(), nil)
+	} else {
+		return ResultOk("删除成功", nil)
+	}
 }