sso-parent-new/sso-server/src/main/java/com/uas/sso/controller/UserManagerController.java

package com.uas.sso.controller;

import com.uas.sso.exception.AccountException;
import com.uas.sso.core.Const;
import com.uas.sso.entity.*;
import com.uas.sso.service.ApplyUserSpaceService;
import com.uas.sso.service.UserService;
import com.uas.sso.service.UserspaceService;
import com.uas.sso.util.encry.Md5Utils;
import org.apache.commons.codec.binary.Base64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.ModelMap;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;


/**
 * 用户信息管理controller
 *
 * @author wangmh
 * @date 2018/1/2
 */
@RestController
@RequestMapping("/api/user")
public class UserManagerController extends BaseController {

    @Autowired
    private UserService userService;

    @Autowired
    private UserspaceService userspaceService;

    @Autowired
    private ApplyUserSpaceService applyUserSpaceService;

    private static final Logger LOGGER = LoggerFactory.getLogger(UserManagerController.class);

    /**
     * 用户信息新增、修改
     *
     * @param userView
     * @return
     */
    @RequestMapping(method = RequestMethod.POST)
    @ResponseBody
    public ModelMap apiSave(@RequestBody User userView, String appId) {
        if (userView == null || appId == null) {
            throw new AccountException("参数错误");
        }
        User user = new User();
        if (userView.getUserUU() != null) {
            user = userService.findOne(userView.getUserUU());
        }

        if (user == null && userView.getMobile() != null) {
            user = userService.findByMobile(userView.getMobile());
        }
        LOGGER.info("开通用户: UserMobile{}", userView.getMobile());
        if (user == null) {
            user = userService.register(userView, appId);
        } else {
            user = userService.updateUser(userView.getUserUU(), userView);
        }

        return success(user);
    }

    /**
     * 校验手机号是否被注册
     *
     * @param mobile 手机号
     * @return
     */
    @RequestMapping(value = "/checkMobile", method = RequestMethod.GET)
    public ModelMap checkMobile(String mobile) {
        return new ModelMap("hasRegister", userService.mobileHasRegistered(mobile));
    }

    /**
     * 校验手机号是否被注册
     *
     * @param email 手机号
     * @return
     */
    @RequestMapping(value = "/checkEmail", method = RequestMethod.GET)
    public ModelMap checkEmail(String email) {
        return new ModelMap("hasRegister", userService.emailHasRegistered(email));
    }

    /**
     * 校验真实姓名是否被认证
     *
     * @param realName 真实姓名
     * @return
     * @author wangmh
     * @date 2018/1/11 15:05
     */
    @RequestMapping(value = "/realName/valid", method = RequestMethod.GET)
    public ModelMap realNameIsValid(String realName) {
        return success(new ModelMap("isValid", userService.realNameIsValid(realName)));
    }

    /**
     * 校验身份证号是否被认证
     *
     * @param idCard 身份证号
     * @return {"isValid", b} b为true说明已认证
     * @author wangmh
     * @date 2018/1/11 15:06
     */
    @RequestMapping(value = "/idCard/valid", method = RequestMethod.GET)
    public ModelMap idCardIsValid(String idCard) {
        return success(new ModelMap("isValid", userService.idCardIsValid(idCard)));
    }

    /**
     * 根据企业uu号查询企业下所有用户信息
     *
     * @param page    当前页数
     * @param size    每页大小
     * @param spaceUU 企业uu号
     * @return org.springframework.data.domain.Page, content 为用户信息集合
     * @author wangmh
     * @date 2018/1/26 14:43
     */
    @RequestMapping(value = "/find/member", method = RequestMethod.GET)
    public ModelMap findMember(@RequestParam(defaultValue = "1") int page, @RequestParam(defaultValue = "20") int size, Long spaceUU) {
        return success(userService.findMemberBySpaceUU(page, size, spaceUU));
    }

    /**
     * 根据用户uu号查询用户信息
     *
     * @param userUU 用户uu号
     * @return 用户信息
     * @author wangmh
     * @date 2018/1/26 14:46
     */
    @RequestMapping(value = "/info", method = RequestMethod.GET)
    public ModelMap findOne(@RequestParam Long userUU) {
        return success(userService.findOne(userUU));
    }

