优化虚拟卡占用逻辑，占用时写入取水口编号，解除占用时清空虚拟卡编号；工单使用的4个表

zhubaomin

2024-11-06 0be32a3805e1430b82b5bded8bd23946e274fa84

 pipIrr-platform/pipIrr-web/pipIrr-web-base/src/main/java/com/dy/pipIrrBase/role/RoleSv.java

@@ -1,49 +1,116 @@
package com.dy.pipIrrBase.role;

import com.alibaba.fastjson2.JSONArray;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrBase.user.QueryVo;
import com.dy.pipIrrGlobal.daoBa.BaRoleMapper;
import com.dy.pipIrrGlobal.daoBa.BaRolePrivilegeMapper;
import com.dy.pipIrrGlobal.daoBa.BaRolePermissionsMapper;
import com.dy.pipIrrGlobal.pojoBa.BaRole;
import com.dy.pipIrrGlobal.pojoBa.BaRolePrivilege;
import com.dy.pipIrrGlobal.pojoBa.BaRolePermissions;
import com.dy.pipIrrGlobal.voBa.VoRole;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.common.utils.PojoUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * @author ZhuBaoMin
 * @date 2024-01-10 11:00
 * @LastEditTime 2024-01-10 11:00
 * @Description
 */

@Slf4j
@Service
public class RoleSv {

    private BaRoleMapper dao;
    private BaRolePrivilegeMapper rolePrivDao ;
    //private BaRoleMapper baRoleMapper;
    //private BaRolePrivilegeMapper rolePrivDao ;

    //@Autowired
    //private void setDao(BaRoleMapper dao){
    //    this.dao = dao;
    //}

    //@Autowired
    //private void setRolePrivDao(BaRolePrivilegeMapper dao){
    //    this.rolePrivDao = dao;
    //}
    @Autowired
    private BaRoleMapper baRoleMapper;

