screen-manage 编辑账号接口删除分配角色功能，分配角色功能变为单独接口

kaiyu

2021-06-09 657182c7989dc77b69bb3f9adaf6c75b6466ff95

 screen-manage/src/main/java/com/moral/api/service/impl/ManageAccountServiceImpl.java

@@ -1,23 +1,45 @@
package com.moral.api.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.moral.api.entity.ManageAccount;
import com.moral.api.entity.ManageAccountRole;
import com.moral.api.entity.ManageMenu;
import com.moral.api.entity.ManageRole;
import com.moral.api.mapper.ManageAccountMapper;
import com.moral.api.mapper.ManageMenuMapper;
import com.moral.api.mapper.ManageAccountRoleMapper;
import com.moral.api.mapper.ManageRoleMapper;
import com.moral.api.pojo.dto.account.*;
import com.moral.api.pojo.redisBean.AccountInfoDTO;
import com.moral.api.pojo.dto.login.LoginDTO;
import com.moral.api.pojo.form.account.AccountDeleteForm;
import com.moral.api.pojo.form.account.AccountInsertForm;
import com.moral.api.pojo.form.account.AccountQueryForm;
import com.moral.api.pojo.form.account.AccountUpdateForm;
import com.moral.api.pojo.form.login.LoginForm;
import com.moral.api.pojo.form.login.LogoutForm;
import com.moral.api.service.ManageAccountService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.moral.util.AESUtils;
import com.moral.util.MD5Utils;
import com.moral.util.TokenUtils;
import org.springframework.beans.factory.annotation.Value;
import com.moral.api.config.mybatis.wrapper.NullFilterWrapper;
import com.moral.api.service.ManageMenuService;
import com.moral.api.util.LogUtils;
import com.moral.constant.Constants;
import com.moral.constant.ResponseCodeEnum;
import com.moral.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.function.Predicate;

/**
 * <p>
@@ -28,82 +50,394 @@
 * @since 2021-03-09
 */
@Service
@ConfigurationProperties(prefix = "log-aspect")
public class ManageAccountServiceImpl extends ServiceImpl<ManageAccountMapper, ManageAccount> implements ManageAccountService {

    @Value("${AES.KEY}")
    private String AESKey;
    @Resource
    ManageAccountMapper accountMapper;
    @Resource
    ManageRoleMapper roleMapper;
    @Resource
    ManageMenuMapper manageMenuMapper;

    @Autowired
    ManageAccountMapper manageAccountMapper;
    @Autowired
    ManageRoleMapper manageRoleMapper;
    @Autowired
    ManageMenuService manageMenuService;
    @Autowired
    ManageAccountRoleMapper manageAccountRoleMapper;
    @Autowired
    LogUtils logUtils;

