wms / sanyizhongka · Files

package com.huaheng.pc.system.user.service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.company.domain.Company;
import com.huaheng.pc.config.company.mapper.CompanyMapper;
import com.huaheng.pc.config.company.service.CompanyService;
import com.huaheng.pc.config.warehouse.domain.Warehouse;
import com.huaheng.pc.config.warehouse.service.WarehouseService;
import com.huaheng.pc.system.user.domain.*;
import com.huaheng.pc.system.user.mapper.SysUserWarehouseMapper;
import com.huaheng.pc.system.user.mapper.UserCompanyMapper;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.huaheng.common.constant.UserConstants;
import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.shiro.service.PasswordService;
import com.huaheng.pc.system.role.domain.Role;
import com.huaheng.pc.system.role.mapper.RoleMapper;
import com.huaheng.pc.system.user.mapper.UserMapper;
import com.huaheng.pc.system.user.mapper.UserRoleMapper;

import javax.annotation.Resource;

/**
 * 用户 业务层处理
 * 
 * @author huaheng
 */
@Service("UserServiceImpl")
public class UserServiceImpl implements IUserService
{
    @Resource
    private UserMapper userMapper;

    @Resource
    private RoleMapper roleMapper;

    @Resource
    private CompanyMapper companyMapper;

    @Resource
    private UserCompanyMapper userCompanyMapper;

    @Resource
    private UserRoleMapper userRoleMapper;

    @Autowired
    private PasswordService passwordService;

    @Autowired
    private CompanyService companyService;

    @Resource
    private WarehouseService warehouseService;

    @Resource
    private SysUserWarehouseMapper sysUserWarehouseMapper;

