fix

zhanzhiqin

2022-06-02 b64d778d7ea64b2c6517b4ec34646be50a930151

 ximon-admin/src/main/java/com/sandu/ximon/admin/service/AdminService.java

@@ -1,18 +1,309 @@
package com.sandu.ximon.admin.service;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageHelper;
import com.sandu.common.enums.RoleLevelStatus;
import com.sandu.common.execption.BusinessException;
import com.sandu.common.object.BaseConditionVO;
import com.sandu.common.service.impl.BaseServiceImpl;
import com.sandu.common.util.SpringContextHolder;
import com.sandu.ximon.admin.param.AdminParam;
import com.sandu.ximon.admin.param.PwdParam;
import com.sandu.ximon.admin.param.UserPwsParm;
import com.sandu.ximon.admin.security.SecurityUtils;
import com.sandu.ximon.admin.utils.StoreOperationRecordsUtils;
import com.sandu.ximon.dao.bo.AdminBo;
import com.sandu.ximon.dao.bo.MenuNode;
import com.sandu.ximon.dao.domain.Admin;
import com.sandu.ximon.dao.domain.AdminRoleRelation;
import com.sandu.ximon.dao.domain.Role;
import com.sandu.ximon.dao.domain.RoleMenuRelation;
import com.sandu.ximon.dao.enums.AdministratorEnums;
import com.sandu.ximon.dao.enums.OrderByEnums;
import com.sandu.ximon.dao.mapper.AdminMapper;
import lombok.AllArgsConstructor;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author chenjiantian
 * @date 2021/11/24 11:02
 */
@Service
@AllArgsConstructor
public class AdminService extends BaseServiceImpl<AdminMapper, Admin> {

    private final PasswordEncoder passwordEncoder;
    private final AdminRoleRelationService adminRoleRelationService;
    private final RoleService roleService;
    private AdminMapper adminMapper;

    public Admin findByUserName(String username) {
        return getOne(Wrappers.lambdaQuery(Admin.class).eq(Admin::getUsername, username).last("limit 1"));
    }

    @Transactional(rollbackFor = Exception.class)
    public boolean register(AdminParam param) {
        Admin admin = findByUserName(param.getUsername());
        if (admin != null) {
            throw new BusinessException("当前账号" + param.getUsername() + "已经存在");
        }
        Admin save = new Admin();
        save.setUsername(param.getUsername());
        save.setPassword(passwordEncoder.encode(param.getPassword()));
        save.setNickName(param.getNickName());
        save.setMobile(param.getMobile());
        save.setNote(param.getNote());
        if (!save(save)) {
            throw new BusinessException("注册管理员失败");
        }

        Role role = roleService.getById(param.getRoleId());
        if (role == null) {
            throw new BusinessException("角色不存在");
        }
        if (RoleLevelStatus.SUPER.getCode().equals(role.getLevel())) {
            throw new BusinessException("无法添加超级管理员");
        }

        AdminRoleRelation adminRoleRelation = new AdminRoleRelation();
        adminRoleRelation.setAdminId(save.getId());
        adminRoleRelation.setRoleId(param.getRoleId());
        if (!adminRoleRelationService.save(adminRoleRelation)) {
            throw new BusinessException("添加管理员角色失败");
        }

        /**
         * 添加管理员日志记录开始
         */
        String content = "新注册管理员：" + param.getUsername();
        StoreOperationRecordsUtils.storeOperationData(null, null, "添加管理员", content);
        /**
         * 添加管理员日志记录结束
         */
        return true;
    }

    @Transactional(rollbackFor = Exception.class)
    public boolean updateAdmin(Long adminId, AdminParam param) {
        Admin admin = getById(adminId);
        if (admin == null) {
            throw new BusinessException("找不到管理员");
        }
        List<Role> roles = roleService.listByAdminId(admin.getId());
        if (CollectionUtil.isEmpty(roles)) {
            throw new BusinessException("当前用户没有角色");
        }
        List<Integer> levels = roles.stream().map(Role::getLevel).collect(Collectors.toList());
        int min = Collections.min(levels);
        roleService.assertLevels(min);

        Admin update = new Admin();
        update.setId(adminId);
        update.setPassword(passwordEncoder.encode(param.getPassword()));
        update.setNickName(param.getNickName());
        update.setMobile(param.getMobile());
        update.setNote(param.getNote());
        if (!updateById(update)) {
            throw new BusinessException("编辑管理员失败");
        }

        adminRoleRelationService.remove(Wrappers.lambdaQuery(AdminRoleRelation.class).eq(AdminRoleRelation::getAdminId, admin.getId()));
        AdminRoleRelation adminRoleRelation = new AdminRoleRelation();
        adminRoleRelation.setAdminId(adminId);
        adminRoleRelation.setRoleId(param.getRoleId());
        if (!adminRoleRelationService.save(adminRoleRelation)) {
            throw new BusinessException("添加管理员角色失败");
        }

        return true;
    }

    /**
     * 修改当前登录用户密码
     *
     * @param param
     * @return
     */
    public boolean updateMyPassword(PwdParam param) {
        Long userId = SecurityUtils.getUserId();
        Admin admin = getById(userId);
        if (admin == null) {
            throw new BusinessException("用户不存在");
        }
        //判断旧密码与数据库是否一致
        if (passwordEncoder.matches(param.getOldPass(), admin.getPassword())) {
            //加密新密码
            admin.setId(userId);
            admin.setPassword(passwordEncoder.encode(param.getNewPass()));
            return updateById(admin);
        } else {
            throw new BusinessException("旧密码不正确，请重新确认密码！");
        }
    }

