xps-server-go/repositories/role_member_repo.go

package repositories

import (
	"fmt"
	"xorm.io/core"
	"xorm.io/xorm"
	"xps/datamodel"
    "xps/viewmodel"
)

type RoleMemberRepo struct {
	engine *xorm.Engine
}

func NewRoleMemberRepo(engine *xorm.Engine) *RoleMemberRepo {
	return &RoleMemberRepo{
		engine: engine,
	}
}

func (d *RoleMemberRepo) GetList(m map[string]interface{})([]viewmodel.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)
	
	if keywords, ok := m["keywords"]; ok {
		sqlWhere += ` AND   B.role_name like ` + "'%" + fmt.Sprintf("%s", keywords) + "%'"
	}
	
	datalist := make([]viewmodel.RoleMemberInfo, 0)
	err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("role_id DESC").Find(&datalist)
	if err != nil {
		return nil, err
	} else {
		return datalist, nil
	}
}

func (d *RoleMemberRepo) GetAccountFirstRole(ocId int64, accountId int64)(*viewmodel.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)
	
	roleMemberInfo := &viewmodel.RoleMemberInfo{}
	has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(roleMemberInfo)
	if !has || err != nil {
		return nil, err
	} else {
		return roleMemberInfo, nil
	}
}

func (d *RoleMemberRepo) Update(ocId int64, rmId int64, rm *datamodel.RoleMember) error {
	_, err := d.engine.Where("oc_id = ?", ocId).
		Where("rm_id  = ?", rmId).
		Update(rm)
	return err
}

func (d *RoleMemberRepo) Delete(ocId int64, rmId int64) error {
	_, err := d.engine.Where("oc_id = ?", ocId).
		Where("rm_id  = ?", rmId).
		Delete(new(datamodel.RoleMember))
	return err
}

func (d *RoleMemberRepo) DeleteById(ocId int64, roleId int64, accountId int64) error {
	_, err := d.engine.ID(core.PK{ocId, roleId, accountId}).Delete(new(datamodel.RoleMember))
	return err
}

func (d *RoleMemberRepo) DeleteByAccountId(ocId int64, accountId int64) error {
	_, err := d.engine.
		Where("oc_id = ?", ocId).
		Where("account_id  = ?", accountId).
		Delete(new(datamodel.RoleMember))
	return err
}

func (d *RoleMemberRepo) Create(data *datamodel.RoleMember) error {
	_, err := d.engine.Insert(data)
	return err
}