    /**
     *  登陆验证
     * @param username  用户名
     * @param password  密  码
//     * @param warehouseId  仓库id
     * @param warehouseCode  仓库编码
     * @return
     */
    @Override
    public AjaxResult login(String username, String password, String warehouseCode, Boolean rememberMe)
    {
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password))
        {
            return AjaxResult.error("用户名和密码不能为空");
        }
        if (StringUtils.isEmpty(warehouseCode))
        {
            return AjaxResult.error("请选择仓库");
        }
        UsernamePasswordToken token = new UsernamePasswordToken(username, password, rememberMe);
        Subject subject = SecurityUtils.getSubject();
        try
        {
            subject.login(token);
        }
        catch (AuthenticationException e)
        {
            String msg = "用户或密码错误";
            if (StringUtils.isNotEmpty(e.getMessage()))
            {
                msg = e.getMessage();
            }
            return AjaxResult.error(msg);
        }
        User user = ShiroUtils.getUser();
        user.setWarehouseCode(warehouseCode);
        ShiroUtils.setUser(user);
        List<Company> Companys = companyService.selectCompanyByCurrentUserId();
        user.setCompanyIdList(Companys.stream().map(X -> X.getId()).collect(Collectors.toList()));
        user.setCompanyCodeList(Companys.stream().map(X -> X.getCode()).collect(Collectors.toList()));
        user.getCompanyCodeList().add("");
        ShiroUtils.setUser(user);
        return AjaxResult.success("登陆成功");
    }


    @Override
    public AjaxResult adminLogin(String username, String password,Boolean rememberMe)
    {
        if (StringUtils.isEmpty(username) || StringUtils.isEmpty(password))
        {
            return AjaxResult.error("用户名和密码不能为空");
        }
        UsernamePasswordToken token = new UsernamePasswordToken(username, password, rememberMe);
        Subject subject = SecurityUtils.getSubject();
        try
        {
            subject.login(token);
        }
        catch (AuthenticationException e)
        {
            String msg = "用户或密码错误";
            if (StringUtils.isNotEmpty(e.getMessage()))
            {
                msg = e.getMessage();
            }
            return AjaxResult.error(msg);
        }
        User user = ShiroUtils.getUser();
//        user.setWarehouseId(warehouseId);
//        user.setWarehouseCode(warehouseCode);
//        ShiroUtils.setUser(user);
//        List<Company> Companys = companyService.selectCompanyByCurrentUserId();
//        user.setCompanyIdList(Companys.stream().map(X -> X.getId()).collect(Collectors.toList()));
//        user.setCompanyCodeList(Companys.stream().map(X -> X.getCode()).collect(Collectors.toList()));
//        user.getCompanyCodeList().add("");
        ShiroUtils.setUser(user);
        return AjaxResult.success("登陆成功");
    }

    /**
     * 根据条件分页查询用户对象
     * 
     * @param user 用户信息
     * 
     * @return 用户信息集合信息
     */
    @Override
    public List<User> selectUserList(User user)
    {
        return userMapper.selectUserList(user);
    }

    /**
     * 通过用户名查询用户
     * 
     * @param userName 用户名
     * @return 用户对象信息
     */
    @Override
    public User selectUserByLoginName(String userName)
    {
        return userMapper.selectUserByLoginName(userName);
    }

    /**
     * 通过手机号码查询用户
     * 
     * @param phoneNumber 手机号
     * @return 用户对象信息
     */
    @Override
    public User selectUserByPhoneNumber(String phoneNumber)
    {
        return userMapper.selectUserByPhoneNumber(phoneNumber);
    }

    /**
     * 通过邮箱查询用户
     * 
     * @param email 邮箱
     * @return 用户对象信息
     */
    @Override
    public User selectUserByEmail(String email)
    {
        return userMapper.selectUserByEmail(email);
    }

    /**
     * 通过用户ID查询用户
     * 
     * @param userId 用户ID
     * @return 用户对象信息
     */
    @Override
    public User selectUserById(Integer userId)
    {
        return userMapper.selectUserById(userId);
    }

    /**
     * 通过用户ID删除用户
     * 
     * @param userId 用户ID
     * @return 结果
     */
    @Override
    public int deleteUserById(Integer userId)
    {
        // 删除用户与角色关联
        userRoleMapper.deleteUserRoleByUserId(userId);
        // 删除用户与岗位表
        userCompanyMapper.deleteUserCompanyByUserId(userId);
        return userMapper.deleteUserById(userId);
    }

    /**
     * 批量删除用户信息
     * 
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteUserByIds(String ids) throws Exception
    {
        Integer[] userIds = Convert.toIntArray(ids);
        for (Integer userId : userIds)
        {
            if (User.isAdmin(userId))
            {
                throw new Exception("不允许删除超级管理员用户");
            }
        }
        return userMapper.deleteUserByIds(userIds);
    }

    /**
     * 新增保存用户信息
     * 
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int insertUser(User user)
    {
        user.randomSalt();
        user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
        user.setCreateBy(ShiroUtils.getLoginName());
        //新建用户名不能重复/
        User u = userMapper.selectUserByLoginName(user.getLoginName());
        int rows = 0;
        if(!StringUtils.isNull(u)){
            //新增用户时，如果已经有逻辑删除的则是修改
            if(u.getDeleted()){
                user.setId(u.getId());
                user.setDeleted(false);
                //修改用户
                rows = this.updateUser(user);
            }else{
                throw new ServiceException("用户名重复!");
            }
        }else{
            // 新增用户信息
            rows = userMapper.insertUser(user);
            // 新增用户货主关联
            this.insertUserCompany(user);
            // 新增用户与角色
            this.insertUserRole(user);
            // 新增用户与仓库
            this.insertUserWarehouse(user);
        }
        return rows;
    }

    /**
     * 修改保存用户信息
     * 
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUser(User user)
    {
        Integer userId = user.getId();
        user.setUpdateBy(ShiroUtils.getLoginName());
        // 删除用户与角色关联
        userRoleMapper.deleteUserRoleByUserId(userId);
        // 新增用户与角色管理
        insertUserRole(user);
        // 删除用户与货主关联
        userCompanyMapper.deleteUserCompanyByUserId(userId);
        // 新增用户与货主管理
        insertUserCompany(user);
        // 删除用户与仓库关联
        sysUserWarehouseMapper.deleteUserWarehouseByUserId(userId);
        // 新增用户与仓库管理
        insertUserWarehouse(user);

        return userMapper.updateUser(user);
    }

    /**
     * 修改用户个人详细信息
     * 
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUserInfo(User user)
    {
        return userMapper.updateUser(user);
    }

    /**
     * 修改用户密码
     * 
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int resetUserPwd(User user)
    {
        user.randomSalt();
        user.setPassword(passwordService.encryptPassword(user.getLoginName(), user.getPassword(), user.getSalt()));
        return updateUserInfo(user);
    }

    /**
     * 新增用户角色信息
     * 
     * @param user 用户对象
     */
    public void insertUserRole(User user)
    {
        // 新增用户与角色管理
        List<UserRole> list = new ArrayList<UserRole>();
        if (user.getRoleIds() != null) {
            for (Integer roleId : user.getRoleIds()) {
                UserRole ur = new UserRole();
                ur.setUserId(user.getId());
                ur.setRoleId(roleId);
                list.add(ur);
            }
            if (list.size() > 0) {
                userRoleMapper.batchUserRole(list);
            }
        }
    }


    /**
     * 新增用户仓库信息
     *
     * @param user 用户对象
     */
    public void insertUserWarehouse(User user)
    {
        // 新增用户与仓库管理
        List<SysUserWarehouse> list = new ArrayList<SysUserWarehouse>();
        if (user.getWarehouseCodeList() != null) {
            for (String warehouseCode : user.getWarehouseCodeList()) {
                SysUserWarehouse warehouse = new SysUserWarehouse();
                warehouse.setUserId(user.getId());
                warehouse.setWarehouseCode(warehouseCode);
                list.add(warehouse);
            }
            if (list.size() > 0) {
                sysUserWarehouseMapper.batchUserWarehouse(list);
            }
        }
    }

    /**
     * 新增用户货主信息
     * 
     * @param user 用户对象
     */
    public void insertUserCompany(User user)
    {
        // 新增用户与货主管理
        List<UserCompany> list = new ArrayList<UserCompany>();
        if (user.getCompanyIdList() != null)        {
            for (Integer companyId : user.getCompanyIdList())       {
                UserCompany up = new UserCompany();
                up.setUserId(user.getId());
                up.setCompanyId(companyId);
                list.add(up);
            }
            if (list.size() > 0)      {
                userCompanyMapper.batchUserCompany(list);
            }
        }
    }

    /**
     * 校验用户名称是否唯一
     * 
     * @param loginName 用户名
     * @return
     */
    @Override
    public String checkLoginNameUnique(String loginName)
    {
        int count = userMapper.checkLoginNameUnique(loginName);
        if (count > 0)
        {
            return UserConstants.USER_NAME_NOT_UNIQUE;
        }
        return UserConstants.USER_NAME_UNIQUE;
    }

    /**
     * 校验用户名称是否唯一
     *
     * @param user 用户名
     * @return
     */
    @Override
    public String checkPhoneUnique(User user)
    {
        Integer userId = StringUtils.isNull(user.getId()) ? -1 : user.getId();
        User info = userMapper.checkPhoneUnique(user.getPhoneNumber());
        if (StringUtils.isNotNull(info) && !info.getId().equals(userId))
        {
            return UserConstants.USER_PHONE_NOT_UNIQUE;
        }
        return UserConstants.USER_PHONE_UNIQUE;
    }

    /**
     * 校验email是否唯一
     *
     * @param user 用户信息
     * @return
     */
    @Override
    public String checkEmailUnique(User user)
    {
        Integer userId = StringUtils.isNull(user.getId()) ? -1 : user.getId();
        User info = userMapper.checkEmailUnique(user.getEmail());
        if (StringUtils.isNotNull(info) && !info.getId().equals(userId))
        {
            return UserConstants.USER_EMAIL_NOT_UNIQUE;
        }
        return UserConstants.USER_EMAIL_UNIQUE;
    }

    /**
     * 查询用户所属角色组
     * 
     * @param userId 用户ID
     * @return 结果
     */
    @Override
    public String selectUserRoleGroup(Integer userId)
    {
        List<Role> list = roleMapper.selectRolesByUserId(userId, ShiroUtils.getWarehouseCode());
        StringBuffer idsStr = new StringBuffer();
        for (Role role : list)
        {
            idsStr.append(role.getRoleName()).append(",");
        }
        if (StringUtils.isNotEmpty(idsStr.toString()))
        {
            return idsStr.substring(0, idsStr.length() - 1);
        }
        return idsStr.toString();
    }

    /**
     * 查询用户所属货主组
     *
     * @param userId 用户ID
     * @return 结果
     */
    @Override
    public String selectUserCompanyGroup(Integer userId)
    {
        List<Company> list = companyMapper.selectCompanyByUserId(userId, ShiroUtils.getWarehouseCode());
        StringBuffer idsStr = new StringBuffer();
        for (Company company : list)
        {
            idsStr.append(company.getName()).append(",");
        }
        if (StringUtils.isNotEmpty(idsStr.toString()))
        {
            return idsStr.substring(0, idsStr.length() - 1);
        }
        return idsStr.toString();
    }

    @Override
    public List<Map<String, Object>> getWarehouseByUserId(Integer userId){
        return  userMapper.getWarehouseByUserId(userId);
    }

    @Override
    public List<Map<String, Object>> getWarehouseByUserCode(String loginName){
        List<Map<String, Object>> list = null;
        if (User.isAdmin(loginName)) {
            QueryWrapper<Warehouse> queryWrapper = new QueryWrapper<>();
            queryWrapper.select("id","code","name");
            list = warehouseService.listMaps(queryWrapper);
        }
        else
        {
            list =  userMapper.getWarehouseByUserName(loginName);
            if (list.size()==1) {
                list=userMapper.getWarehouseByUserCode(loginName);
            }


        }
        return  list;
    }

    @Override
    public List<Map<String, Object>> getModules(Integer warehouseId, String warehouseCode, ClientType clientType)
    {
//        List<String> permList= new ArrayList();
//        List<String> moduleColumnList = new ArrayList();
//        moduleColumnList.add("id");
//        moduleColumnList.add("type");
//        moduleColumnList.add("parentId");
//        moduleColumnList.add("url");
//        moduleColumnList.add("moduleName");
//        moduleColumnList.add("modulePhto");
//        SysModules moduleCondition = new SysModules();
//        if (clientType == ClientType.PC)
//            moduleCondition.setIsMobile(false);
//        else if (clientType == ClientType.Mobile)
//            moduleCondition.setIsMobile(true);

        List<Map<String, Object>> returnList = new ArrayList();
//        List<Map<String, Object>> moduleList = sysModulesService.selectListMapByEqual(moduleColumnList, moduleCondition);
//
//        //从session取出用户信息
//        UserInfo userInfo = (UserInfo) SecurityUtils.getSubject().getPrincipal();
//        if (userInfo.getCode().equals("superAdmin"))
//        {
//            List<String> columnList = new ArrayList<>();
//            columnList.add("id");
//            SysPerm condition = new SysPerm();
//            condition.setEnable(true);
//            condition.setDeleted(false);
//            List<Map<String, Object>>  permListMap = sysPermService.selectListMapByEqual(columnList, condition);
//            for (Map<String, Object> map : permListMap) {
//                permList.add(map.get("id").toString());
//            }
//            returnList = moduleList;
//        }
//        else {
//            //不是超级管理员的话，需要验证对应的仓库权限
//            List<Map<String, Object>> permListMap = userInfoMapper.getPermByUserId(userInfo.getId(), warehouseId);
//            for (Map<String, Object> permMap : permListMap) {
//                permList.add(permMap.get("id").toString());
//            }
//            // 如果模块类型为2，且id等于权限的模块id，那么就添加到返回的模块列表
//            for (Map<String, Object> moduleMap : moduleList)   {
//                if(moduleMap.get("type").equals("2")) {
//                    for (Map<String, Object> permMap : permListMap)   {
//                        if (moduleMap.get("id").equals(permMap.get("moduleId")))   {
//                            returnList.add(moduleMap);
//                            break;
//                        }
//                    }
//                }
//            }
//            // 将模块列表和返回模块列表进行对比，把父模块也放进去
//            for (Map<String, Object> moduleMap : moduleList)
//                for (Map<String, Object> returnMap : returnList)
//                    if (moduleMap.get("id").equals(returnMap.get("parentId"))) {
//                        returnList.add(moduleMap);
//                        break;
//                    }
//        }
//        userInfo.setWarehouseId(warehouseId);
//        userInfo.setWarehouseCode(warehouseCode);
//        userInfo.setPerms(new HashSet(permList));

        return  returnList;
    }

    @Override
    public int insertupdateTime(Date date, String cPersonCode) {
        return userMapper.insertupdateTime(date,cPersonCode);
    }

    @Override
    public User selectmen(String loginName) {
        User user=userMapper.selectmen(loginName);
        return user;
    }

    @Override
    public int batchUserWarehouse(List<SysUserWarehouse> userWarehouseList) {
        return sysUserWarehouseMapper.batchUserWarehouse(userWarehouseList);
    }

    @Override
    public boolean checkWarehouseCodeAndUserName(String warehouseCode, String username) {
        return !userMapper.checkWarehouseCodeAndUserName(warehouseCode, username).isEmpty();
    }

}