    /**
     * 修改管理员的密码
     *
     * @param param
     * @return
     */
    public boolean updateAdminPassword(UserPwsParm param) {
        Admin admin = getOne(Wrappers.lambdaQuery(Admin.class).eq(Admin::getId, param.getUserid()));
        if (admin == null) {
            throw new BusinessException("用户不存在");
        }

        //加密新密码
        admin.setPassword(passwordEncoder.encode(param.getNewPass()));
        return updateById(admin);
    }

    @Transactional(rollbackFor = Exception.class)
    public boolean deleteAdmin(Long adminId) {
        boolean flag = false;
        Admin admin = getById(adminId);
        if (admin == null) {
            throw new BusinessException("找不到管理员");
        }
        if (!AdministratorEnums.ADMIN.getCode().equals(SecurityUtils.getUserDetails().getAdministratorType())) {
            throw new BusinessException("只有超级管理员才能删除用户");
        }

        //管理员角色关系表
        AdminRoleRelationService adminRoleRelationService = SpringContextHolder.getBean(AdminRoleRelationService.class);
        //有用户必定有用户与角色的关系数据
        AdminRoleRelation one = adminRoleRelationService.getOne(Wrappers.lambdaQuery(AdminRoleRelation.class).eq(AdminRoleRelation::getAdminId, admin.getId()));
        Role role = SpringContextHolder.getBean(RoleService.class).getOne(Wrappers.lambdaQuery(Role.class).eq(Role::getId, one.getRoleId()));
        if (role == null) {
            throw new BusinessException("数据异常！");
        }

        if (role.getLevel().equals(RoleLevelStatus.SUPER.getCode())) {
            throw new BusinessException("超级管理员无法删除");
        } else {
            //删用户
            if (removeById(adminId)) {
                //删角色关系表信息
                flag = adminRoleRelationService.removeById(one);
                //删除失败回滚数据
                if (!flag) {
                    throw new BusinessException("删除管理员用户失败！");
                }
            }
        }

        /**
         * 删除管理员 日志记录开始
         */
        String content = "删除管理员：" + admin.getUsername() + "用户id：" + admin;
        StoreOperationRecordsUtils.storeOperationData(null, null, "删除管理员", content);
        /**
         * 删除管理员 日志记录结束
         */

        return flag;
    }

    /**
     * 修改超级管理员、管理员用户头像
     *
     * @param userId
     * @param IconUrl
     * @return
     */
    public boolean updateIcon(Long userId, String IconUrl) {
        Admin one = getOne(Wrappers.lambdaQuery(Admin.class).eq(Admin::getId, userId));
        if (one == null) {
            throw new BusinessException("用户不存在");
        }
        one.setIcon(IconUrl);
        return updateById(one);
    }

    public List<AdminBo> listAdmin(BaseConditionVO baseConditionVO, String keyword, Integer order, Integer seq) {
        //排序字段
        String orderByResult = OrderByEnums.ADMIN_ID.getCode();
        //正序、倒叙
        String orderBySeq = OrderByEnums.ASC.getCode();
        if (order != null) {
            switch (order) {
                case 1:
                    orderByResult = OrderByEnums.ADMIN_ID.getCode();
                    break;
                case 2:
                    orderByResult = OrderByEnums.ADMIN_CREATE_TIME.getCode();
                    break;
                case 3:
                    orderByResult = OrderByEnums.ADMIN_LOGIN_TIME.getCode();
                    break;
                default:
            }
        }
        if (seq != null) {
            switch (seq) {
                case 1:
                    orderBySeq = OrderByEnums.ASC.getCode();
                    break;
                case 2:
                    orderBySeq = OrderByEnums.DESC.getCode();
                    break;
                default:
                    break;
            }
        }
        //排序方式
        String orderBy = orderByResult + " " + orderBySeq;

        if (baseConditionVO != null) {
            PageHelper.startPage(baseConditionVO.getPageNo(), baseConditionVO.getPageSize(), orderBy);
        }

        return adminMapper.listAdmin(keyword);
    }

    /**
     * 获取用户权限列表地
     */
    public List<MenuNode> getUserPermissionList() {
        List<MenuNode> resultList;
        //判断超管与普通管理员
        if (SecurityUtils.getAdministratorIdentity().equals(AdministratorEnums.ADMIN.getCode())) {
            //参数为null时，获取所有的菜单权限
            resultList = SpringContextHolder.getBean(MenuService.class).getUserPermissionListById(null);
        } else {
            //通过用户UserID获取用户角色
            AdminRoleRelation one = SpringContextHolder.getBean(AdminRoleRelationService.class).
                    getOne(Wrappers.lambdaQuery(AdminRoleRelation.class).eq(AdminRoleRelation::getAdminId, SecurityUtils.getUserId()));
            //判空
            if (one == null) {
                throw new BusinessException("该用户未绑定角色");
            }

            //通过RoleID获取MeunId列表
            List<RoleMenuRelation> menuIdList = SpringContextHolder.getBean(RoleMenuRelationService.class)
                    .list(Wrappers.lambdaQuery(RoleMenuRelation.class).eq(RoleMenuRelation::getRoleId, one.getRoleId()));

            //判空
            if (menuIdList.isEmpty()) {
                return new ArrayList<>();
            }
            List<Long> menuIds = new ArrayList<>(menuIdList.size());
            for (RoleMenuRelation bean : menuIdList) {
                menuIds.add(bean.getMenuId());
            }

            resultList = SpringContextHolder.getBean(MenuService.class).getUserPermissionListById(menuIds);

        }

        return resultList;
    }
}