    public Map<String, Object> login(Map<String, Object> paramters) {
        Map<String,Object> result = new HashMap<>();
        //接收参数
        String cyrpAccount = (String) paramters.get("account");
        String cyrpPassword = (String) paramters.get("password");
    Map<String, String> manageAccountFormMap;

    public void setManageAccountFormMap(Map<String, String> manageAccountFormMap) {
        this.manageAccountFormMap = manageAccountFormMap;
    }

    /**
     * @Description: 登陆接口
     * @Param: [loginForm]
     * @return: com.moral.api.pojo.dto.login.LoginDTO
     * @Author: 陈凯裕
     * @Date: 2021/3/30
     */
    @Override
    public LoginDTO login(LoginForm loginForm) {
        LoginDTO loginDTO = new LoginDTO();
        //取参
        String account = loginForm.getAccount();
        String AESPassword = loginForm.getPassword();
        //解密
        String account = AESUtils.decrypt(cyrpAccount, AESKey);
        String password = AESUtils.decrypt(cyrpPassword, AESKey);
        String password = AESUtils.decrypt(AESPassword);
        //查询是否存在
        QueryWrapper<ManageAccount> wrapper = new QueryWrapper<>();
        wrapper.eq("account", account);
        ManageAccount manageAccount = accountMapper.selectOne(wrapper);
        if(ObjectUtils.isEmpty(manageAccount)){
            result.put("accountId",-1);
            result.put("msg","用户不存在");
            return result;
        List<ManageAccount> manageAccounts = manageAccountMapper.selectList(wrapper);
        if (ObjectUtils.isEmpty(manageAccounts)) {
            loginDTO.setCode(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getCode());
            loginDTO.setMsg(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getMsg());
            return loginDTO;
        }
        //查询是否逻辑删除
        if(manageAccount.getIsDelete().equals("1")){
            result.put("accountId",-2);
            result.put("msg","用户已被封禁");
            return result;
        ManageAccount manageAccount = null;
        for (ManageAccount value : manageAccounts) {
            if (Constants.NOT_DELETE.equals(value.getIsDelete()))
                manageAccount = value;
        }

        if (ObjectUtils.isEmpty(manageAccount)) {
            loginDTO.setCode(ResponseCodeEnum.ACCOUNT_IS_DELETE.getCode());
            loginDTO.setMsg(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getMsg());
            return loginDTO;
        }
        //校验密码
        if(!MD5Utils.saltMD5Verify(password,manageAccount.getPassword())){
            result.put("accountId",-3);
            result.put("msg","用户名密码错误");
            return result;
        if (!MD5Utils.saltMD5Verify(password, manageAccount.getPassword())) {
            loginDTO.setCode(ResponseCodeEnum.PASSWORD_ERROR.getCode());
            loginDTO.setMsg(ResponseCodeEnum.PASSWORD_ERROR.getMsg());
            return loginDTO;
        }

        //查询角色
        List<ManageRole> roles = roleMapper.getManageRoleByAccountId(manageAccount.getId());
        if(ObjectUtils.isEmpty(roles)){
            result.put("accountId",-4);
            result.put("msg","用户尚未分配角色");
            return result;
        }
        List<ManageRole> roles = manageRoleMapper.getManageRoleByAccountId(manageAccount.getId());

        //查询菜单
        List<ManageMenu> menus = manageMenuMapper.getParentChildrenMenusByRoles(roles);
        if(ObjectUtils.isEmpty(menus)){
            result.put("accountId",-5);
            result.put("msg","用户尚未分配菜单");
            return result;
        List<ManageMenu> menus = new ArrayList<>();
        if (!ObjectUtils.isEmpty(roles)) {
            menus = manageMenuService.getParentChildrenMenusByRoles(roles);
        }

        //获取用户token,并且将基本信息存入缓存
        Map<String,Object> userInfo = new HashMap<>();//需要保存在缓存中用户的数据
        userInfo.put("accountId",manageAccount.getId());//用户Id
        userInfo.put("userName",manageAccount.getUserName());//用户名称
        userInfo.put("roles",roles);//用户角色
        userInfo.put("menus",menus);//用户菜单
        Map<String, Object> tokenResult = TokenUtils.getToken(String.valueOf(manageAccount.getId()), userInfo);
        if(tokenResult.get("code").equals(TokenUtils.error)){
            result.put("accountId",-6);
            result.put("msg","生成token错误");
            return result;
        //封装用户信息
        AccountInfoDTO accountInfoDTO = new AccountInfoDTO();
        accountInfoDTO.setAccount(manageAccount);
        accountInfoDTO.setMenus(menus);
        accountInfoDTO.setRoles(roles);

        //获取token 并且存入缓存
        String token = TokenUtils.getToken(String.valueOf(manageAccount.getId()), accountInfoDTO);

        //封装返回结果
        loginDTO.setCode(ResponseCodeEnum.SUCCESS.getCode());
        loginDTO.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
        loginDTO.setAccountInfoDTO(accountInfoDTO);
        loginDTO.setToken(token);

        //登陆插入日志
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        StringBuilder content = new StringBuilder();
        content.append(manageAccount.getUserName()).append("登陆了后台系统;");
        logUtils.saveLoginForManage(request, content.toString(), manageAccount, manageAccount.getUserName());

        return loginDTO;
    }

    /**
     * @Description: 注销
     * @Param: [parameters]
     * @return:
     * @Author: 陈凯裕
     * @Date: 2021/3/11
     */
    @Override
    public boolean logout(LogoutForm logoutForm) {
        String accountId = logoutForm.getAccountId();
        String token = logoutForm.getToken();
        TokenUtils.destoryToken(accountId, token);
        return true;
    }

    /**
     * @Description: 添加后台账号
     * @Param: [accountAddRequest]
     * @return: com.moral.api.pojo.dto.AccountDTO
     * @Author: 陈凯裕
     * @Date: 2021/3/13
     */
    @Override
    @Transactional
    public AccountDTO insertAccount(AccountInsertForm accountInsertForm) {
        AccountDTO accountDTO = new AccountDTO();
        //取参
        ManageAccount manageAccount = accountInsertForm.formConvertEntity();
        List<Integer> roleIds = accountInsertForm.getRoleIds();

        /*判断账号是否存在*/
        ManageAccount existAccount = new ManageAccount();
        existAccount.setAccount(manageAccount.getAccount());
        existAccount.setIsDelete(Constants.NOT_DELETE);
        QueryWrapper<ManageAccount> wrapper = new QueryWrapper<>();
        wrapper.setEntity(existAccount);
        ManageAccount exitAccountResult = manageAccountMapper.selectOne(wrapper);
        if (!ObjectUtils.isEmpty(exitAccountResult)) {
            accountDTO.setCode(ResponseCodeEnum.ACCOUNT_EXIST.getCode());
            accountDTO.setMsg(ResponseCodeEnum.ACCOUNT_EXIST.getMsg());
            return accountDTO;
        }

        //打包返回信息
        result.put("accountId",manageAccount.getId());//用户Id
        result.put("userName",manageAccount.getUserName());//用户名称
        result.put("roles",roles);//用户角色
        result.put("menus",menus);//用户菜单
        result.put("token",tokenResult.get("token"));
        return result;
        //插入
        manageAccountMapper.insert(manageAccount);

        //如果新建账号没有分配角色则不进行操作
        if (!ObjectUtils.isEmpty(roleIds)) {
            Integer accountId = manageAccount.getId();
            roleIds.forEach(
                    value -> {
                        ManageAccountRole manageAccountRole = new ManageAccountRole();
                        manageAccountRole.setAccountId(accountId);
                        manageAccountRole.setRoleId(value);
                        manageAccountRoleMapper.insert(manageAccountRole);
                    }
            );
        }
        //封装返回结果
        accountDTO.setCode(ResponseCodeEnum.SUCCESS.getCode());
        accountDTO.setMsg(ResponseCodeEnum.SUCCESS.getMsg());

        //操作插入日志
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        StringBuilder content = new StringBuilder();
        content.append("添加了用户：").append(manageAccount.getUserName() + ";")
                .append("account：" + manageAccount.getAccount() + ";");
        logUtils.saveOperationForManage(request, content.toString(), Constants.INSERT_OPERATE_TYPE);

        return accountDTO;
    }

    /**
     * @Description: 查询后台账号
     * @Param: [accountQueryRequest]
     * @return: com.moral.api.pojo.dto.AccountDTO
     * @Author: 陈凯裕
     * @Date: 2021/3/15
     */
    @Override
    public AccountQueryDTO queryAccount(AccountQueryForm accountQueryForm) {
        AccountQueryDTO accountQueryDTO = new AccountQueryDTO();

        //取参
        Integer page = accountQueryForm.getPage();
        Integer size = accountQueryForm.getSize();
        String userName = accountQueryForm.getUserName();
        String email = accountQueryForm.getEmail();
        String mobile = accountQueryForm.getMobile();
        String wechat = accountQueryForm.getWechat();
        String isDelete = accountQueryForm.getIsDelete();
        String order = accountQueryForm.getOrder();
        String orderType = accountQueryForm.getOrderType();
        Date createStartTime = accountQueryForm.getCreateStartTime();
        Date createEndTime = accountQueryForm.getCreateEndTime();

        //组装查询条件
        Page<ManageAccount> queryPage = new Page<>(page, size);
        NullFilterWrapper<ManageAccount> wrapper = new NullFilterWrapper<>();

        wrapper.like("user_name", userName);
        wrapper.like("email", email);
        wrapper.like("mobile", mobile);
        wrapper.like("wechat", wechat);
        wrapper.between("create_time", createStartTime, createEndTime);

        if (!ObjectUtils.isEmpty(order) && !ObjectUtils.isEmpty(orderType)) { //排序顺序条件构造
            if (orderType.equals(Constants.ORDER_ASC))
                wrapper.orderByAsc(ConvertUtils.toLine(order));
            else
                wrapper.orderByDesc(ConvertUtils.toLine(order));
        }

        if (!ObjectUtils.isEmpty(isDelete))//逻辑删除条件构造
            wrapper.eq("is_delete", isDelete);
        else
            wrapper.eq("is_delete", Constants.NOT_DELETE);

        //查询结果
        Page resultPage = manageAccountMapper.selectPage(queryPage, wrapper);
        List<ManageAccount> accounts = resultPage.getRecords();
        //过滤系统最高权限账号admin，除admin角色外无法查看
        AccountInfoDTO accountInfoDTO = (AccountInfoDTO) TokenUtils.getUserInfoByToken();
        List<ManageRole> ownRoles = accountInfoDTO.getRoles();
        boolean ownAdminRole = false;
        for (ManageRole ownRole : ownRoles) {
            String roleName = ownRole.getName();
            if ("admin".equals(roleName))
                ownAdminRole = true;
        }
        if (!ownAdminRole) {
            accounts.removeIf(new Predicate<ManageAccount>() {
                @Override
                public boolean test(ManageAccount manageAccount) {
                    if (manageAccount.getAccount().equals("admin"))
                        return true;
                    return false;
                }
            });
        }
        //查询用户对应的角色
        List<AccountDTO> accountDTOS = new ArrayList<>();
        for (ManageAccount manageAccount : accounts) {
            AccountDTO accountDTO = new AccountDTO();
            List<ManageRole> roles = manageRoleMapper.getManageRoleByAccountId(manageAccount.getId());
            accountDTO.setRoles(roles);
            accountDTO.setAccount(manageAccount);
            accountDTOS.add(accountDTO);
        }


        //封装返回结果
        accountQueryDTO.setAccountDTOS(accountDTOS);
        accountQueryDTO.setCurrent(resultPage.getCurrent());
        accountQueryDTO.setPages(resultPage.getPages());
        accountQueryDTO.setSize(resultPage.getSize());
        accountQueryDTO.setTotal(resultPage.getTotal());
        accountQueryDTO.setCode(ResponseCodeEnum.SUCCESS.getCode());
        accountQueryDTO.setMsg(ResponseCodeEnum.SUCCESS.getMsg());

        return accountQueryDTO;
    }

    /**
     * @Description: 删除后台账号
     * @Param: [accountDeleteRequest]
     * @return: com.moral.api.pojo.dto.account.AccountDeleteDTO
     * @Author: 陈凯裕
     * @Date: 2021/3/16
     */
    @Override
    @Transactional
    public AccountDTO deleteAccount(AccountDeleteForm accountDeleteForm) {
        AccountDTO accountDTO = new AccountDTO();
        //取参
        Integer accountId = accountDeleteForm.getAccountId();
        //查询要删除的账号，用于插入日志
        ManageAccount manageAccount = new ManageAccount();
        manageAccount.setIsDelete(Constants.NOT_DELETE);
        manageAccount.setId(accountId);
        QueryWrapper<ManageAccount> queryWrapper = new QueryWrapper<>();
        queryWrapper.setEntity(manageAccount);
        ManageAccount existManageAccount = manageAccountMapper.selectOne(queryWrapper);
        if (ObjectUtils.isEmpty(existManageAccount)) {
            accountDTO.setCode(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getCode());
            accountDTO.setMsg(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getMsg());
            return accountDTO;
        }
        //逻辑删除账号
        UpdateWrapper<ManageAccount> deleteAccountWrapper = new UpdateWrapper<>();
        deleteAccountWrapper.eq("id", accountId);
        deleteAccountWrapper.set("is_delete", Constants.DELETE);
        manageAccountMapper.update(null, deleteAccountWrapper);
        //逻辑删除账号相关角色
        UpdateWrapper<ManageAccountRole> deleteManageAccountRoleWrapper = new UpdateWrapper<>();
        deleteManageAccountRoleWrapper.set("is_delete", Constants.DELETE).eq("account_id", manageAccount.getId());
        manageAccountRoleMapper.update(null, deleteManageAccountRoleWrapper);
        //销毁token
        TokenUtils.destoryToken(accountId);
        //封装返回结果
        accountDTO.setCode(ResponseCodeEnum.SUCCESS.getCode());
        accountDTO.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
        //操作插入日志
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        StringBuilder content = new StringBuilder();
        content.append("删除了用户：").append(existManageAccount.getUserName() + ";")
                .append("账号:" + existManageAccount.getAccount() + ";");
        logUtils.saveOperationForManage(request, content.toString(), Constants.DELETE_OPERATE_TYPE);

        return accountDTO;
    }

    /**
     * @Description: 更新后台账号
     * @Param: [accountUpdateRequest]
     * @return: com.moral.api.pojo.dto.account.AccountUpdateDTO
     * @Author: 陈凯裕
     * @Date: 2021/3/16
     */
    @Override
    @Transactional
    public AccountDTO updateAccount(AccountUpdateForm accountUpdateForm) {
        AccountDTO accountDTO = new AccountDTO();
        //取参
        ManageAccount manageAccount = accountUpdateForm.formConvertEntity();

        //查找要更新的用户用于插入日志
        QueryWrapper<ManageAccount> oldAccountWrapper = new QueryWrapper<>();
        ManageAccount oldManageAccount = new ManageAccount();
        oldManageAccount.setId(manageAccount.getId());
        oldManageAccount.setIsDelete(Constants.NOT_DELETE);
        oldAccountWrapper.setEntity(oldManageAccount);
        oldManageAccount = manageAccountMapper.selectOne(oldAccountWrapper);
        if (ObjectUtils.isEmpty(oldManageAccount)) {
            accountDTO.setCode(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getCode());
            accountDTO.setMsg(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getMsg());
            return accountDTO;
        }

        //更新ManageAccount表
        manageAccountMapper.updateById(manageAccount);

        //操作插入日志
        insertUpdateLog(accountUpdateForm, oldManageAccount);
        //销毁token
        TokenUtils.destoryToken(manageAccount.getId());
        //封装返回结果
        accountDTO.setCode(ResponseCodeEnum.SUCCESS.getCode());
        accountDTO.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
        return accountDTO;
    }

    /**
     * @Description: 将更新操作插入日志
     * @Param: [form, newAccount, oldAccount]
     * @return: void
     * @Author: 陈凯裕
     * @Date: 2021/4/8
     */
    private void insertUpdateLog(AccountUpdateForm updateForm, ManageAccount oldAccount) {
        //操作插入日志
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        StringBuilder content = new StringBuilder();
        content.append("修改了用户：").append(oldAccount.getUserName() + ";")
                .append("账号:" + oldAccount.getAccount() + ";");
        //对象转为Map,获取对象更新前后的属性
        Map<String, Object> newParameters = JSONObject.parseObject(JSON.toJSONString(updateForm), Map.class);
        Map<String, Object> oldParameters = JSONObject.parseObject(JSON.toJSONString(oldAccount), Map.class);
        //遍历配置文件中的Map，将属性转化为汉字
        Set<String> keys = manageAccountFormMap.keySet();
        for (String key : keys) {
            String value = manageAccountFormMap.get(key);//属性对应的汉字
            if ("password".equals(key)) {//密码特殊处理，不显示在日志上
                if (!ObjectUtils.isEmpty(updateForm.getPassword())) {//判断密码是否进行了更新
                    content.append("修改了密码;");
                }
            } else {//其他属性处理
                if (newParameters.get(key) != null) {
                    String newValue = "空";
                    String oldValue = "空";
                    if (newParameters.get(key) != null && !newParameters.get(key).equals(" ")) {
                        newValue = String.valueOf(newParameters.get(key));
                    }
                    if (oldParameters.get(key) != null && !oldParameters.get(key).equals(" ")) {
                        oldValue = String.valueOf(oldParameters.get(key));
                    }
                    content.append(value + ":" + oldValue + "->" + newValue + ";");
                }
            }
        }
        logUtils.saveOperationForManage(request, content.toString(), Constants.UPDATE_OPERATE_TYPE);
    }