    /**
     * 根据用户手机号查询用户信息
     *
     * @param mobile 用户手机号
     * @return 用户信息
     * @author wangmh
     * @date 2018/1/26 14:46
     */
    @RequestMapping(value = "/info/mobile", method = RequestMethod.GET)
    public ModelMap findByMobile(@RequestParam String mobile) {
        return success(userService.findByMobile(mobile));
    }

    /**
     * 用户申请绑定企业
     *
     * @param userUU  用户uu号
     * @param spaceUU 企业uu号
     * @return 用户信息
     * @author wangmh
     * @date 2018/1/31 18:22
     */
    @RequestMapping(value = "/apply/bind", method = RequestMethod.POST)
    public ModelMap bindUserSpace(@RequestParam Long userUU, Long spaceUU) {
        applyUserSpaceService.applyBindUserSpace(userUU, spaceUU);

        User user = userService.findOne(userUU);
        Userspace userspace = userspaceService.findOne(spaceUU);

        // 发送邮箱通知管理员
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日");
        ModelMap data = new ModelMap();
        data.put("username", user.getVipName());
        data.put("time", format.format(new Date()));
        data.put("enName", userspace.getSpaceName());
        sendEmail("templateForSendMailWhenApplyUserSpace", userspace.getAdmin().getEmail(), data);

        // 发送短信通知管理员
        sendSms("templateForSendSmsWhenApplyUserSpace", userspace.getAdmin().getMobile(), user.getVipName(), format.format(new Date()), userspace.getSpaceName());
        return success();
    }

    /**
     * 根据用户uu号查询分页查询申请信息
     *
     * @param userUU 用户uu号
     * @param page   当前页，默认值为1
     * @param size   每页大小，默认值为20
     * @return org.springframework.data.domain.Page，content为ApplyUserSpace集合
     */
    @RequestMapping(value = "/apply/info", method = RequestMethod.GET)
    public ModelMap findApplyInfo(Long userUU, @RequestParam(defaultValue = "1") int page, @RequestParam(defaultValue = "20") int size) {
        return success(applyUserSpaceService.findApplyByUserUU(userUU, page, size));
    }

    /**
     * 用户解除绑定企业
     *
     * @param userUU  用户uu号
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(params = "_operate=unbind", method = RequestMethod.POST)
    public ModelMap unbindUserSpace(Long userUU, Long spaceUU) {
        userService.unbindUserspace(userUU, spaceUU);
        return success();
    }

    /**
     * 企业添加已注册用户
     *
     * @param appId   应用id
     * @param userUU  用户uu号
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(params = "_operate=bind", method = RequestMethod.POST)
    public ModelMap addUser(String appId, Long userUU, Long spaceUU) {
        userService.bindUserspace(appId, userUU, spaceUU);
        return success();
    }

    /**
     * 企业添加未注册用户
     *
     * @param appId   应用id
     * @param user    用户信息
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping(params = "_operate=add", method = RequestMethod.POST)
    public ModelMap addUser(String appId, User user, Long spaceUU) {
        // 参数判断
        if (user == null || user.getUserUU() != null || spaceUU == null) {
            return error("参数错误");
        }

        // 根据手机号判断用户是否为新用户，新用户注册，旧用户绑定
        User oldUser = userService.findByMobile(user.getMobile());
        if (oldUser == null) {
            // 注册新用户，无密码则使用默认密码
            if (StringUtils.isEmpty(user.getPassword())) {
                user.setPassword("111111");
            }
            user = userService.register(user, appId);
        } else {
            user = oldUser;
        }

        // 绑定企业
        userService.bindUserspace(appId, user.getUserUU(), spaceUU);

        return success(user);
    }

    /**
     * 接口调用验证密码登录
     * <p>
     * <pre>
     * 这个比较特殊，指定应用可能密码为空，需要借用其他应用的密码来校验
     * </pre>
     *
     * @return
     */
    @RequestMapping(params = "_operate=fuzzyCheck")
    public ModelMap apiFuzzyLogin(User user) {
        if (null == user || null == user.getPassword()) {
            return error("参数错误");
        }
        if (!StringUtils.isEmpty(user.getMobile())) {
            User userInfo = userService.findByMobile(user.getMobile());
            if (userInfo == null) {
                return error("未找到用户");
            }
            // 允许应用在调用该接口前，已经将用户输入的明文加密为密文
            String encryPwd = user.getPassword().length() >= 32 ? user.getPassword() : userService.getEncryPassword(
                    Const.ENCRY_FORMAT, user.getPassword(), userInfo.getSalt());
            if (encryPwd.equals(userInfo.getPassword())) {
                return success();
            }
            return error("密码错误");
        }
        return error("请填写手机号");
    }

