sso-parent/sso-server/src/main/java/com/uas/sso/service/impl/UserServiceImpl.java

package com.uas.sso.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.uas.sso.common.encrypt.MD5;
import com.uas.sso.common.util.HttpUtil;
import com.uas.sso.core.Const;
import com.uas.sso.core.ICallable;
import com.uas.sso.core.Status;
import com.uas.sso.core.Type;
import com.uas.sso.dao.UserDao;
import com.uas.sso.dao.UserRecordDao;
import com.uas.sso.entity.*;
import com.uas.sso.exception.VisibleError;
import com.uas.sso.logging.LoggerManager;
import com.uas.sso.logging.SyncBufferedLogger;
import com.uas.sso.logging.UserBufferedLogger;
import com.uas.sso.service.AppService;
import com.uas.sso.service.UserService;
import com.uas.sso.service.UserValidService;
import com.uas.sso.service.UserspaceService;
import com.uas.sso.util.AccountTypeUtils;
import com.uas.sso.util.ExecuteUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import com.uas.sso.exception.AccountException;

import javax.persistence.criteria.*;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * 用户service实现类
 *
 * @author wangmh
 * @date 2018/1/2
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private UserRecordDao userRecordDao;

    @Autowired
    private UserValidService userValidService;

    @Autowired
    private UserspaceService userspaceService;

    @Autowired
    private AppService appService;

    private UserBufferedLogger userLog = LoggerManager.getLogger(UserBufferedLogger.class);

    private SyncBufferedLogger syncLog = LoggerManager.getLogger(SyncBufferedLogger.class);

    @Override
    public User findByMobile(String mobile, String mobileArea) {
        return userDao.findByMobileAndMobileArea(mobile, mobileArea);
    }

    @Override
    public User findByMobile(String mobile) {
        return userDao.findByMobile(mobile);
    }

    @Override
    public boolean mobileHasRegistered(String mobile) {
        User user = userDao.findByMobile(mobile);
        if (user == null) {
            return false;
        }
        return true;
    }

    @Override
    public boolean emailHasRegistered(String email) {
        List<User> users = userDao.findByEmailAndEmailValidCode(email, (short) Status.AUTHENTICATED.getCode());
        if (CollectionUtils.isEmpty(users)) {
            return false;
        }
        return true;
    }

    @Override
    public User register(User user) {
        // 校验手机号是否被注册
        if (mobileHasRegistered(user.getMobile())) {
            throw new VisibleError("该手机号已被注册");
        }

        // 由于现在不考虑手机号所属区域，默认为中国大陆
        if (StringUtils.isEmpty(user.getMobileArea())) {
            user.setMobileArea(Const.CONTINENT);
        }

        // 设置基本属性，手机号默认已认证
        user.setRegisterDate(new Timestamp(System.currentTimeMillis()));
        Long uu = userDao.findMaxUU();
        user.setUserUU(uu == null ? 10000 : (uu + 1));
        user.setSalt(String.valueOf(user.getUserUU()));
        user.setMobileValidCode((short) Status.AUTHENTICATED.getCode());
        user.setEmailValidCode((short) Status.NOT_APPLYING.getCode());
        user.setIdentityValidCode((short) Status.NOT_APPLYING.getCode());
        user.setPassword(getEncryPassword(Const.ENCRY_FORMAT, user.getPassword(), user.getSalt()));
        user.setUserRecord(new UserRecord());

        userDao.save(user);
        userLog.info(user, Type.UPDATE_REGISTER.getValue());

        // 同步到各个应用
        syncUserInfo(user.getUserUU(), "个人注册");
        return user;
    }

    @Override
    public String getEncryPassword(String format, String noEncryPwd, String salt) {
        if (StringUtils.isEmpty(format)) {
            return noEncryPwd;
        }
        // 超过32认为是已加密过的密文
        if (noEncryPwd.length() >= 32) {
            /// 之后添加日志时恢复
            //logger.error("用户密码加密", String.format("传递过来的密码(%s)必须是未加密的明文", noEncryPwd));
            throw new AccountException("invalid password");
        }
        // $password{$salt}
        String password = format.replace(Const.ENCRY_PARAM_PASSWORD, noEncryPwd);
        password = password.replace(Const.ENCRY_PARAM_SALT, salt == null ? "" : salt);
        return MD5.toMD5(password);
    }

    @Override
    public User save(User user) {
        user = userDao.save(user);
        syncUserInfo(user.toView(), "修改用户信息");
        return user;
    }

    @Override
    public void checkPassword(Long userUU, String password, boolean isEncry) {
        // 根据用户uu号找到旧数据
        User oldUser = userDao.findByUserUU(userUU);
        if (oldUser == null) {
            throw new VisibleError("用户名或密码错误");
        }

        // 校验密码
        checkPassword(oldUser, password, isEncry);

    }

    @Override
    public void checkPasswordByMobile(String mobile, String password, boolean isEncry) {
        // 找到用户
        User oldUser = userDao.findByMobile(mobile);
        if (oldUser == null) {
            throw new VisibleError("用户名或密码错误");
        }

        // 校验密码
        checkPassword(oldUser, password, isEncry);
    }

    @Override
    public void checkPasswordByEmail(String email, String password, boolean isEncry) {
        // 找到用户
        List<User> oldUsers = userDao.findByEmailAndEmailValidCode(email, (short) Status.AUTHENTICATED.getCode());
        if (CollectionUtils.isEmpty(oldUsers)) {
            throw new VisibleError("该邮箱未认证，请使用手机号登录");
        }

        // 校验密码
        for (User oldUser : oldUsers) {
            checkPassword(oldUser, password, isEncry);
        }
    }

    @Override
    public int getPwdErrorCount(String username) {
        User user = findByUsername(username);
        if (user == null) {
            throw new VisibleError("用户名不存在");
        }
        if (user.getUserRecord() == null) {
            return 0;
        }
        return user.getUserRecord().getPwdErrorCount();
    }

    @Override
    public User findByUsername(String username) {
        String type = AccountTypeUtils.getAccountType(username);
        User user = null;
        if (AccountTypeUtils.MOBILE.equals(type)) {
            // 手机号
            user = userDao.findByMobile(username);
        } else if (AccountTypeUtils.EMAIL.equals(type)) {
            // 邮箱
            List<User> users = userDao.findByEmailAndEmailValidCode(username, (short) Status.AUTHENTICATED.getCode());
            // 认证邮箱只有一条记录，直接选择第一个
            if (!CollectionUtils.isEmpty(users)) {
                user = users.get(0);
            }
        } else if (AccountTypeUtils.UU_NUMBER.equals(type)) {
            // uu号
            user = userDao.findByUserUU(Long.valueOf(type));
        }
        return user;
    }

    /**
     * 校验用户密码
     *
     * @param oldUser 用户信息
     * @param password 需要校验的密码
     * @param isEncry 需校验的密码是否被加密
     */
    private void checkPassword(User oldUser, String password, boolean isEncry) {
        // 密码未加密，转换成加密后的密码
        String encryPassword = password;
        if (!isEncry) {
            encryPassword = getEncryPassword(Const.ENCRY_FORMAT, password, oldUser.getSalt());
        }

        // 校验密码
        if (!encryPassword.equals(oldUser.getPassword())) {
            throw new VisibleError("密码不一致");
        }
    }

    @Override
    public void save(UserRecord userRecord) {
        userRecordDao.save(userRecord);
    }

    @Override
    public User findOne(Long userUU) {
        return userDao.findOne(userUU);
    }

    @Override
    public boolean realNameIsValid(String realName) {
        User user = userDao.findByRealName(realName);
        if (user != null && user.getIdentityValidCode() == Status.AUTHENTICATED.getCode()) {
            return true;
        }
        return false;
    }

    @Override
    public boolean idCardIsValid(String idCard) {
        User user = userDao.findByIdCard(idCard);
        if (user != null && user.getIdentityValidCode() == Status.AUTHENTICATED.getCode()) {
            return true;
        }
        return false;
    }

    @Override
    public void submitIdValidInfo(User user) {
        // 校验企业名和营业执照是否被认证
        boolean isValid = realNameIsValid(user.getRealName());
        if (isValid) {
            throw new VisibleError("该真实姓名已被认证，请确认");
        }
        isValid = idCardIsValid(user.getIdCard());
        if (isValid) {
            throw new VisibleError("该身份证号已被认证，请确认");
        }

        // 保存日志
        userValidService.submitValid(user);
    }

    @Override
    public void updateMobile(Long userUU, String newMobile) {
        // 获取用户信息
        User user = userDao.findOne(userUU);
        if (user == null) {
            throw new VisibleError("用户不存在");
        }

        // 修改手机号
        user.setMobile(newMobile);
        user.setMobileValidCode((short) Status.AUTHENTICATED.getCode());

        // 保存用户信息
        userDao.save(user);

        // 保存日志
        userLog.info(user, Type.UPDATE_MOBILE.getValue());

        // 同步到各个应用
        syncUserInfo(user.getUserUU(), "个人注册");
    }

    @Override
    public void updateEmail(Long userUU, String newEmail) {
        // 获取用户信息
        User user = userDao.findOne(userUU);
        if (user == null) {
            throw new VisibleError("用户不存在");
        }

        // 修改手机号
        user.setEmail(newEmail);
        user.setEmailValidCode((short) Status.AUTHENTICATED.getCode());

        // 保存用户信息
        userDao.save(user);

        // 保存日志
        userLog.info(user, Type.UPDATE_EMAIL.getValue());

        // 同步信息到各应用
        syncUserInfo(user.getUserUU(), "个人注册");
    }

    @Override
    public Page<User> findMemberBySpaceUU(int page, int size, Long spaceUU) {
        Pageable pageable = new PageRequest(page, size);
        Page<User> pUsers = userDao.findAll(new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> list = new ArrayList<>();
                list.add(cb.equal(root.join("userSpaces", JoinType.INNER).get("spaceUU").as(Long.class), spaceUU));
                Predicate[] predicates = new Predicate[list.size()];
                predicates = list.toArray(predicates);
                return cb.and(predicates);
            }
        }, pageable);
        return pUsers;
    }

    @Override
    public void bindUserspace(Long userUU, Long spaceUU) {
        // 找到用户和企业
        User user = findOne(userUU);
        Userspace userspace = userspaceService.findOne(spaceUU);

        // 将企业添加到用户列表上
        Set<Userspace> userspaces = user.getUserSpaces();
        userspaces.add(userspace);

        // 保存
        userDao.save(user);
    }

    /**
     * 同步用户信息到各个应用
     * @param userUU 用户uu号
     * @param msg 同步信息描述，用户区分同步类型
     */
    private void syncUserInfo(Long userUU, String msg) {
        syncUserInfo(findOneView(userUU), msg);
    }

    /**
     * 同步用户信息到各个应用
     * @param userView 用户信息视图
     * @param msg 同步信息描述，用户区分同步类型
     */
    private void syncUserInfo(final UserView userView, final String msg) {
        List<String> apps = appService.findUid();

        ExecuteUtils.execute(new ICallable<Void, String>() {

            @Override
            public Void call(String appId) {
                App tempApp = appService.findOne(appId);
                if (tempApp != null && StringUtils.isEmpty(tempApp.getUserControl())
                        && !StringUtils.isEmpty(tempApp.getBackUserUrl())) {
                    String url = tempApp.getBackUserUrl();
                    JSONObject formData = JSON.parseObject(JSON.toJSONString(userView));
                    HttpUtil.ResponseWrap res = null;
                    try {
                        res = HttpUtil.doPost(url, formData, 30000);
                        if (!res.isSuccess()) {
                            syncLog.error(appId, msg + ",同步用户信息成功", JSON.toJSONString(userView), res.getContent());
                        } else {
                            syncLog.info(appId, msg + ",同步用户信息成功", JSON.toJSONString(userView));
                        }
                    } catch (Exception e) {
                        syncLog.error(appId, msg + ",同步用户信息失败", JSON.toJSONString(userView), e.getMessage());
                    }
                }
                return null;
            }
        }, apps);
    }

    public UserView findOneView(Long userUU) {
        User user = findOne(userUU);
        return user.toView();
    }
}