acl_tousu/src/main/java/com/nokia/service/UserService.java

package com.nokia.service;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.nokia.common.R;
import com.nokia.common.exception.BizException;
import com.nokia.dao.*;
import com.nokia.pojo.User;
import com.nokia.pojo.UserFunction;
import com.nokia.pojo.UserRoleCity;
import com.nokia.vo.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpSession;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class UserService {

    private final UserDao userDao;
    private final UserRoleCityDao userRoleCityDao;
    private final UserFunctionDao userFunctionDao;
    private final AreaDao areaDao;
    private final RoleDao roleDao;
    private final OperationLogService operationLogService;

    public UserService(UserDao userDao, UserRoleCityDao userRoleCityDao, UserFunctionDao userFunctionDao,
                       AreaDao areaDao, RoleDao roleDao, OperationLogService operationLogService) {
        this.userDao = userDao;
        this.userRoleCityDao = userRoleCityDao;
        this.userFunctionDao = userFunctionDao;
        this.areaDao = areaDao;
        this.roleDao = roleDao;
        this.operationLogService = operationLogService;
    }

    public List<UserVo> baseList() {
        return userDao.baseList();
    }

    public R<TopUserVo> getTopUserByLoginName(TopUserDto dto, HttpSession session) {
        if (hasLoginName(dto.getLoginName())) {
            return R.<TopUserVo>error("用户已存在系统中").code(-3);
        }
        TopUserVo vo = userDao.getTopUserByLoginName(dto.getLoginName());
        if (vo == null) {
            return R.<TopUserVo>error("新增用户必须是TOP已由账号，用户正常使用需要TOP增加移网投诉权限。"
                    + "识别当前用户为外协用户或top用户信息未同步，需要手动输入用户信息").code(-1);
        }
        UserRoleCity role = getUserRoleCity(session);
        if (role.getCityId() != -1 && !role.getCityId().equals(vo.getCityId())) {
            return R.<TopUserVo>error("非本地市用户").code(-2);
        }
        if (vo.getCityId() != -1) {
            // 查询归属地市区县列表
            vo.setAreas(areaDao.getByParentId(vo.getCityId()).stream()
                    .map(t -> new TreeAreaVo(t.getAreaName(), t.getAreaId())).collect(Collectors.toList()));
        }
        return R.ok(vo);
    }

    public R<List<GetRoleByLoginNameVo>> getRoleByLoginName(GetRoleByLoginNameDto dto, HttpSession session) {
        User user = userDao.selectByLoginName(dto.getLoginName());
        if (user == null || user.getDeleted().equals(1)) {
            return R.error("账号不存在");
        }
        UserRoleCity role = getUserRoleCity(session);
        if (role.getCityId() != -1 && !role.getCityId().equals(user.getCityId())) {
            return R.error("非本地市用户");
        }
        List<GetRoleByLoginNameVo> vo = userDao.getRoleByLoginName(dto.getLoginName());
        return R.ok(vo);
    }

    public R<PageVo<ListUserVo>> list(ListUserDto dto, HttpSession session) {
        // 默认归属地市
        if (dto.getAreaId() == null) {
            User userinfo = getUserInfo(session);
            dto.setAreaId(userinfo.getCityId());
        }
        PageVo<ListUserVo> vo = new PageVo<>();
        Page<ListUserVo> page = new Page<>(dto.getCurrent(), dto.getPageSize());
        page.addOrder(OrderItem.asc("au.city_id"));
        List<ListUserVo> list = userDao.list(page, dto.getLoginName(), dto.getUserName(), dto.getOrg(), dto.getAreaId());
        vo.setList(list);
        vo.setTotal(page.getTotal());
        return R.ok(vo);
    }

    @Transactional(rollbackFor = Exception.class)
    public R<Object> add(AddUserDto dto, HttpSession session) {
        // 查询用户
        User user = userDao.selectByLoginName(dto.getLoginName());
        if (user != null && user.getDeleted().equals(0)) {
            return R.error("用户已存在系统中");
        }
        UserRoleCity role = getUserRoleCity(session);
        if (role.getCityId() != -1 && !role.getCityId().equals(dto.getCityId())) {
            return R.error("无法添加非本地市用户");
        }
        // 检查权限和地市
        if (!CollectionUtils.isEmpty(dto.getRoles())) {
            for (AddUserRoleDto t : dto.getRoles()) {
                // 除工单查询外其他权限地市不匹配
                if (!t.getRoleId().equals(3) && !t.getCityId().equals(dto.getCityId())) {
                    throw new BizException("权限和地市不匹配");
                }
            }
        }
        if (user == null) {
            user = new User();
        }
        user.setLoginName(dto.getLoginName());
        user.setUserName(dto.getUserName());
        user.setPhone(dto.getPhone());
        user.setEmail(dto.getEmail());
        user.setOrg(dto.getOrgName());
        user.setDeleted(0);
        user.setProvinceId(dto.getProvinceId());
        user.setCityId(dto.getCityId());
        user.setAreaId(dto.getAreaId());
        // 插入新用户
        if (user.getUserId() == null) {
            userDao.insert(user);
        } else {
            // 修改已删除用户信息
            userDao.updateById(user);
        }
        StringBuilder sb = new StringBuilder();
        sb.append("添加用户 ").append(dto.getLoginName()).append("；")
                .append("用户名：").append(dto.getUserName()).append("，")
                .append("手机号：").append(dto.getPhone()).append("，")
                .append("邮箱：").append(dto.getEmail()).append("，")
                .append("部门：").append(dto.getOrgName()).append("，")
                .append("省份：").append(dto.getProvinceName()).append("，")
                .append("地市：").append(dto.getCityName()).append("，")
                .append("区县：").append(dto.getAreaName()).append("；");
        // 添加权限
        if (!CollectionUtils.isEmpty(dto.getRoles())) {
            int userId = user.getUserId();
            List<UserRoleCity> userRoleCities = new ArrayList<>();
            Set<Integer> roleIds = new HashSet<>();
            sb.append("角色：");
            for (AddUserRoleDto t : dto.getRoles()) {
                sb.append(t.getRoleName()).append("-").append(t.getCityName()).append("，");
                UserRoleCity userRoleCity = new UserRoleCity();
                userRoleCity.setUserId(userId);
                userRoleCity.setRoleId(t.getRoleId());
                userRoleCity.setCityId(t.getCityId());
                userRoleCities.add(userRoleCity);
                roleIds.add(t.getRoleId());
            }
            userRoleCityDao.insertBatch(userRoleCities);
            Set<Integer> functionIds = roleDao.getFunctionIdsByRoleIds(roleIds);
            if (!CollectionUtils.isEmpty(functionIds)) {
                List<UserFunction> userFunctions = functionIds.stream().map(t -> new UserFunction(userId, t))
                        .collect(Collectors.toList());
                userFunctionDao.insertBatch(userFunctions);
            }
        }
        // 记录日志
        operationLogService.logOperation(session, "添加用户", sb.toString());
        return R.ok();
    }

    @Transactional(rollbackFor = Exception.class)
    public R<Object> update(UpdateUserDto dto, HttpSession session) {
        GetUserDetailVo oldUser = userDao.getUserDetail(dto.getUserId());
        UserRoleCity role = getUserRoleCity(session);
        if (role.getCityId() != -1 && !role.getCityId().equals(oldUser.getCityId())) {
            return R.error("无法修改非本地市用户");
        }
        // 检查权限和地市
        if (!CollectionUtils.isEmpty(dto.getRoles())) {
            for (AddUserRoleDto t : dto.getRoles()) {
                // 除工单查询外其他权限地市不匹配
                if (!t.getRoleId().equals(3) && !t.getCityId().equals(oldUser.getCityId())) {
                    throw new BizException("权限和地市不匹配");
                }
            }
        }
        User user = new User();
        user.setUserId(dto.getUserId());
        StringBuilder sb = new StringBuilder();
        sb.append("修改用户 ").append(oldUser.getLoginName()).append("；");
        if (StringUtils.hasText(dto.getEmail()) && !dto.getEmail().equals(oldUser.getEmail())) {
            sb.append("邮箱旧值：").append(oldUser.getEmail()).append("，")
                    .append("邮箱新值：").append(dto.getEmail()).append("；");
            user.setEmail(dto.getEmail());
        }
        if (StringUtils.hasText(dto.getPhone()) && !dto.getPhone().equals(oldUser.getPhone())) {
            sb.append("手机号旧值：").append(oldUser.getPhone()).append("，")
                    .append("手机号新值：").append(dto.getPhone()).append("；");
            user.setPhone(dto.getPhone());
        }
        if (dto.getAreaId() != null && !dto.getAreaId().equals(oldUser.getAreaId())) {
            sb.append("区县旧值：").append(oldUser.getAreaName()).append("，")
                    .append("区县新值：").append(dto.getAreaName()).append("；");
            user.setAreaId(dto.getAreaId());
        }
        // 修改用户信息
        if (StringUtils.hasText(user.getEmail()) || StringUtils.hasText(user.getPhone()) || user.getAreaId() != null) {
            userDao.updateById(user);
        }
        // 修改权限
        if (!CollectionUtils.isEmpty(dto.getRoles())) {
            int userId = oldUser.getUserId();
            List<GetUserDetailRoleVo> oldRoles = userDao.getUserDetailRole(userId);
            sb.append("角色旧值：");
            for (GetUserDetailRoleVo t : oldRoles) {
                sb.append(t.getRoleName()).append("-").append(t.getCityName()).append("，");
            }
            List<UserRoleCity> userRoleCities = new ArrayList<>();
            Set<Integer> roleIds = new HashSet<>();
            sb.append("；角色新值：");
            for (AddUserRoleDto t : dto.getRoles()) {
                sb.append(t.getRoleName()).append("-").append(t.getCityName()).append("，");
                UserRoleCity userRoleCity = new UserRoleCity();
                userRoleCity.setUserId(oldUser.getUserId());
                userRoleCity.setRoleId(t.getRoleId());
                userRoleCity.setCityId(t.getCityId());
                userRoleCities.add(userRoleCity);
                roleIds.add(t.getRoleId());
            }
            UpdateWrapper<UserRoleCity> userRoleCityUpdateWrapper = new UpdateWrapper<>();
            userRoleCityUpdateWrapper.eq("user_id", dto.getUserId());
            userRoleCityDao.delete(userRoleCityUpdateWrapper);
            userRoleCityDao.insertBatch(userRoleCities);
            Set<Integer> functionIds = roleDao.getFunctionIdsByRoleIds(roleIds);
            if (!CollectionUtils.isEmpty(functionIds)) {
                UpdateWrapper<UserFunction> userFunctionUpdateWrapper = new UpdateWrapper<>();
                userFunctionUpdateWrapper.eq("user_id", dto.getUserId());
                userFunctionDao.delete(userFunctionUpdateWrapper);
                List<UserFunction> userFunctions = functionIds.stream().map(t -> new UserFunction(userId, t))
                        .collect(Collectors.toList());
                userFunctionDao.insertBatch(userFunctions);
            }
        }
        // 记录日志
        operationLogService.logOperation(session, "修改用户", sb.toString());
        return R.ok();
    }

    @Transactional(rollbackFor = Exception.class)
    public R<Object> del(DeleteUserDto dto, HttpSession session) {
        UserRoleCity role = getUserRoleCity(session);
        if (role.getCityId() != -1 && userDao.exceptCityUser(role.getCityId(), dto.getUserIds()) != null) {
            return R.error("无法删除非本地市用户");
        }
        User user = new User();
        user.setDeleted(1);
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.in("user_id", dto.getUserIds());
        userDao.update(user, wrapper);
        deleteUserRoleCityByUserIds(dto.getUserIds());
        deleteUserFunctionByUserIds(dto.getUserIds());
        StringBuilder sb = new StringBuilder();
        List<User> users = userDao.selectBatchIds(dto.getUserIds());
        String loginNames = users.stream().map(User::getLoginName).collect(Collectors.joining("、"));
        sb.append("删除用户 ").append(loginNames);
        // 记录日志
        operationLogService.logOperation(session, "删除用户", sb.toString());
        return R.ok();
    }

    public R<GetUserDetailVo> detail(GetUserDetailDto dto) {
        GetUserDetailVo vo = userDao.getUserDetail(dto.getUserId());
        List<GetUserDetailRoleVo> roles = userDao.getUserDetailRole(dto.getUserId());
        vo.setRoles(roles);
        if (vo.getCityId() != -1) {
            // 查询归属地市区县列表
            vo.setAreas(areaDao.getByParentId(vo.getCityId()).stream()
                    .map(t -> new TreeAreaVo(t.getAreaName(), t.getAreaId())).collect(Collectors.toList()));
        }
        return R.ok(vo);
    }

    @Transactional(rollbackFor = Exception.class)
    public R<Object> copyRole(CopyRolesDto dto, HttpSession session) {
        List<Integer> cityIds = userDao.getCityIdsByUserIds(dto.getUserIds());
        if (cityIds.size() > 1) {
            return R.error("不能选择不同地市用户");
        }
        int cityId = cityIds.get(0);
        UserRoleCity role = getUserRoleCity(session);
        if (role.getCityId() != -1 && !role.getCityId().equals(cityId)) {
            return R.error("无法修改非本地市用户");
        }
        Set<Integer> roleIds = new HashSet<>();
        // 检查权限和地市
        for (AddUserRoleDto t : dto.getRoles()) {
            // 除工单查询外其他权限地市不匹配
            if (!t.getRoleId().equals(3) && !t.getCityId().equals(cityId)) {
                throw new BizException("权限和地市不匹配");
            }
            roleIds.add(t.getRoleId());
        }
        StringBuilder sb = new StringBuilder();
        List<User> users = userDao.selectBatchIds(dto.getUserIds());
        String loginNames = users.stream().map(User::getLoginName).collect(Collectors.joining("、"));
        sb.append("批量复制权限给 ").append(loginNames).append("；权限：");
        List<UserRoleCity> userRoleCities = new ArrayList<>();
        Set<UserFunction> userFunctions = new HashSet<>();
        for (AddUserRoleDto t : dto.getRoles()) {
            sb.append(t.getRoleName()).append("-").append(t.getCityName()).append("，");
            for (Integer userId : dto.getUserIds()) {
                UserRoleCity userRoleCity = new UserRoleCity();
                userRoleCity.setUserId(userId);
                userRoleCity.setRoleId(t.getRoleId());
                userRoleCity.setCityId(t.getCityId());
                userRoleCities.add(userRoleCity);
            }
        }
        Set<Integer> functionIds = roleDao.getFunctionIdsByRoleIds(roleIds);
        for (Integer t : functionIds) {
            for (Integer userId : dto.getUserIds()) {
                UserFunction userFunction = new UserFunction();
                userFunction.setUserId(userId);
                userFunction.setFunctionId(t);
                userFunctions.add(userFunction);
            }
        }
        deleteUserRoleCityByUserIds(dto.getUserIds());
        userRoleCityDao.insertBatch(userRoleCities);
        if (!CollectionUtils.isEmpty(userFunctions)) {
            deleteUserFunctionByUserIds(dto.getUserIds());
            userFunctionDao.insertBatch(new ArrayList<>(userFunctions));
        }
        // 记录日志
        operationLogService.logOperation(session, "批量复制权限", sb.toString());
        return R.ok();
    }

    /**
     * 获取用户信息
     *
     * @param session 会话
     * @return {@link User}
     */
    public User getUserInfo(HttpSession session) {
        return  (User) session.getAttribute("userinfo");
    }

    /**
     * 得到用户角色城市
     *
     * @param session 会话
     * @return {@link UserRoleCity}
     */
    public UserRoleCity getUserRoleCity(HttpSession session) {
        return (UserRoleCity) session.getAttribute("role");
    }

    /**
     * 登录名存在
     *
     * @param loginName 登录名
     * @return boolean
     */
    private boolean hasLoginName(String loginName) {
        return userDao.hasLoginName(loginName) != null;
    }

    /**
     * 通过用户id删除用户功能
     *
     * @param list 列表
     */
    private void deleteUserFunctionByUserIds(List<Integer> list) {
        UpdateWrapper<UserFunction> wrapper = new UpdateWrapper<>();
        wrapper.in("user_id", list);
        userFunctionDao.delete(wrapper);
    }

    /**
     * 通过用户id删除用户角色城市
     *
     * @param list 列表
     */
    private void deleteUserRoleCityByUserIds(List<Integer> list) {
        UpdateWrapper<UserRoleCity> wrapper = new UpdateWrapper<>();
        wrapper.in("user_id", list);
        userRoleCityDao.delete(wrapper);
    }
}