    @Autowired
    private void setDao(BaRoleMapper dao){
        this.dao = dao;
    private BaRolePermissionsMapper baRolePermissionsMapper;

    /**
     * 根据指定条件（角色编号、角色名称）获取角色列表
     * 当获取一条记录时，传入roleId即可
     * @param queryVo
     * @return
     */
    public QueryResultVo<List<VoRole>> getRoles(QueryVo queryVo) {
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(queryVo);

        Long itemTotal = baRolePermissionsMapper.getRecordCount(params);

        QueryResultVo<List<VoRole>> rsVo = new QueryResultVo<>() ;
        //Integer pageCurr = 0;
        //Integer pageSize = 10000;
        //rsVo.pageCurr = 1;
        //rsVo.pageSize = 10000;
        //if(queryVo.pageSize != null && queryVo.pageCurr != null) {
        //    rsVo.pageSize = queryVo.pageSize ;
        //    rsVo.pageCurr = queryVo.pageCurr;
        //    pageSize = queryVo.pageSize ;
        //    pageCurr = (Integer.parseInt(params.get("pageCurr").toString()) - 1) * Integer.parseInt(params.get("pageSize").toString());
        //}
        //params.put("pageCurr", pageCurr);
        //params.put("pageSize", pageSize);
        rsVo.pageSize = queryVo.pageSize ;
        rsVo.pageCurr = queryVo.pageCurr ;

        rsVo.calculateAndSet(itemTotal, params);
        //rsVo.obj = baRoleMapper.getRoles(params);

        /**
         * 获取角色列表，把汗角色权限ID
         * 遍历角色列表并取出角色对象中的perId
         * 根据perId获取权限对象，并将对象添加到角色对象中
         */
        List<VoRole> list_Roles = Optional.ofNullable(baRolePermissionsMapper.getRoles(params)).orElse(new ArrayList<>());
        if(list_Roles.size() > 0) {
            for(int i = 0; i < list_Roles.size(); i++) {
                VoRole voRole = list_Roles.get(i);
                Long perId = voRole.getPerId();
                BaRolePermissions baRolePermissions = baRolePermissionsMapper.selectByPrimaryKey(perId);
                JSONArray array_permission = JSONArray.parseArray("[]");
                if(baRolePermissions != null) {
                    array_permission = baRolePermissions.getPermissions();
                }
                voRole.setPermissions(array_permission);
            }
        }
        rsVo.obj = list_Roles;
        return rsVo ;
    }

    @Autowired
    private void setRolePrivDao(BaRolePrivilegeMapper dao){
        this.rolePrivDao = dao;
    public BaRolePermissions getRolePermissionsById(Long id) {
        return baRolePermissionsMapper.selectByPrimaryKey(id);
    }


    /**
     * 得到所有角色
     * @return 所有角色集合
     */
    @SuppressWarnings("unchecked")
    public QueryResultVo<List<BaRole>> selectAll(QueryVo vo){
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(vo) ;
        QueryResultVo<List<BaRole>> rsVo = new QueryResultVo<>() ;
        rsVo.obj = this.dao.selectAll(params) ;
        return rsVo ;
    }
    //public QueryResultVo<List<BaRole>> selectAll(){
    //    QueryResultVo<List<BaRole>> rsVo = new QueryResultVo<>() ;
    //    rsVo.obj = this.dao.selectAll() ;
    //    return rsVo ;
    //}


    /**
@@ -51,48 +118,65 @@
     * @param id 角色ID
     * @return 角色实体
     */
    public BaRole selectById(Long id){
        return this.dao.selectById(id) ;
    }
    //public BaRole selectById(Long id){
    //    return this.dao.selectById(id) ;
    //}


    /**
     * 得到一个用户
     * @param vo 查询条件值对象
     //* @param vo 查询条件值对象
     * @return 用户实体
     */
    @SuppressWarnings("unchecked")
    public QueryResultVo<List<BaRole>> selectSome(QueryVo vo){
        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(vo) ;
        Long itemTotal = this.dao.selectTotal(params) ;
    //public QueryResultVo<List<BaRole>> selectSome(QueryVo vo){
    //    Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(vo) ;
    //    Long itemTotal = this.dao.selectTotal(params) ;
    //
    //    QueryResultVo<List<BaRole>> rsVo = new QueryResultVo<>() ;
    //    rsVo.pageSize = vo.pageSize ;
    //    rsVo.pageCurr = vo.pageCurr ;
    //    rsVo.calculateAndSet(itemTotal, params);
    //    rsVo.obj = this.dao.selectSome(params) ;
    //
    //    return rsVo ;
    //}

        QueryResultVo<List<BaRole>> rsVo = new QueryResultVo<>() ;
        rsVo.pageSize = vo.pageSize ;
        rsVo.pageCurr = vo.pageCurr ;
        rsVo.calculateAndSet(itemTotal, params);
        rsVo.obj = this.dao.selectSome(params) ;

        return rsVo ;
    /**
     * 添加角色
     * @param po 角色实体
     * @return 角色ID
     */
    public Long addRole(BaRole po){
        baRoleMapper.insert(po);
        return po.getId();
    }

    /**
     * 保存实体
     * @param po 实体
     * @return 影响记录数量
     * 根据角色名称查询记录数量，添加角色前判断是否重名
     * @param roleName 角色名称
     * @return 符合条件记录数
     */
    @Transactional
    public int save(BaRole po){
        return this.dao.insert(po) ;
    public Integer getRecordCountByName(String roleName) {
        return baRoleMapper.getRecordCountByName(roleName);
    }

    /**
     * 保存修改实体
     * @param po 实体
     * @return 影响记录数量
     * 修改角色
     * @param record
     * @return
     */
    @Transactional
    public int update(BaRole po){
        return this.dao.updateByPrimaryKeySelective(po) ;
    public int updateRole(BaRole record) {
        return baRoleMapper.updateByPrimaryKeySelective(record);
    }

    /**
     * 根据roleId逻辑删除角色对象
     * @param roleId 角色编号
     * @return
     */
    public Integer deleteRoleById(Long roleId) {
        return baRoleMapper.deleteRoleById(roleId);
    }

    /**
@@ -101,32 +185,51 @@
     * @param priviIds 选择的权限id集合
     * @return 插入角色与权限关联记录数量
     */
    public int setRoles(Long roleId, Long[] priviIds){
        this.rolePrivDao.deleteByRoleId(roleId) ;
        int count = 0 ;
        if(priviIds != null && priviIds.length > 0){
            for(Long privId : priviIds){
                count += this.rolePrivDao.insertSelective(new BaRolePrivilege(roleId, privId)) ;
            }
        }
        return count ;
    }
    //public int setRoles(Long roleId, Long[] priviIds){
    //    this.rolePrivDao.deleteByRoleId(roleId) ;
    //    int count = 0 ;
    //    if(priviIds != null && priviIds.length > 0){
    //        for(Long privId : priviIds){
    //            count += this.rolePrivDao.insertSelective(new BaRolePrivilege(roleId, privId)) ;
    //        }
    //    }
    //    return count ;
    //}

    /**
     * 保存修改实体
     * @param id 实体ID
     * @return 影响记录数量
     */
    @Transactional
    public int delete(Long id){
        //int count = this.dao.deleteLogicById(id) ;
        //逻辑删除，所以不实际删除其关联的权限
        //if(count > 0){
        //    this.rolePrivDao.deleteByRoleId(id) ;
        //}
        //return count ;
        return this.dao.deleteLogicById(id) ;
    //@Transactional
    //public int delete(Long id){
    //    //int count = this.dao.deleteLogicById(id) ;
    //    //逻辑删除，所以不实际删除其关联的权限
    //    //if(count > 0){
    //    //    this.rolePrivDao.deleteByRoleId(id) ;
    //    //}
    //    //return count ;
    //    return this.dao.deleteLogicById(id) ;
    //}

    /**
     * 添加授权记录
     * @Auth 朱宝民
     * @param po
     * @return
     */
    public Integer addPermissions(BaRolePermissions po) {
        return baRolePermissionsMapper.insert(po);
    }

    /**
     * 依据角色编号删除授权记录
     * @Auth 朱宝民
     * @param roleid
     * @return
     */
    public Integer delPermissionsByRoleId(Long roleid) {
        return baRolePermissionsMapper.delPermissionsByRoleId(roleid);
    }

}