From f342a0d88b2a7168f794d0cf545d16a3138acb6d Mon Sep 17 00:00:00 2001
From: wuqiping <wuqiping@qq.com>
Date: Wed, 09 Jun 2021 15:55:33 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/dev' into dev

---
 screen-manage/src/main/java/com/moral/api/service/impl/ManageAccountServiceImpl.java |  474 ++++++++++++++++++++++++++++++++++++++++------------------
 1 files changed, 325 insertions(+), 149 deletions(-)

diff --git a/screen-manage/src/main/java/com/moral/api/service/impl/ManageAccountServiceImpl.java b/screen-manage/src/main/java/com/moral/api/service/impl/ManageAccountServiceImpl.java
index 389c024..dcc9e60 100644
--- a/screen-manage/src/main/java/com/moral/api/service/impl/ManageAccountServiceImpl.java
+++ b/screen-manage/src/main/java/com/moral/api/service/impl/ManageAccountServiceImpl.java
@@ -1,34 +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.ManageAccountRoleMapper;
-import com.moral.api.mapper.ManageMenuMapper;
 import com.moral.api.mapper.ManageRoleMapper;
-import com.moral.api.pojo.dto.AccountDTO;
-import com.moral.api.pojo.dto.AccountInfoDTO;
-import com.moral.api.pojo.dto.LoginDTO;
-import com.moral.api.pojo.request.AccountAddRequest;
-import com.moral.api.pojo.request.LoginRequest;
-import com.moral.api.pojo.request.LogoutRequest;
+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.regex.Matcher;
-import java.util.regex.Pattern;
+import java.util.function.Predicate;
 
 /**
  * <p>
@@ -39,70 +50,66 @@
  * @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
+
+    @Autowired
     ManageAccountMapper manageAccountMapper;
-    @Resource
+    @Autowired
     ManageRoleMapper manageRoleMapper;
-    @Resource
-    ManageMenuMapper manageMenuMapper;
-    @Resource
+    @Autowired
+    ManageMenuService manageMenuService;
+    @Autowired
     ManageAccountRoleMapper manageAccountRoleMapper;
+    @Autowired
+    LogUtils logUtils;
 
-    public final static String specialCharRegEx =  "[ _`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~���@#���%������&*������������+|{}������������������������������������]|\n|\r|\t";
+    Map<String, String> manageAccountFormMap;
 
-    public final static String mobileRegEx = "^((13[0-9])|(14[0,1,4-9])|(15[0-3,5-9])|(16[2,5,6,7])|(17[0-8])|(18[0-9])|(19[0-3,5-9]))\\d{8}$";
+    public void setManageAccountFormMap(Map<String, String> manageAccountFormMap) {
+        this.manageAccountFormMap = manageAccountFormMap;
+    }
 
-    public final static String emailRegEx = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
     /**
-     * @Description: ������
-     * @Param: [parameters]
-     * @return: java.util.Map<java.lang.String   ,   java.lang.Object>
+     * @Description: ������������
+     * @Param: [loginForm]
+     * @return: com.moral.api.pojo.dto.login.LoginDTO
      * @Author: ���������
-     * @Date: 2021/3/11
+     * @Date: 2021/3/30
      */
     @Override