    /**
     * erp修改用户信息 如果type为password则修改密码，为mobile则修改手机号，为email则修改邮箱
     *
     * @param type     修改类型
     * @param userUU   用户uu号
     * @param spaceUU  企业uu号
     * @param password 密码
     * @param data     其他数据
     * @return
     */
    @RequestMapping(value = "/update/{type}/{userUU}/{spaceUU}", method = RequestMethod.POST)
    public ModelMap updatePassword(@PathVariable String type, @PathVariable Long userUU, @PathVariable Long spaceUU, String password, String data) {
        // 获取企业密钥
        Userspace userspace = userspaceService.findOne(spaceUU);

        // 校验请求
        checkRequest(userspace.getAccessSecret());

        // 修改密码
        switch (type) {
            case "password":
                userService.updatePassword(userUU, password);
                break;
            case "mobile":
                userService.updateMobile(userUU, data);
                break;
            case "email":
                userService.updateEmail(userUU, data);
                break;
            default:
                return error("404", "请求错误");
        }

        return success();
    }

    /**
     * 众创商机导入注册
     *
     * @param user 用户信息（主要是用户名，手机号，邮箱和密码，密码base64加密）
     * @return
     */
    @RequestMapping(value = "/sysUserdata/uuzc", method = RequestMethod.POST)
    public ModelMap uuzcRegister(User user, @RequestParam String appId) {
        // 校验手机号
        checkMobile(user.getMobile(), null);

        // 用户名不能为空
        if (StringUtils.isEmpty(user.getVipName())) {
            return error("用户名不能为空");
        }

        // 获取密码
        try {
            String pwd = new String(Base64.decodeBase64(user.getPassword().getBytes("utf-8")), "utf-8");
            user.setPassword(pwd);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        // 传来的值可能带有uu号，去除uu号
        user.setUserUU(null);
        user = userService.register(user, appId);
        return success(user.getUserUU());
    }

    /**
     * erp根据token获取用户信息
     *
     * @param token tokenId
     * @return
     */
    @RequestMapping(value = "/getUserByToken", method = RequestMethod.GET)
    public ModelMap findUserByToken(String token) {
        Token existToken = tokenService.findOne(token);
        if (existToken == null) {
            return error("验证过期");
        }

        if (!(existToken.getBind() instanceof ModelMap)) {
            return error("验证信息错误");
        }
        ModelMap data = (ModelMap) existToken.getBind();
        User user = userService.findOne((Long) data.get("userUU"));
        return success(user);
    }

    /**
     * 根据手机号获取所在企业信息
     *
     * @param mobile 用户手机号
     * @return
     */
    @RequestMapping(value = "/getSpace", method = RequestMethod.GET)
    @Deprecated
    public ModelMap getSpace(String mobile) {
        User user = userService.findByMobile(mobile);
        Set<Userspace> userSpaces = user.getUserSpaces();
        ModelMap data = new ModelMap(user);
        data.put("spaces", userSpaces);
        return data;
    }

    @RequestMapping(value = "/getToken", method = RequestMethod.GET)
    @ResponseBody
    public ModelMap getToken(Long userUU, Long spaceUU) {
        ModelMap data = new ModelMap();
        data.put("userUU", userUU);
        data.put("spaceUU", spaceUU);
        Token token = new Token(data);
        tokenService.save(token);
        return success(token.getId());
    }

    @RequestMapping("/getTokenData")
    public ModelMap getTokenData(String token) {
        return success(tokenService.findOne(token).getBind());
    }

    /**
     * （消息）根据企业uu号和用户uu号获取用户和企业信息
     *
     * @param userUU  用户uu号
     * @param spaceUU 企业uu号
     * @return
     */
    @RequestMapping("/info/userUU")
    public ModelMap getUserInfo(Long userUU, Long spaceUU) {
        User user = userService.findOne(userUU);
        if (user == null) {
            return error("用户不存在");
        }
        Userspace userspace = userspaceService.findOne(spaceUU);
        if (userspace == null) {
            return error("企业不存在");
        }
        if (!user.getUserSpaces().contains(userspace)) {
            return error("用户（" + userUU + "）不属于企业（" + spaceUU + "）");
        }
        ModelMap data = new ModelMap();
        data.addAttribute("mobile", user.getMobile());
        data.addAttribute("imId", user.getImId());
        data.addAttribute("vipName", user.getVipName());
        data.addAttribute("email", user.getEmail());
        data.addAttribute("spaceName", userspace.getSpaceName());
        return success(data);
    }

    /**
     * 优软云个人用户注册总数
     */
    @RequestMapping(value = "/count", method = RequestMethod.GET)
    public ModelMap count() {
        return new ModelMap("count", userService.count());
    }

    /**
     * 统计指定应用个人用户总数
     *
     * @param fromApps
     * @return
     */
    @RequestMapping(value = "/count/apps", method = RequestMethod.GET)
    public ModelMap countForApp(String fromApps) {
        String[] apps = fromApps.split(",");
        return success(userService.count(new ArrayList<>(Arrays.asList(apps))));
    }

    /**
     * 获取本月用户注册数量
     *
     * @return
     */
    @RequestMapping(value = "/currentMonth/count", method = RequestMethod.GET)
    public ModelMap countInCurrentMonth() {
        return new ModelMap("count", userService.countInCurrentMonth());
    }

    /**
     * 获取上个月用户注册数量
     *
     * @return
     */
    @RequestMapping(value = "/lastMonth/count", method = RequestMethod.GET)
    public ModelMap countInLastMonth() {
        return new ModelMap("count", userService.countInLastMonth());
    }

    /**
     * 获取本周用户注册数量
     *
     * @return
     */
    @RequestMapping(value = "/currentWeek/count", method = RequestMethod.GET)
    public ModelMap countInCurrentWeek() {
        return new ModelMap("count", userService.countInCurrentWeek());
    }

    /**
     * 获取指定应用注册数量
     *
     * @param fromApps 应用id，逗号分隔
     * @return
     */
    @RequestMapping(value = "/count/app", method = RequestMethod.GET)
    public ModelMap count(String fromApps) {
        String[] apps = fromApps.split(",");
        return success(userService.count(Arrays.asList(apps)));
    }

    /**
     * 获取指定应用本月注册数量
     *
     * @param fromApps 应用id，逗号分隔
     * @return
     */
    @RequestMapping(value = "/currentMonth/count/app", method = RequestMethod.GET)
    public ModelMap countInCurrentMonth(String fromApps) {
        String[] apps = fromApps.split(",");
        return success(userService.countInCurrentMonth(new ArrayList<>(Arrays.asList(apps))));
    }

    /**
     * 获取指定应用本周注册数量
     *
     * @param fromApps 应用id，逗号分隔
     * @return
     */
    @RequestMapping(value = "/currentWeek/count/app", method = RequestMethod.GET)
    public ModelMap countInCurrentWeek(String fromApps) {
        String[] apps = fromApps.split(",");
        return success(userService.countInCurrentWeek(new ArrayList<>(Arrays.asList(apps))));
    }

    /**
     * 获取指定应用当天注册数量
     *
     * @param fromApps 应用id，逗号分隔
     * @return
     */
    @RequestMapping(value = "/today/count/app", method = RequestMethod.GET)
    public ModelMap countInToday(String fromApps) {
        String[] apps = fromApps.split(",");
        return success(userService.countInToday(new ArrayList<>(Arrays.asList(apps))));
    }

    /**
     * 获取指定应用前一天注册数量
     *
     * @param fromApps 应用id，逗号分隔
     * @return
     */
    @RequestMapping(value = "/yesterday/count/app", method = RequestMethod.GET)
    public ModelMap countInYesterday(String fromApps) {
        String[] apps = fromApps.split(",");
        return success(userService.countInYesterday(new ArrayList<>(Arrays.asList(apps))));
    }

    /**
     * 获取指定应用上一个月注册数量
     *
     * @param fromApps 应用id，逗号分隔
     * @return
     */
    @RequestMapping(value = "/lastMonth/count/app", method = RequestMethod.GET)
    public ModelMap countInLastMonth(String fromApps) {
        String[] apps = fromApps.split(",");
        return success(userService.countgInLastMonth(new ArrayList<>(Arrays.asList(apps))));
    }

    @RequestMapping(value = "/inputTime/count/apps", method = RequestMethod.GET)
    public ModelMap countInInputTime(String start, String end, String fromApps) {
        String[] apps = fromApps.split(",");
        try {
            return success(userService.countInInputTime(start, end, new ArrayList<>(Arrays.asList(apps))));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 统计指定时间内个人用户登录总数
     */
    @RequestMapping(value = "/count/login", method = RequestMethod.GET)
    public ModelMap countByLogin(String start, String end) throws ParseException {
        return new ModelMap("count", userService.countByLogin(start, end));
    }

    /**
     * 统计指定时间内X未登录用户数
     *
     * @param start
     * @param end
     * @param
     * @return
     * @throws ParseException
     */
    @RequestMapping(value = "/count/notlgoin/month", method = RequestMethod.GET)
    public Map<String, Long> countByNotLogin(String start, String end, String months) throws ParseException {
        Map<String, Long> data = new HashMap<>();
        List<String> monthss = Arrays.asList(months.split(","));
        for (String smonth : monthss) {
            int month = Integer.parseInt(smonth);
            long count = userService.countByLoginInputMonth(start, end, month);
            data.put("month"+smonth,count);
        }
        return data;
    }

    /**
     * 统计指定时间内个人用户未登录总数
     */
    @RequestMapping(value = "/count/notlogin", method = RequestMethod.GET)
    public ModelMap countByNotLogin(int month) throws ParseException {
        return new ModelMap("count", userService.countByNotLogin(month));
    }

    /**
     * 根据用户IMID获取女用户信息
     *
     * @param imId 用户的IMID
     * @return 用户信息
     */
    @GetMapping(params = "_operate=getUserByImId")
    public ModelMap getUserByImId(String imId) {
        return success(userService.findByImId(imId));
    }

    /**
     * 获取用户上周最大uu号
     * @return 上周最大uu号（周一算第一天）
     */
    @GetMapping("/maxuu/lastWeek")
    public ModelMap getMaxUUInLastWeek() {
        return success(userService.getMaxUUInLastWeek());
    }

    /**
     * 分页获取用户信息
     * @param pageNumber 当前页数
     * @param pageSize 每页大小
     * @param timestamp 时间戳，与当前时间不能相差10分钟
     * @param encro 签名 md5(#{pageNumber}, #{pageSize}, #{timestamp}, ssoAccountSync),
     * @return
     */
    @GetMapping("/paging/info")
    public ModelMap getUserPaging(int pageNumber, int pageSize, long timestamp, String encro) {
        // 验证时间
        long current = System.currentTimeMillis();
        if (Math.abs(current - timestamp) > 10 * 60 * 1000) {
            LOGGER.warn("全量更新：分页获取用户信息请求过期，当前时间：{}，请求时间：{}", current, timestamp);
            return error("请求过期");
        }

        // 验证签名
        String laws = String.format("%s, %s, %s, %s", pageNumber, pageSize, timestamp, "ssoAccountSync");
        String str = Md5Utils.encode(laws, null);
        if (!str.equals(encro)) {
            LOGGER.warn("全量更新：分页获取用户信息签名错误，明文：{}，签名：{}", laws, encro);
            return error("签名错误");
        }
        return success(userService.getUserInfo(pageNumber, pageSize));
    }
}