xps-server-go/repositories/system/app_permit_repo.go

package system

import (
	"fmt"
	"xorm.io/xorm"
	"xps/datamodels"
	"xps/viewmodels"
)

type AppPermitRepo struct {
	engine *xorm.Engine
}

func NewAppPermitRepo(engine *xorm.Engine) *AppPermitRepo {
	return &AppPermitRepo{
		engine: engine,
	}
}

func (d *AppPermitRepo) GetByList(m map[string]interface{})([]viewmodels.AppPermitInfo, error) {
	roleId    := m["roleId"].(int64)
	keywords  := m["keywords"].(string)
	appKey    := m["appKey"].(string)


	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 + "%'"
	}
	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 {
		return nil, err
	} else {
		return datalist, nil
	}
}

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
	}
}

func (d *AppPermitRepo) Create(data *datamodels.AppPermit) error {
	_, err := d.engine.Insert(data)
	return err
}

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) 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
}