# Request定義
[request_definition]
r = sub, obj, act

# 策略定義
[policy_definition]
p = sub, obj, act

# 角色定義
[role_definition]
g = _, _

[policy_effect]
e = some(where (p.eft == allow))

# 匹配器定義
[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

p, alice, data1, read
p, bob, data2, write
p, data2_admin, data2, read
p, data2_admin, data2, write
g, alice, data2_admin

├─configs         # 配置文件
├─global				  # 全局變量
├─internal        # 內(nèi)部模塊
│  ├─dao					# 數(shù)據(jù)處理模塊
│  ├─middleware   # 中間件
│  ├─model        # 模型層
│  ├─router       # 路由
│  │  └─api
│  │      └─v1    # 視圖
│  └─service      # 業(yè)務(wù)邏輯層
└─pkg             # 內(nèi)部模塊包
    ├─app         # 應(yīng)用包
    ├─errcode     # 錯(cuò)誤代碼包
    └─setting     # 配置包

go get -u github.com/gin-gonic/gin
# Go語(yǔ)言casbin的依賴包
go get github.com/casbin/casbin
# gorm 適配器依賴包
go get github.com/casbin/gorm-adapter
# mysql驅(qū)動(dòng)依賴
go get github.com/go-sql-driver/mysql
# gorm 包
go get github.com/jinzhu/gorm

CREATE DATABASE `casbin_test` DEFAULT CHARACTER SET utf8;
GRANT Alter, Alter Routine, Create, Create Routine, Create Temporary Tables, Create View, Delete, Drop, Event, Execute, Index, Insert, Lock Tables, References, Select, Show View, Trigger, Update ON `casbin\_test`.* TO `ops`@`%`;
FLUSH PRIVILEGES;
DROP TABLE IF EXIST `casbin_rule`;
CREATE TABLE `casbin_rule` (
  `p_type` varchar(100) DEFAULT NULL COMMENT '規(guī)則類型',
  `v0` varchar(100) DEFAULT NULL COMMENT '角色I(xiàn)D',
  `v1` varchar(100) DEFAULT NULL COMMENT 'api路徑',
  `v2` varchar(100) DEFAULT NULL COMMENT 'api訪問方法',
  `v3` varchar(100) DEFAULT NULL,
  `v4` varchar(100) DEFAULT NULL,
  `v5` varchar(100) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='權(quán)限規(guī)則表';
/*插入操作casbin api的權(quán)限規(guī)則*/
INSERT INTO `casbin_rule`(`p_type`, `v0`, `v1`, `v2`) VALUES ('p', 'admin', '/api/v1/casbin', 'POST');
INSERT INTO `casbin_rule`(`p_type`, `v0`, `v1`, `v2`) VALUES ('p', 'admin', '/api/v1/casbin/list', 'GET');

[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[role_definition]
g = _, _

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = r.sub == p.sub && ParamsMatch(r.obj,p.obj) && r.act == p.act

type CasbinModel struct {
	PType  string `json:"p_type" gorm:"column:p_type" description:"策略類型"`
	RoleId string `json:"role_id" gorm:"column:v0" description:"角色I(xiàn)D"`
	Path   string `json:"path" gorm:"column:v1" description:"api路徑"`
	Method string `json:"method" gorm:"column:v2" description:"訪問方法"`
}

func (c *CasbinModel) TableName() string {
	return "casbin_rule"
}

func (c *CasbinModel) Create(db *gorm.DB) error {
	e := Casbin()
	if success := e.AddPolicy(c.RoleId,c.Path,c.Method); success == false {
		return errors.New("存在相同的API，添加失敗")
	}
	return nil
}

func (c *CasbinModel) Update(db *gorm.DB, values interface{}) error {
	if err := db.Model(c).Where("v1 = ? AND v2 = ?", c.Path, c.Method).Update(values).Error; err != nil {
		return err
	}
	return nil
}

func (c *CasbinModel) List(db *gorm.DB) [][]string {
	e := Casbin()
	policy := e.GetFilteredPolicy(0, c.RoleId)
	return policy
}

//@function: Casbin
//@description: 持久化到數(shù)據(jù)庫(kù)  引入自定義規(guī)則
//@return: *casbin.Enforcer
func Casbin() *casbin.Enforcer {
	s := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=%s&parseTime=%t&loc=Local",
		global.DatabaseSetting.Username,
		global.DatabaseSetting.Password,
		global.DatabaseSetting.Host,
		global.DatabaseSetting.DBName,
		global.DatabaseSetting.Charset,
		global.DatabaseSetting.ParseTime,
	)
	db, _ := gorm.Open(global.DatabaseSetting.DBType, s)

	adapter := gormadapter.NewAdapterByDB(db)
	enforcer := casbin.NewEnforcer(global.CasbinSetting.ModelPath, adapter)
	enforcer.AddFunction("ParamsMatch", ParamsMatchFunc)
	_ = enforcer.LoadPolicy()
	return enforcer
}

//@function: ParamsMatch
//@description: 自定義規(guī)則函數(shù)
//@param: fullNameKey1 string, key2 string
//@return: bool
func ParamsMatch(fullNameKey1 string, key2 string) bool {
	key1 := strings.Split(fullNameKey1, "?")[0]
	// 剝離路徑后再使用casbin的keyMatch2
	return util.KeyMatch2(key1, key2)
}

//@function: ParamsMatchFunc
//@description: 自定義規(guī)則函數(shù)
//@param: args ...interface{}
//@return: interface{}, error
func ParamsMatchFunc(args ...interface{}) (interface{}, error) {
	name1 := args[0].(string)
	name2 := args[1].(string)

	return ParamsMatch(name1, name2), nil
}

func (d *Dao) CasbinCreate(roleId string, path, method string) error {
	cm := model.CasbinModel{
		PType:  "p",
		RoleId: roleId,
		Path:   path,
		Method: method,
	}
	return cm.Create(d.engine)
}

func (d *Dao) CasbinList(roleID string) [][]string {
	cm := model.CasbinModel{RoleId: roleID}
	return cm.List(d.engine)
}

type CasbinInfo struct {
	Path   string `json:"path" form:"path"`
	Method string `json:"method" form:"method"`
}
type CasbinCreateRequest struct {
	RoleId      string       `json:"role_id" form:"role_id" description:"角色I(xiàn)D"`
	CasbinInfos []CasbinInfo `json:"casbin_infos" description:"權(quán)限模型列表"`
}

type CasbinListResponse struct {
	List []CasbinInfo `json:"list" form:"list"`
}

type CasbinListRequest struct {
	RoleID string `json:"role_id" form:"role_id"`
}

func (s Service) CasbinCreate(param *CasbinCreateRequest) error {
	for _, v := range param.CasbinInfos {
		err := s.dao.CasbinCreate(param.RoleId, v.Path, v.Method)
		if err != nil {
			return err
		}
	}
	return nil
}


func (s Service) CasbinList(param *CasbinListRequest) [][]string {
	return s.dao.CasbinList(param.RoleID)
}

type Casbin struct {
}

func NewCasbin() Casbin {
	return Casbin{}
}

// Create godoc
// @Summary 新增權(quán)限
// @Description 新增權(quán)限
// @Tags 權(quán)限管理
// @Produce json
// @Security ApiKeyAuth
// @Param body body service.CasbinCreateRequest true "body"
// @Success 200 {object} string "成功"
// @Failure 400 {object} errcode.Error "請(qǐng)求錯(cuò)誤"
// @Failure 500 {object} errcode.Error "內(nèi)部錯(cuò)誤"
// @Router /api/v1/casbin [post]
func (c Casbin) Create(ctx *gin.Context) {
	param := service.CasbinCreateRequest{}
	response := app.NewResponse(ctx)
	valid, errors := app.BindAndValid(ctx, &param)
	if !valid {
		log.Printf("app.BindAndValid errs: %v", errors)
		errRsp := errcode.InvalidParams.WithDetails(errors.Errors()...)
		response.ToErrorResponse(errRsp)
		return
	}

	// 進(jìn)行插入操作
	svc := service.NewService(ctx)
	err := svc.CasbinCreate(&param)
	if err != nil {
		log.Printf("svc.CasbinCreate err: %v", err)
		response.ToErrorResponse(errcode.ErrorCasbinCreateFail)
	}
	response.ToResponse(gin.H{})
	return
}


// List godoc
// @Summary 獲取權(quán)限列表
// @Produce json
// @Tags 權(quán)限管理
// @Security ApiKeyAuth
// @Param data body service.CasbinListRequest true "角色I(xiàn)D"
// @Success 200 {object} service.CasbinListResponse "成功"
// @Failure 400 {object} errcode.Error "請(qǐng)求錯(cuò)誤"
// @Failure 500 {object} errcode.Error "內(nèi)部錯(cuò)誤"
// @Router /api/v1/casbin/list [post]
func (c Casbin) List(ctx *gin.Context) {
	param := service.CasbinListRequest{}
	response := app.NewResponse(ctx)
	valid, errors := app.BindAndValid(ctx, &param)
	if !valid {
		log.Printf("app.BindAndValid errs: %v", errors)
		errRsp := errcode.InvalidParams.WithDetails(errors.Errors()...)
		response.ToErrorResponse(errRsp)
		return
	}
	// 業(yè)務(wù)邏輯處理
	svc := service.NewService(ctx)
	casbins := svc.CasbinList(&param)
	var respList []service.CasbinInfo
	for _, host := range casbins {
		respList = append(respList, service.CasbinInfo{
			Path:   host[1],
			Method: host[2],
		})
	}
	response.ToResponseList(respList, 0)
	return
}

type Test struct {
}

func NewTest() Test {
	return Test{}
}

func (t Test) Get(ctx *gin.Context) {
	log.Println("Hello 接收到GET請(qǐng)求..")
	response := app.NewResponse(ctx)
	response.ToResponse("接收GET請(qǐng)求成功")
}

func CasbinHandler() gin.HandlerFunc {
	return func(ctx *gin.Context) {
		response := app.NewResponse(ctx)
		// 獲取請(qǐng)求的URI
		obj := ctx.Request.URL.RequestURI()
		// 獲取請(qǐng)求方法
		act := ctx.Request.Method
		// 獲取用戶的角色
		sub := "admin"
		e := model.Casbin()
		fmt.Println(obj, act, sub)
		// 判斷策略中是否存在
		success := e.Enforce(sub, obj, act)
		if success {
			log.Println("恭喜您,權(quán)限驗(yàn)證通過(guò)")
			ctx.Next()
		} else {
			log.Printf("e.Enforce err: %s", "很遺憾,權(quán)限驗(yàn)證沒有通過(guò)")
			response.ToErrorResponse(errcode.UnauthorizedAuthFail)
			ctx.Abort()
			return
		}
	}
}

func NewRouter() *gin.Engine {
	r := gin.New()
	r.Use(gin.Logger())
	r.Use(gin.Recovery())
	casbin := v1.NewCasbin()
	test := v1.NewTest()
	apiv1 := r.Group("/api/v1")
	apiv1.Use(middleware.CasbinHandler())
	{
		// 測(cè)試路由
		apiv1.GET("/hello", test.Get)

		// 權(quán)限策略管理
		apiv1.POST("/casbin", casbin.Create)
		apiv1.POST("/casbin/list", casbin.List)
	}
	return r
}