xps-server-g5/pkg/system/repository/group_member_position_repo.go

package repository

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

type GroupMemberPositionRepo struct {
    engine *xorm.Engine
}

func NewGroupMemberPositionRepo(engine *xorm.Engine) *GroupMemberPositionRepo {
    return &GroupMemberPositionRepo{
        engine: engine,
    }
}

func (d *GroupMemberPositionRepo) GetFirstPositionByGroupIdAndAccountId(ocId, groupId, accountId int64) (*viewmodel.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  `
    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)

    roleMemberPositionInfo := &viewmodel.GroupMemberPositionInfo{}
    has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Limit(1).Get(roleMemberPositionInfo)
    if !has || err != nil {
        return nil, err
    }
    return roleMemberPositionInfo, nil
}

func (d *GroupMemberPositionRepo) GetByAccountId(ocId int64, accountId int64) (*datamodel.GroupMemberPosition, error) {
    data := &datamodel.GroupMemberPosition{OcId: ocId, AccountId: accountId}
    ok, err := d.engine.Get(data)
    if !ok && err != nil {
        return nil, err
    } else {
        return data, nil
    }
}

func (d *GroupMemberPositionRepo) GetList(m map[string]interface{}) ([]viewmodel.GroupMemberPositionInfo, error) {
    sqlSelect := `    SELECT      A.gmp_id,
                                    A.oc_id,
                                    A.group_id,
                                    B.group_name,
                                    A.account_id,
                                    D.account_name,
                                    D.account_real_name,
                                    A.position_id,
                                    C.position_name `
    sqlFrom := `    FROM        s_group_member_position A
                        LEFT JOIN   s_group                 B ON (A.oc_id = B.oc_id AND A.group_id     = B.group_id)
                        LEFT JOIN   s_position              C ON (A.oc_id = C.oc_id AND A.position_id  = C.position_id)
                        LEFT JOIN   account               D ON (A.oc_id = D.oc_id AND A.account_id   = D.account_id) `
    sqlWhere := `   WHERE A.deleted_flag = 0 `
    if ocId, ok := m["ocId"]; ok {
        sqlWhere += ` AND A.oc_id = ` + fmt.Sprintf("%d", ocId)
    }
    if groupId, ok := m["groupId"]; ok {
        sqlWhere += ` AND A.group_id = ` + fmt.Sprintf("%d", groupId)
    }
    if accountId, ok := m["accountId"]; ok {
        sqlWhere += ` AND A.account_id = ` + fmt.Sprintf("%d", accountId)
    }
    if positionId, ok := m["positionId"]; ok {
        sqlWhere += ` AND A.position_id = ` + fmt.Sprintf("%d", positionId)
    }
    if keywords, ok := m["keywords"]; ok {
        sqlWhere += ` AND A.group_cat_title like '%` + fmt.Sprintf("%s", keywords) + `%'`
    }
    nodeLeft, ok1 := m["nodeLeft"]
    nodeRight, ok2 := m["nodeRight"]
    if ok1 && ok2 {
        sqlWhere += ` AND B.node_left  >= ` + fmt.Sprintf("%d", nodeLeft)
        sqlWhere += ` AND B.node_right <= ` + fmt.Sprintf("%d", nodeRight)
    }

    datalist := make([]viewmodel.GroupMemberPositionInfo, 0)
    err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).OrderBy("group_id DESC").Find(&datalist)
    if err != nil {
        return nil, err
    } else {
        return datalist, nil
    }
}

func (d *GroupMemberPositionRepo) GetById(ocId int64, gmpid int64) (*viewmodel.GroupMemberPositionInfo, error) {
    sqlSelect := `    SELECT      A.gmp_id,
                                    A.oc_id,
                                    A.group_id,
                                    B.group_name,
                                    A.account_id,
                                    D.account_name,
                                    D.account_real_name,
                                    A.position_id,
                                    C.position_name `
    sqlFrom := `    FROM        s_group_member_position A
                        LEFT JOIN   s_group                 B ON (A.oc_id = B.oc_id AND A.group_id     = B.group_id)
                        LEFT JOIN   s_position              C ON (A.oc_id = C.oc_id AND A.position_id  = C.position_id)
                        LEFT JOIN   account               D ON (A.oc_id = D.oc_id AND A.account_id   = D.account_id) `
    sqlWhere := `   WHERE A.deleted_flag = 0 `

    data := &viewmodel.GroupMemberPositionInfo{}
    has, err := d.engine.SQL(sqlSelect + sqlFrom + sqlWhere).Get(data)
    if !has || err != nil {
        return nil, err
    } else {
        return data, nil
    }
}

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

func (d *GroupMemberPositionRepo) Update(ocId int64, gmpId int64, data *datamodel.GroupMemberPosition) error {
    _, err := d.engine.ID(core.PK{ocId, gmpId}).Update(data)
    return err
}

func (d *GroupMemberPositionRepo) Delete(ocId int64, gmpId int64) error {
    _, err := d.engine.ID(core.PK{ocId, gmpId}).
        Delete(new(datamodel.GroupMemberPosition))
    return err
}

func (d *GroupMemberPositionRepo) DeleteByGroupId(ocId int64, groupId int64) error {
    _, err := d.engine.Where("oc_id = ?", ocId).
        Where("group_id = ?", groupId).
        Delete(new(datamodel.GroupMemberPosition))
    return err
}

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