-    public LoginDTO login(LoginRequest loginRequest) {
+    public LoginDTO login(LoginForm loginForm) {
         LoginDTO loginDTO = new LoginDTO();
         //������
-        String AESAccount = loginRequest.getAccount();
-        String AESPassword = loginRequest.getPassword();
+        String account = loginForm.getAccount();
+        String AESPassword = loginForm.getPassword();
         //������
-        String account = AESUtils.decrypt(AESAccount, AESKey);
-        String password = AESUtils.decrypt(AESPassword, AESKey);
+        String password = AESUtils.decrypt(AESPassword);
         //������������������
         QueryWrapper<ManageAccount> wrapper = new QueryWrapper<>();
         wrapper.eq("account", account);
+        wrapper.eq("is_delete",Constants.NOT_DELETE);
         ManageAccount manageAccount = manageAccountMapper.selectOne(wrapper);
         if (ObjectUtils.isEmpty(manageAccount)) {
-            loginDTO.setCode(LoginDTO.NOT_EXIST);
-            return loginDTO;
-        }
-        //������������������������
-        if (manageAccount.getIsDelete().equals("1")) {
-            loginDTO.setCode(LoginDTO.IS_DELETE);
+            loginDTO.setCode(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getCode());
+            loginDTO.setMsg(ResponseCodeEnum.ACCOUNT_NOT_EXIST.getMsg());
             return loginDTO;
         }
         //������������
         if (!MD5Utils.saltMD5Verify(password, manageAccount.getPassword())) {
-            loginDTO.setCode(LoginDTO.PASSWORD_ERROR);
+            loginDTO.setCode(ResponseCodeEnum.PASSWORD_ERROR.getCode());
+            loginDTO.setMsg(ResponseCodeEnum.PASSWORD_ERROR.getMsg());
             return loginDTO;
         }
 
         //������������
         List<ManageRole> roles = manageRoleMapper.getManageRoleByAccountId(manageAccount.getId());
-        if (ObjectUtils.isEmpty(roles)) {//������������������������������
-            loginDTO.setCode(LoginDTO.ROLE_EMPTY);
-            return loginDTO;
-        }
+
         //������������
-        List<ManageMenu> menus = manageMenuMapper.getParentChildrenMenusByRoles(roles);
-        if (ObjectUtils.isEmpty(menus)) {//������������������������������
-            loginDTO.setCode(LoginDTO.MENU_EMPTY);
-            return loginDTO;
+        List<ManageMenu> menus = new ArrayList<>();
+        if (!ObjectUtils.isEmpty(roles)) {
+            menus = manageMenuService.getParentChildrenMenusByRoles(roles);
         }
 
         //������������������
@@ -115,9 +122,15 @@
         String token = TokenUtils.getToken(String.valueOf(manageAccount.getId()), accountInfoDTO);
 
         //������������������
-        loginDTO.setCode(LoginDTO.SUCCESS);
-        loginDTO.setAccountInfoDTO(accountInfoDTO);
+        loginDTO.setCode(ResponseCodeEnum.SUCCESS.getCode());
+        loginDTO.setMsg(ResponseCodeEnum.SUCCESS.getMsg());
         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;
     }
@@ -125,132 +138,295 @@
     /**
      * @Description: ������
      * @Param: [parameters]
-     * @return: java.util.Map<java.lang.String   ,   java.lang.Object>
+     * @return:
      * @Author: ���������
      * @Date: 2021/3/11
      */
     @Override
-    public boolean logout(LogoutRequest logoutRequest) {
-        String accountId = logoutRequest.getAccountId();
-        String token  = logoutRequest.getToken();
-        TokenUtils.destoryToken(accountId,token);
+    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
-            */
+     * @Description: ������������������
+     * @Param: [accountAddRequest]
+     * @return: com.moral.api.pojo.dto.AccountDTO
+     * @Author: ���������
+     * @Date: 2021/3/13
+     */
     @Override
     @Transactional
-    public AccountDTO addAccount(AccountAddRequest accountAddRequest) {
+    public AccountDTO insertAccount(AccountInsertForm accountInsertForm) {
         AccountDTO accountDTO = new AccountDTO();
         //������
-        String AESAccount = accountAddRequest.getAccount();
-        String AESPassword = accountAddRequest.getPassword();
-        String account = AESUtils.decrypt(AESAccount,AESKey);
-        String password = MD5Utils.saltMD5(AESUtils.decrypt(AESPassword,AESKey));
-        String userName = accountAddRequest.getUserName();
-        String email = accountAddRequest.getEmail();
-        String mobile = accountAddRequest.getMobile();
-        String wechat = accountAddRequest.getWechat();
-        String isDelete = accountAddRequest.getIsDelete();
-        List<String> roleIdsStr = accountAddRequest.getRoleIds();
-        //������������������������������������
-        /*���������������������������������������*/
-        if(isSpecialChar(account)){
-            accountDTO.setCode(AccountDTO.ACCOUNT_EXIST_SPECIAL_CHAR);
-            return accountDTO;
-        }
-        /*������������������������������������*/
-        if(isSpecialChar(password)){
-            accountDTO.setCode(AccountDTO.PASSWORD_EXIST_SPECIAL_CHAR);
-            return accountDTO;
-        }
-        /*���������������������������������*/
-        if(account.length()>=20){
-            accountDTO.setCode(AccountDTO.ACCOUNT_LENGTH_INVALID);
-            return accountDTO;
-        }
-        /*������������������������������*/
-        if(AESUtils.decrypt(AESPassword,AESKey).length()>=20){
-            accountDTO.setCode(AccountDTO.PASSWORD_LENGTH_INVALID);
-            return accountDTO;
-        }
-        /*���������������������������������*/
-        if(!isValidMobile(mobile)){
-            accountDTO.setCode(AccountDTO.MOBILE_INVALID);
-            return accountDTO;
-        }
-        /*������������������������������*/
-        if(!isValidEmail(email)){
-            accountDTO.setCode(AccountDTO.EMAIL_INVALID);
-            return accountDTO;
-        }
-        /*���������������������������*/
-        ManageAccount exitAccount = new ManageAccount();
-        exitAccount.setAccount(account);
+        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(exitAccount);
-        List<ManageAccount> exitAccounts = manageAccountMapper.selectList(wrapper);
-        if(!ObjectUtils.isEmpty(exitAccounts)){
-            accountDTO.setCode(AccountDTO.ACCOUNT_EXIST);
+        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;
         }
 
-        //String to Integer
-        List<Integer> roleIds = new ArrayList<>();
-        roleIdsStr.forEach(str->roleIds.add(Integer.parseInt(str)));
-
-        //������account
-        ManageAccount manageAccount = new ManageAccount();
-        manageAccount.setAccount(account);
-        manageAccount.setPassword(password);
-        manageAccount.setUserName(userName);
-        manageAccount.setEmail(email);
-        manageAccount.setMobile(mobile);
-        manageAccount.setWechat(wechat);
-        manageAccount.setIsDelete(isDelete);
+        //������
         manageAccountMapper.insert(manageAccount);
-        //������account_role
-        Integer accountId = manageAccount.getId();
-        roleIdsStr.forEach(
-                value->{
-                    ManageAccountRole manageAccountRole = new ManageAccountRole();
-                    manageAccountRole.setAccountId(accountId);
-                    manageAccountRole.setRoleId(Integer.parseInt(value));
-                    manageAccountRoleMapper.insert(manageAccountRole);
-                }
-        );
+
+        //������������������������������������������������������
+        if (!ObjectUtils.isEmpty(roleIds)) {
+            Integer accountId = manageAccount.getId();
+            roleIds.forEach(
+                    value -> {
+                        ManageAccountRole manageAccountRole = new ManageAccountRole();
+                        manageAccountRole.setAccountId(accountId);
+                        manageAccountRole.setRoleId(value);
+                        manageAccountRoleMapper.insert(manageAccountRole);
+                    }
+            );
+        }
         //������������������
-        List<ManageRole> roles = manageRoleMapper.selectBatchIds(roleIds);
-        accountDTO.setAccount(manageAccount);
-        accountDTO.setRoles(roles);
-        accountDTO.setCode(AccountDTO.SUCCESS);
+        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;
     }
 
-    private static boolean isSpecialChar(String str){
-        Pattern pattern = Pattern.compile(specialCharRegEx);
-        Matcher matcher = pattern.matcher(str);
-        return matcher.find();
+    /**
+     * @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.getUserInfo();
+        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;
     }
 
-    private static boolean isValidMobile(String str){
-        Pattern pattern = Pattern.compile(mobileRegEx);
-        Matcher matcher = pattern.matcher(str);
-        return matcher.find();
+    /**
+     * @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;
     }
 
-    private static boolean isValidEmail(String str){
-        Pattern pattern = Pattern.compile(emailRegEx);
-        Matcher matcher = pattern.matcher(str);
-        return matcher.find();
+    /**
+     * @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);
+    }
 
 
 }

--
Gitblit v1.8.0