package com.yeshi.fanli.service.impl.user;
|
|
import java.io.File;
|
import java.io.FileWriter;
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletRequest;
|
import javax.servlet.http.HttpSession;
|
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.yeshi.utils.JsonUtil;
|
import org.yeshi.utils.tencentcloud.COSManager;
|
|
import com.google.gson.Gson;
|
import com.qcloud.cos.model.COSObjectSummary;
|
import com.qcloud.cos.model.ObjectListing;
|
import com.yeshi.fanli.dao.mybatis.AccountMessageMapper;
|
import com.yeshi.fanli.dao.mybatis.UserConnectHistoryMapper;
|
import com.yeshi.fanli.dao.mybatis.UserInfoMapper;
|
import com.yeshi.fanli.entity.bus.user.BindingAccount;
|
import com.yeshi.fanli.entity.bus.user.ForbiddenUserIdentifyCode;
|
import com.yeshi.fanli.entity.bus.user.ForbiddenUserIdentifyCode.ForbiddenUserIdentifyCodeTypeEnum;
|
import com.yeshi.fanli.entity.bus.user.LoginResult;
|
import com.yeshi.fanli.entity.bus.user.SMSHistory;
|
import com.yeshi.fanli.entity.bus.user.ThreeSale;
|
import com.yeshi.fanli.entity.bus.user.UserConnectHistory;
|
import com.yeshi.fanli.entity.bus.user.UserInfo;
|
import com.yeshi.fanli.entity.bus.user.WeiXinUser;
|
import com.yeshi.fanli.exception.UserAccountException;
|
import com.yeshi.fanli.log.LogHelper;
|
import com.yeshi.fanli.service.inter.hongbao.ThreeSaleSerivce;
|
import com.yeshi.fanli.service.inter.msg.UserAccountMsgNotificationService;
|
import com.yeshi.fanli.service.inter.user.BindingAccountService;
|
import com.yeshi.fanli.service.inter.user.ForbiddenUserIdentifyCodeService;
|
import com.yeshi.fanli.service.inter.user.SpreadUserImgService;
|
import com.yeshi.fanli.service.inter.user.UserAccountService;
|
import com.yeshi.fanli.service.inter.user.UserExtraTaoBaoInfoService;
|
import com.yeshi.fanli.util.Constant;
|
import com.yeshi.fanli.util.FileUtil;
|
import com.yeshi.fanli.util.RedisManager;
|
import com.yeshi.fanli.util.StringUtil;
|
import com.yeshi.fanli.util.TimeUtil;
|
import com.yeshi.fanli.util.factory.msg.MsgAccountDetailFactory;
|
import com.yeshi.fanli.util.wx.WXLoginUtil;
|
|
import net.sf.json.JSONObject;
|
|
@Service
|
public class UserAccountServiceImpl implements UserAccountService {
|
|
@Resource
|
private RedisManager redisManager;
|
|
@Resource
|
private UserInfoMapper userInfoMapper;
|
|
@Resource
|
private BindingAccountService bindingAccountService;
|
|
@Resource
|
private UserConnectHistoryMapper userConnectHistoryMapper;
|
|
@Resource
|
private ThreeSaleSerivce threeSaleSerivce;
|
|
@Resource
|
private AccountMessageMapper accountMessageMapper;
|
|
@Resource
|
private SpreadUserImgService spreadUserImgService;
|
|
@Resource
|
private UserAccountMsgNotificationService userAccountMsgNotificationService;
|
|
@Resource
|
private UserExtraTaoBaoInfoService userExtraTaoBaoInfoService;
|
|
@Resource
|
private ForbiddenUserIdentifyCodeService forbiddenUserIdentifyCodeService;
|
|
@Transactional
|
@Override
|
public LoginResult login(HttpServletRequest request, Boolean first, String appId, String code, String phone,
|
UserInfo tbUserInfo, boolean wxinstall, int loginType) throws UserAccountException {
|
|
JSONObject logInfo = new JSONObject();
|
logInfo.put("appId", appId);
|
logInfo.put("code", code);
|
logInfo.put("phone", phone);
|
if (tbUserInfo != null)
|
logInfo.put("tbUserInfo", tbUserInfo.getId());
|
logInfo.put("loginType", loginType);
|
LogHelper.lgoinInfo(logInfo.toString());
|
|
HttpSession session = request.getSession();
|
if (first != null && first == true)
|
session.removeAttribute("LAST_LOGIN_USER");
|
// 会话中上次登录的用户
|
if (wxinstall) {// 安装了微信的状态
|
UserInfo lastUser = (UserInfo) session.getAttribute("LAST_LOGIN_USER");
|
UserInfo userInfo = null;
|
WeiXinUser weiXinUser = null;
|
switch (loginType) {
|
case 1:// 淘宝
|
// 判断淘宝是否被封禁
|
if (!StringUtil.isNullOrEmpty(tbUserInfo.getTaoBaoUid())) {
|
ForbiddenUserIdentifyCode identifyCode = forbiddenUserIdentifyCodeService.listByTypeAndIdentifyCode(
|
ForbiddenUserIdentifyCodeTypeEnum.taobaoUid, tbUserInfo.getTaoBaoUid());
|
if (identifyCode != null && identifyCode.getEffective() != null && identifyCode.getEffective())
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER,
|
Constant.FORBIDDEN_USER_REASON_DESC);
|
}
|
userInfo = getUserInfoByTaoBaoOpenId(appId, tbUserInfo.getOpenid());
|
// 判断用户是否被删除
|
if (userInfo != null && userInfo.getState() != null
|
&& (userInfo.getState() == UserInfo.STATE_DELETE_OUT_OF_DATE
|
|| userInfo.getState() == UserInfo.STATE_DELETE))
|
userInfo = null;
|
if (userInfo == null) {// 原先的账号不存在
|
userInfo = new UserInfo();
|
userInfo.setAppId(appId);
|
userInfo.setTbName(tbUserInfo.getTbName());
|
userInfo.setOpenid(tbUserInfo.getOpenid());
|
userInfo.setTbPic(tbUserInfo.getTbPic());
|
userInfo.setNickName(tbUserInfo.getNickName());
|
userInfo.setPortrait(tbUserInfo.getPortrait());
|
userInfo.setLoginType(loginType);
|
session.setAttribute("LAST_LOGIN_USER", userInfo);
|
// 需要微信登录
|
return new LoginResult(LoginResult.TYPE_WX, userInfo);
|
} else {// 原先的账号存在
|
// 判定是否绑定了微信
|
if (StringUtil.isNullOrEmpty(userInfo.getWxUnionId())) {// 没有绑定微信
|
userInfo.setLoginType(loginType);
|
session.setAttribute("LAST_LOGIN_USER", userInfo);
|
// 需要微信登录
|
return new LoginResult(LoginResult.TYPE_WX, userInfo);
|
} else {// 绑定了微信
|
updateLatestLoginTime(userInfo.getId());
|
return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
|
}
|
}
|
|
case 2:// 微信
|
// 通过Code换取信息
|
weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
|
if (weiXinUser == null)
|
throw new UserAccountException(1001, "无法获取到微信个人信息");
|
LogHelper.test("微信授权用户信息：" + new Gson().toJson(weiXinUser));
|
// 判断微信unionid是否被封禁
|
ForbiddenUserIdentifyCode identifyCode = forbiddenUserIdentifyCodeService.listByTypeAndIdentifyCode(
|
ForbiddenUserIdentifyCodeTypeEnum.wxUnionId, weiXinUser.getUnionid());
|
if (identifyCode != null && identifyCode.getEffective() != null && identifyCode.getEffective())
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER, Constant.FORBIDDEN_USER_REASON_DESC);
|
|
userInfo = getUserInfoByWXUnionId(appId, weiXinUser.getUnionid());
|
// 判断用户是否被删除
|
if (userInfo != null && userInfo.getState() != null
|
&& (userInfo.getState() == UserInfo.STATE_DELETE_OUT_OF_DATE
|
|| userInfo.getState() == UserInfo.STATE_DELETE))
|
userInfo = null;
|
// 直接用的微信登录
|
if (lastUser == null) {
|
if (userInfo != null) {
|
// 使分销关系生效
|
threeSaleSerivce.effective(userInfo);
|
// 更新头像与昵称
|
UserInfo updateUserInfo = new UserInfo(userInfo.getId());
|
updateUserInfo.setNickName(weiXinUser.getNickname());
|
if (!StringUtil.isNullOrEmpty(weiXinUser.getHeadimgurl()))
|
updateUserInfo.setPortrait(weiXinUser.getHeadimgurl());
|
updateUserInfo.setWxPic(weiXinUser.getHeadimgurl());
|
updateUserInfo.setWxName(weiXinUser.getNickname());
|
// 设置登录时间与登录类型
|
updateUserInfo.setLastLoginTime(System.currentTimeMillis());
|
updateUserInfo.setLoginType(loginType);
|
updateUserInfo.setLastLoginIp(request.getRemoteHost());
|
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
// 删除邀请图片
|
spreadUserImgService.deleteImgUrl(userInfo.getId());
|
return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
|
}
|
userInfo = new UserInfo();
|
userInfo.setPortrait(weiXinUser.getHeadimgurl());
|
userInfo.setAppId(appId);
|
userInfo.setNickName(weiXinUser.getNickname());
|
userInfo.setWxName(weiXinUser.getNickname());
|
userInfo.setWxOpenId(weiXinUser.getOpenid());
|
userInfo.setWxUnionId(weiXinUser.getUnionid());
|
userInfo.setWxPic(weiXinUser.getHeadimgurl());
|
userInfo.setLastLoginTime(System.currentTimeMillis());
|
userInfo.setLoginType(loginType);
|
userInfo.setLastLoginIp(request.getRemoteHost());
|
addUser(userInfo);
|
|
return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
|
} else {
|
// 本会话采用过其他账号登录
|
if (userInfo != null)// 微信账号存在
|
{
|
if (lastUser.getLoginType() == 2) {
|
session.removeAttribute("LAST_LOGIN_USER");
|
throw new UserAccountException(1002, "微信不能绑定微信");
|
}
|
if (lastUser.getLoginType() == 1 && !StringUtil.isNullOrEmpty(userInfo.getOpenid())) {
|
session.removeAttribute("LAST_LOGIN_USER");
|
throw new UserAccountException(1003, "该微信已经绑定了淘宝账号，请先解绑");
|
}
|
if (lastUser.getLoginType() == 3 && !StringUtil.isNullOrEmpty(userInfo.getPhone())) {
|
session.removeAttribute("LAST_LOGIN_USER");
|
throw new UserAccountException(1003, "该微信已经绑定了电话号码，请先解绑");
|
}
|
|
// 删除邀请图片
|
spreadUserImgService.deleteImgUrl(userInfo.getId());
|
// 还没有绑定同类型的账号
|
|
// 两个账号没有同时有独立的UID
|
if (lastUser.getId() == null || lastUser.getId() == 0
|
|| lastUser.getId() == userInfo.getId().longValue()) {
|
// 绑定关系
|
UserInfo updateUserInfo = new UserInfo(userInfo.getId());
|
|
if (!StringUtil.isNullOrEmpty(lastUser.getPhone())) {
|
updateUserInfo.setPhone(lastUser.getPhone());
|
userAccountMsgNotificationService.bindingSuccess(userInfo.getId(),
|
MsgAccountDetailFactory.TYPE_PHONE);
|
}
|
if (!StringUtil.isNullOrEmpty(lastUser.getOpenid())) {
|
updateUserInfo.setOpenid(lastUser.getOpenid());
|
updateUserInfo.setTbName(lastUser.getTbName());
|
updateUserInfo.setTbPic(lastUser.getTbPic());
|
userAccountMsgNotificationService.bindingSuccess(userInfo.getId(),
|
MsgAccountDetailFactory.TYPE_TB);
|
}
|
updateUserInfo.setLastLoginTime(System.currentTimeMillis());
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
session.removeAttribute("LAST_LOGIN_USER");
|
|
// 使分销关系生效
|
threeSaleSerivce.effective(userInfo);
|
|
return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
|
} else {// 两个账号拥有不同的UID
|
// 询问是否打通
|
// 暂存微信账号
|
// session.setAttribute("WEIXIN_USERINFO",
|
// userInfo);
|
session.removeAttribute("LAST_LOGIN_USER");
|
LoginResult result = new LoginResult(LoginResult.TYPE_CONNECT, lastUser);
|
result.setMainUser(userInfo);
|
result.setLessUser(lastUser);
|
|
// 使分销关系生效
|
threeSaleSerivce.effective(userInfo);
|
return result;
|
}
|
|
} else {// 微信账号不存在
|
// 创建账号,绑定账号
|
userInfo = new UserInfo();
|
userInfo.setPortrait(weiXinUser.getHeadimgurl());
|
userInfo.setAppId(appId);
|
userInfo.setNickName(weiXinUser.getNickname());
|
userInfo.setWxName(weiXinUser.getNickname());
|
userInfo.setWxOpenId(weiXinUser.getOpenid());
|
userInfo.setWxUnionId(weiXinUser.getUnionid());
|
userInfo.setWxPic(weiXinUser.getHeadimgurl());
|
if (!StringUtil.isNullOrEmpty(lastUser.getPhone()))
|
userInfo.setPhone(lastUser.getPhone());
|
|
if (!StringUtil.isNullOrEmpty(lastUser.getOpenid())) {
|
userInfo.setOpenid(lastUser.getOpenid());
|
userInfo.setTbName(lastUser.getTbName());
|
userInfo.setTbPic(lastUser.getTbPic());
|
}
|
userInfo.setLastLoginTime(System.currentTimeMillis());
|
userInfo.setLoginType(loginType);
|
userInfo.setLastLoginIp(request.getRemoteHost());
|
addUser(userInfo);
|
session.removeAttribute("LAST_LOGIN_USER");
|
return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
|
}
|
}
|
case 3:// 手机号码
|
// 判断手机号码是否被封禁
|
ForbiddenUserIdentifyCode identifyCode1 = forbiddenUserIdentifyCodeService
|
.listByTypeAndIdentifyCode(ForbiddenUserIdentifyCodeTypeEnum.phone, phone);
|
if (identifyCode1 != null && identifyCode1.getEffective() != null && identifyCode1.getEffective())
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER, Constant.FORBIDDEN_USER_REASON_DESC);
|
|
userInfo = getUserInfoByPhone(appId, phone);
|
// 判断用户是否被删除
|
if (userInfo != null && userInfo.getState() != null
|
&& (userInfo.getState() == UserInfo.STATE_DELETE_OUT_OF_DATE
|
|| userInfo.getState() == UserInfo.STATE_DELETE))
|
userInfo = null;
|
|
if (userInfo == null) {// 原先的账号不存在
|
userInfo = new UserInfo();
|
userInfo.setAppId(appId);
|
userInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
|
userInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
|
userInfo.setPhone(phone);
|
userInfo.setLoginType(loginType);
|
session.setAttribute("LAST_LOGIN_USER", userInfo);
|
// 询问是否绑定微信
|
return new LoginResult(LoginResult.TYPE_WX, userInfo);
|
} else {// 原先的账号存在
|
// 判定是否绑定了微信
|
if (StringUtil.isNullOrEmpty(userInfo.getWxUnionId())) {// 没有绑定微信
|
userInfo.setLoginType(loginType);
|
session.setAttribute("LAST_LOGIN_USER", userInfo);
|
// 需要微信登录
|
return new LoginResult(LoginResult.TYPE_WX, userInfo);
|
} else {// 绑定了微信
|
updateLatestLoginTime(userInfo.getId());
|
return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
|
}
|
}
|
default:
|
return null;
|
}
|
|
} else {// 没有安装微信
|
LoginResult result = loginNoInstallWX(appId, code, phone, tbUserInfo, loginType);
|
if (result.getType() == LoginResult.TYPE_CREATE)
|
session.setAttribute("LAST_LOGIN_USER", result.getUser());
|
return result;
|
}
|
}
|
|
@Transactional
|
@Override
|
public LoginResult loginNoInstallWX(String appId, String code, String phone, UserInfo tbUserInfo, int loginType)
|
throws UserAccountException {
|
JSONObject logInfo = new JSONObject();
|
logInfo.put("appId", appId);
|
logInfo.put("code", code);
|
logInfo.put("phone", phone);
|
if (tbUserInfo != null)
|
logInfo.put("tbUserInfo", tbUserInfo.getId());
|
logInfo.put("loginType", loginType);
|
LogHelper.lgoinInfo(logInfo.toString());
|
|
UserInfo userInfo = null;
|
WeiXinUser weiXinUser = null;
|
switch (loginType) {
|
case 1:// 淘宝
|
if (!StringUtil.isNullOrEmpty(tbUserInfo.getTaoBaoUid())) {
|
ForbiddenUserIdentifyCode identifyCode = forbiddenUserIdentifyCodeService.listByTypeAndIdentifyCode(
|
ForbiddenUserIdentifyCodeTypeEnum.taobaoUid, tbUserInfo.getTaoBaoUid());
|
if (identifyCode != null && identifyCode.getEffective() != null && identifyCode.getEffective())
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER, Constant.FORBIDDEN_USER_REASON_DESC);
|
}
|
userInfo = getUserInfoByTaoBaoOpenId(appId, tbUserInfo.getOpenid());
|
break;
|
case 2:// 微信
|
// 通过Code换取信息
|
weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
|
if (weiXinUser == null)
|
throw new UserAccountException(1001, "无法获取到微信个人信息");
|
|
// 判断是否被封禁
|
ForbiddenUserIdentifyCode identifyCode = forbiddenUserIdentifyCodeService
|
.listByTypeAndIdentifyCode(ForbiddenUserIdentifyCodeTypeEnum.phone, phone);
|
if (identifyCode != null && identifyCode.getEffective() != null && identifyCode.getEffective())
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER, Constant.FORBIDDEN_USER_REASON_DESC);
|
|
userInfo = getUserInfoByWXUnionId(appId, weiXinUser.getUnionid());
|
break;
|
case 3:// 手机号码
|
// 判断是否被封禁
|
ForbiddenUserIdentifyCode identifyCode1 = forbiddenUserIdentifyCodeService
|
.listByTypeAndIdentifyCode(ForbiddenUserIdentifyCodeTypeEnum.phone, phone);
|
if (identifyCode1 != null && identifyCode1.getEffective() != null && identifyCode1.getEffective())
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER, Constant.FORBIDDEN_USER_REASON_DESC);
|
userInfo = getUserInfoByPhone(appId, phone);
|
break;
|
}
|
|
// 判断用户是否被删除
|
if (userInfo != null && userInfo.getState() != null && (userInfo.getState() == UserInfo.STATE_DELETE_OUT_OF_DATE
|
|| userInfo.getState() == UserInfo.STATE_DELETE))
|
userInfo = null;
|
|
if (userInfo != null) {
|
UserInfo updateUserInfo = new UserInfo(userInfo.getId());
|
updateUserInfo.setLastLoginTime(System.currentTimeMillis());
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
return new LoginResult(LoginResult.TYPE_NORMAL, userInfo);
|
} else {// 询问是否创建用户
|
userInfo = new UserInfo();
|
userInfo.setAppId(appId);
|
switch (loginType) {
|
case 1:// 淘宝
|
userInfo.setTbName(tbUserInfo.getNickName());
|
userInfo.setTbPic(tbUserInfo.getPortrait());
|
userInfo.setNickName(tbUserInfo.getNickName());
|
userInfo.setPortrait(tbUserInfo.getPortrait());
|
break;
|
case 2:// 微信
|
userInfo.setPortrait(weiXinUser.getHeadimgurl());
|
userInfo.setNickName(weiXinUser.getNickname());
|
userInfo.setWxName(weiXinUser.getNickname());
|
userInfo.setWxOpenId(weiXinUser.getOpenid());
|
userInfo.setWxUnionId(weiXinUser.getUnionid());
|
userInfo.setWxPic(weiXinUser.getHeadimgurl());
|
break;
|
case 3:// 手机号码
|
// 默认头像与昵称
|
userInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
|
userInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
|
userInfo.setPhone(phone);
|
break;
|
}
|
return new LoginResult(LoginResult.TYPE_CREATE, userInfo);
|
}
|
}
|
|
@Override
|
public void connectUsers(HttpSession session) throws UserAccountException {
|
UserInfo mainUser = (UserInfo) session.getAttribute("WEIXIN_USERINFO");
|
UserInfo lessUser = (UserInfo) session.getAttribute("LAST_LOGIN_USER");
|
|
int lessUserLoginType = lessUser.getLoginType();
|
|
if (mainUser == null || lessUser == null || mainUser.getId() == null || lessUser.getId() == null)
|
throw new UserAccountException(30001, "缺少打通账号");
|
|
mainUser = userInfoMapper.selectByPrimaryKeyForUpdate(mainUser.getId());
|
lessUser = userInfoMapper.selectByPrimaryKeyForUpdate(lessUser.getId());
|
|
session.removeAttribute("WEIXIN_USERINFO");
|
session.removeAttribute("LAST_LOGIN_USER");
|
|
if (mainUser == null || lessUser == null)
|
throw new UserAccountException(30002, "缺少打通账号");
|
|
// 判断是否有绑定相同类型的账号
|
if (lessUserLoginType == 1) {// 次账号以淘宝登录
|
if (!StringUtil.isNullOrEmpty(mainUser.getPhone()) && !StringUtil.isNullOrEmpty(lessUser.getPhone())
|
&& !lessUser.getPhone().equalsIgnoreCase(mainUser.getPhone()))
|
throw new UserAccountException(30003, "请先解除其中一个账号的手机绑定");
|
|
} else if (lessUserLoginType == 3) {// 次账号以手机号登录
|
if (!StringUtil.isNullOrEmpty(mainUser.getOpenid()) && !StringUtil.isNullOrEmpty(lessUser.getOpenid())
|
&& !lessUser.getOpenid().equalsIgnoreCase(mainUser.getOpenid()))
|
throw new UserAccountException(30003, "请先解除其中一个账号的淘宝绑定");
|
}
|
connectUsers(mainUser, lessUser);
|
}
|
|
@Transactional
|
@Override
|
public void connectUsers(UserInfo mainUser, UserInfo lessUser) throws UserAccountException {
|
mainUser = userInfoMapper.selectByPrimaryKeyForUpdate(mainUser.getId());
|
lessUser = userInfoMapper.selectByPrimaryKeyForUpdate(lessUser.getId());
|
|
if (!StringUtil.isNullOrEmpty(mainUser.getOpenid()) && !StringUtil.isNullOrEmpty(lessUser.getOpenid()))
|
throw new UserAccountException(9, "两个账号都绑定了淘宝，请解绑其中一个");
|
|
if (!StringUtil.isNullOrEmpty(mainUser.getPhone()) && !StringUtil.isNullOrEmpty(lessUser.getPhone()))
|
throw new UserAccountException(9, "两个账号都绑定了手机号码，请解绑其中一个");
|
|
if (lessUser.getMyHongBao().compareTo(new BigDecimal("10")) >= 0
|
&& mainUser.getMyHongBao().compareTo(new BigDecimal("10")) > 0)
|
throw new UserAccountException(10, String.format("账户ID:%s 的资金超过10元，为保证资金安全请联系客服打通", lessUser.getId() + ""));
|
|
// 判定是否绑定了同一支付宝
|
BindingAccount mainUserAccount = bindingAccountService.getBindingAccountByUidAndType(mainUser.getId(),
|
BindingAccount.TYPE_ALIPAY);
|
|
BindingAccount lessUserAccount = bindingAccountService.getBindingAccountByUidAndType(lessUser.getId(),
|
BindingAccount.TYPE_ALIPAY);
|
|
// 有不同的支付宝账号
|
boolean hasDiffrentAlipayAccount = false;
|
if (mainUserAccount != null && lessUserAccount != null) {
|
if (!mainUserAccount.getAccount().equalsIgnoreCase(lessUserAccount.getAccount()))
|
hasDiffrentAlipayAccount = true;
|
}
|
|
if (hasDiffrentAlipayAccount)
|
throw new UserAccountException(10, "两个账户都绑定了支付宝，请先解绑其中一个");
|
|
// 判定是否有重叠的账号
|
UserInfo updateUser = new UserInfo(mainUser.getId());
|
if (!StringUtil.isNullOrEmpty(lessUser.getOpenid())) {
|
updateUser.setOpenid(lessUser.getOpenid());
|
updateUser.setTbName(lessUser.getTbName());
|
updateUser.setTbPic(lessUser.getTbPic());
|
}
|
|
if (!StringUtil.isNullOrEmpty(lessUser.getPhone())) {
|
updateUser.setPhone(lessUser.getPhone());
|
}
|
|
// 备份原来的用户信息
|
String logUrl = backupUserImportantInfo(lessUser.getId());
|
|
// 添加打通记录
|
UserConnectHistory userConnectHistory = new UserConnectHistory();
|
userConnectHistory.setCreateTime(new Date());
|
userConnectHistory.setLessUser(lessUser);
|
userConnectHistory.setMainUser(mainUser);
|
userConnectHistory.setLogUrl(logUrl);
|
userConnectHistoryMapper.insertSelective(userConnectHistory);
|
|
userInfoMapper.updateByPrimaryKeySelective(updateUser);
|
// 删除原来的账号
|
UserInfo updateLessUser = new UserInfo(lessUser.getId());
|
updateLessUser.setState(UserInfo.STATE_DELETE);
|
updateLessUser.setStateDesc("账号被打通删除");
|
userInfoMapper.updateByPrimaryKeySelective(updateLessUser);
|
// 融合业务
|
userInfoMapper.connectUser(mainUser.getId(), lessUser.getId());
|
|
// 查询是否有多余的新人红包
|
int subCount = 0;
|
int addCount = 0;
|
|
userAccountMsgNotificationService.connectSuccess(mainUser.getId(), lessUser.getId());
|
}
|
|
/**
|
* 根据系统与unionid寻找用户
|
*
|
* @param appId
|
* @param unionId
|
* @return
|
*/
|
@Override
|
public UserInfo getUserInfoByWXUnionId(String appId, String unionId) throws UserAccountException {
|
if (StringUtil.isNullOrEmpty(appId))
|
throw new UserAccountException(1, "appId为空");
|
if (StringUtil.isNullOrEmpty(unionId))
|
throw new UserAccountException(2, "unionId为空");
|
|
List<UserInfo> list = userInfoMapper.listByAppIdAndWXUnionId(appId, unionId);
|
// 剔除被删除掉的用户
|
for (int i = 0; i < list.size(); i++) {
|
if (list.get(i).getState() == UserInfo.STATE_DELETE
|
|| list.get(i).getState() == UserInfo.STATE_DELETE_OUT_OF_DATE) {
|
list.remove(i);
|
i--;
|
}
|
}
|
if (list.size() > 0)
|
return list.get(list.size() - 1);
|
else
|
return null;
|
}
|
|
/**
|
* 根据系统和淘宝的Openid寻找用户
|
*
|
* @param appId
|
* @param openId
|
* @return
|
*/
|
public UserInfo getUserInfoByTaoBaoOpenId(String appId, String openId) throws UserAccountException {
|
if (StringUtil.isNullOrEmpty(appId))
|
throw new UserAccountException(1, "appId为空");
|
if (StringUtil.isNullOrEmpty(openId))
|
throw new UserAccountException(2, "openId为空");
|
List<UserInfo> list = userInfoMapper.listByAppIdAndTaoBaoOpenId(appId, openId);
|
|
// 剔除被删除掉的用户
|
for (int i = 0; i < list.size(); i++) {
|
if (list.get(i).getState() == UserInfo.STATE_DELETE
|
|| list.get(i).getState() == UserInfo.STATE_DELETE_OUT_OF_DATE) {
|
list.remove(i);
|
i--;
|
}
|
}
|
if (list.size() > 0)
|
return list.get(list.size() - 1);
|
else
|
return null;
|
|
}
|
|
/**
|
* 根据系统和电话号码寻找用户
|
*
|
* @param appId
|
* @param phone
|
* @return
|
*/
|
public UserInfo getUserInfoByPhone(String appId, String phone) throws UserAccountException {
|
if (StringUtil.isNullOrEmpty(appId))
|
throw new UserAccountException(1, "appId为空");
|
if (StringUtil.isNullOrEmpty(phone))
|
throw new UserAccountException(2, "phone为空");
|
List<UserInfo> list = userInfoMapper.listByAppIdAndPhone(appId, phone);
|
|
// 剔除被删除掉的用户
|
for (int i = 0; i < list.size(); i++) {
|
if (list.get(i).getState() == UserInfo.STATE_DELETE
|
|| list.get(i).getState() == UserInfo.STATE_DELETE_OUT_OF_DATE) {
|
list.remove(i);
|
i--;
|
}
|
}
|
if (list.size() > 0)
|
return list.get(list.size() - 1);
|
else
|
return null;
|
|
}
|
|
private void updateLatestLoginTime(Long uid) {
|
UserInfo userInfo = new UserInfo(uid);
|
userInfo.setLastLoginTime(System.currentTimeMillis());
|
userInfoMapper.updateByPrimaryKeySelective(userInfo);
|
}
|
|
@Override
|
public void register(UserInfo userInfo) throws UserAccountException {
|
if (!StringUtil.isNullOrEmpty(userInfo.getPhone())) {
|
UserInfo user = getUserInfoByPhone(userInfo.getAppId(), userInfo.getPhone());
|
if (user != null)
|
throw new UserAccountException(50001, "电话号码已经被绑定");
|
}
|
|
if (!StringUtil.isNullOrEmpty(userInfo.getOpenid())) {
|
UserInfo user = getUserInfoByTaoBaoOpenId(userInfo.getAppId(), userInfo.getOpenid());
|
if (user != null)
|
throw new UserAccountException(50002, "淘宝号已经被绑定");
|
}
|
|
if (!StringUtil.isNullOrEmpty(userInfo.getWxUnionId())) {
|
UserInfo user = getUserInfoByWXUnionId(userInfo.getAppId(), userInfo.getWxUnionId());
|
if (user != null)
|
throw new UserAccountException(50003, "微信号已经被注册");
|
}
|
|
addUser(userInfo);
|
}
|
|
@Override
|
public void addUser(UserInfo user) {
|
Long maxUid = userInfoMapper.getMaxUid();
|
if (maxUid == null)
|
maxUid = 100000L;
|
long dd = (long) (Math.random() * 100);
|
if (dd == 0) {
|
dd = 1;
|
}
|
long uid = maxUid + dd;
|
user.setId(uid);
|
user.setCreatetime(System.currentTimeMillis());
|
user.setRank(0);
|
if (StringUtil.isNullOrEmpty(user.getPortrait()))
|
user.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
|
|
userInfoMapper.insertSelective(user);
|
if (StringUtil.isNullOrEmpty(user.getNickName())) {
|
UserInfo updateUserInfo = new UserInfo(user.getId());
|
updateUserInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName() + user.getId());
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
}
|
}
|
|
@Override
|
public void updateUserSelective(UserInfo user) {
|
userInfoMapper.updateByPrimaryKeySelective(user);
|
}
|
|
@Override
|
public void bindPhone(Long uid, String phone) throws UserAccountException {
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null)
|
throw new UserAccountException(4, "用户不存在");
|
|
if (!StringUtil.isNullOrEmpty(user.getPhone()))
|
throw new UserAccountException(5, "当前账号已经绑定了手机号，请先解绑");
|
|
UserInfo phoneUser = getUserInfoByPhone(user.getAppId(), phone);
|
if (phoneUser != null)
|
throw new UserAccountException(6, "当前电话号码已经被绑定");
|
|
UserInfo update = new UserInfo(user.getId());
|
update.setPhone(phone);
|
userInfoMapper.updateByPrimaryKeySelective(update);
|
userAccountMsgNotificationService.bindingSuccess(uid, MsgAccountDetailFactory.TYPE_PHONE);
|
}
|
|
@Override
|
public void unBindPhone(Long uid, String phone) throws UserAccountException {
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null)
|
throw new UserAccountException(4, "用户不存在");
|
|
if (StringUtil.isNullOrEmpty(user.getPhone()))
|
throw new UserAccountException(4, "尚未绑定电话号码");
|
|
if (!user.getPhone().equalsIgnoreCase(phone))
|
throw new UserAccountException(4, "原绑定手机号输入错误");
|
|
if (StringUtil.isNullOrEmpty(user.getWxUnionId()) && StringUtil.isNullOrEmpty(user.getOpenid()))
|
throw new UserAccountException(5, "不能解除绑定");
|
|
UserInfo updateUserInfo = new UserInfo(uid);
|
updateUserInfo.setPhone("");
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
userAccountMsgNotificationService.unBindingSuccess(uid, MsgAccountDetailFactory.TYPE_PHONE);
|
}
|
|
@Override
|
public void bindTaoBao(Long uid, String tbOpenId, String tbNickName, String tbPortrait)
|
throws UserAccountException {
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null)
|
throw new UserAccountException(4, "用户不存在");
|
|
if (!StringUtil.isNullOrEmpty(user.getOpenid()) && !user.getOpenid().equalsIgnoreCase(tbOpenId))
|
throw new UserAccountException(5, "当前账号已经绑定了淘宝，请先解绑");
|
|
// 绑定同一个淘宝号
|
if (!StringUtil.isNullOrEmpty(user.getOpenid()) && user.getOpenid().equalsIgnoreCase(tbOpenId))
|
return;
|
|
UserInfo taoBaoUser = getUserInfoByTaoBaoOpenId(user.getAppId(), tbOpenId);
|
if (taoBaoUser != null)
|
throw new UserAccountException(6, "当前淘宝号已经被绑定");
|
UserInfo update = new UserInfo(user.getId());
|
update.setOpenid(tbOpenId);
|
update.setTbName(tbNickName);
|
update.setTbPic(tbPortrait);
|
// 如果没有绑定微信就以淘宝的头像和昵称作为用户的头像与昵称
|
if (StringUtil.isNullOrEmpty(user.getWxUnionId())) {
|
update.setNickName(tbNickName);
|
update.setPortrait(tbPortrait);
|
}
|
userInfoMapper.updateByPrimaryKeySelective(update);
|
|
userAccountMsgNotificationService.bindingSuccess(uid, MsgAccountDetailFactory.TYPE_TB);
|
}
|
|
@Override
|
public void unBindTaoBao(Long uid) throws UserAccountException {
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null)
|
throw new UserAccountException(4, "用户不存在");
|
if (StringUtil.isNullOrEmpty(user.getOpenid()))
|
throw new UserAccountException(5, "当前账号尚未绑定淘宝");
|
|
if (StringUtil.isNullOrEmpty(user.getWxUnionId()) && StringUtil.isNullOrEmpty(user.getPhone()))
|
throw new UserAccountException(5, "不能接触绑定");
|
|
UserInfo update = new UserInfo(user.getId());
|
update.setOpenid("");
|
update.setTbName("");
|
update.setTbPic("");
|
// 判断是否有微信绑定
|
if (StringUtil.isNullOrEmpty(user.getWxUnionId())) {
|
update.setNickName(Constant.systemCommonConfig.getDefaultNickName() + user.getId());
|
update.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
|
}
|
|
userInfoMapper.updateByPrimaryKeySelective(update);
|
|
userExtraTaoBaoInfoService.unBindUid(uid);
|
|
userAccountMsgNotificationService.unBindingSuccess(uid, MsgAccountDetailFactory.TYPE_TB);
|
}
|
|
@Override
|
public void changeWXBind(Long uid, String code) throws UserAccountException {
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null)
|
throw new UserAccountException(4, "用户不存在");
|
WeiXinUser weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
|
if (weiXinUser == null)
|
throw new UserAccountException(10, "获取微信用户信息失败");
|
if (weiXinUser.getUnionid().equalsIgnoreCase(user.getWxUnionId()))
|
throw new UserAccountException(12, "亲，请登录其它微信号进行更换绑定");
|
|
UserInfo newUser = getUserInfoByWXUnionId(user.getAppId(), weiXinUser.getUnionid());
|
if (newUser != null)
|
throw new UserAccountException(13, "亲，你要更换绑定的微信号已被其他账号绑定");
|
|
UserInfo updateUserInfo = new UserInfo(uid);
|
updateUserInfo.setWxName(weiXinUser.getNickname());
|
updateUserInfo.setWxOpenId(weiXinUser.getOpenid());
|
updateUserInfo.setWxPic(weiXinUser.getHeadimgurl());
|
updateUserInfo.setWxUnionId(weiXinUser.getUnionid());
|
updateUserInfo.setNickName(weiXinUser.getNickname());
|
updateUserInfo.setPortrait(weiXinUser.getHeadimgurl());
|
if (StringUtil.isNullOrEmpty(weiXinUser.getNickname())) {
|
updateUserInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
|
}
|
|
if (StringUtil.isNullOrEmpty(weiXinUser.getHeadimgurl())) {
|
updateUserInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
|
}
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
|
userAccountMsgNotificationService.changeBindingSuccess(uid, MsgAccountDetailFactory.TYPE_WX);
|
}
|
|
@Override
|
public String backupUserImportantInfo(Long uid) {
|
|
String logPath = String.format(FileUtil.getCacheDir() + "/benfen_%s_" + uid + ".log",
|
TimeUtil.getGernalTime(System.currentTimeMillis(), "yyyyMMddHHmmss"));
|
|
// 备份用户信息
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
|
// TODO 备份资金明细
|
|
// 备份邀请关系
|
List<ThreeSale> threeSaleList = new ArrayList<>();
|
|
FileWriter fw = null;
|
try {
|
// 设置为:True,表示写入的时候追加数据
|
fw = new FileWriter(new File(logPath), true);
|
|
fw.write("#UserInfo" + "\r\n");
|
fw.write(JsonUtil.getSimpleGsonWithDate().toJson(user) + "\r\n");
|
|
fw.write("#ThreeSale" + "\r\n");
|
fw.write(JsonUtil.getSimpleGsonWithDate().toJson(threeSaleList) + "\r\n");
|
|
fw.close();
|
|
String logUrl = COSManager.getInstance()
|
.uploadFile(new File(logPath), "beifen/" + new File(logPath).getName()).getUrl();
|
return logUrl;
|
} catch (IOException e) {
|
e.printStackTrace();
|
} finally {
|
if (new File(logPath).exists())
|
new File(logPath).delete();
|
}
|
|
return null;
|
}
|
|
@Override
|
public void clearUserPortrait(Long uid) {
|
if (uid == null)
|
return;
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
String prefix = String.format("/portrait/wx/%s_", user.getWxUnionId());
|
ObjectListing list = COSManager.getInstance().getObjectList(prefix, null, 30);
|
if (list != null && list.getObjectSummaries() != null)
|
for (COSObjectSummary object : list.getObjectSummaries()) {
|
if (user.getWxPic() != null && !user.getWxPic().contains(object.getKey())) {
|
COSManager.getInstance().deleteFile(object.getKey());
|
}
|
}
|
}
|
|
@Override
|
public String repairPortrait(Long uid) {
|
if (uid == null)
|
return null;
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null)
|
return null;
|
String prefix = String.format("/portrait/wx/%s_", user.getWxUnionId());
|
ObjectListing list = COSManager.getInstance().getObjectList(prefix, null, 30);
|
// 查询头像文件是否还存在
|
boolean exist = false;
|
if (list != null && list.getObjectSummaries() != null)
|
for (COSObjectSummary object : list.getObjectSummaries()) {
|
if (user.getPortrait().contains(object.getKey())) {
|
exist = true;
|
break;
|
}
|
}
|
|
if (!exist && list.getObjectSummaries() != null && list.getObjectSummaries().size() > 0) {
|
COSObjectSummary object = list.getObjectSummaries().get(list.getObjectSummaries().size() - 1);
|
String portrait = String.format("https://%s.file.myqcloud.com/%s", object.getBucketName(), object.getKey());
|
if (!StringUtil.isNullOrEmpty(portrait)) {
|
UserInfo updateUser = new UserInfo(uid);
|
updateUser.setPortrait(portrait);
|
userInfoMapper.updateByPrimaryKeySelective(updateUser);
|
return portrait;
|
}
|
}
|
|
return user.getPortrait();
|
}
|
|
|
|
@Transactional
|
@Override
|
public UserInfo loginPhone(HttpServletRequest request,int loginType, String vcode, String phone,
|
String appId) throws UserAccountException {
|
|
// 空额清理
|
if (phone == null || phone.trim().length() == 0) {
|
throw new UserAccountException(1, "请输入手机号码");
|
}
|
phone = phone.replaceAll(" ", "");
|
|
// 苹果应用商店上线测试号码
|
if ("17316780233".equalsIgnoreCase(phone) && "258168".equalsIgnoreCase(vcode)) {
|
;
|
} else {
|
|
if (StringUtil.isNullOrEmpty(vcode)) {
|
throw new UserAccountException(1, "请输入验证码");
|
}
|
|
String oldVcode = redisManager.getSMSVCode(phone, SMSHistory.TYPE_LOGIN);
|
LogHelper.test("----------------------登录验证码： " + oldVcode);
|
if (StringUtil.isNullOrEmpty(oldVcode) || !oldVcode.equalsIgnoreCase(vcode)) {
|
throw new UserAccountException(1, "验证码错误，重新输入");
|
}
|
}
|
redisManager.clearSMSFrequencyLimit(phone, SMSHistory.TYPE_LOGIN);
|
|
JSONObject logInfo = new JSONObject();
|
logInfo.put("appId", appId);
|
logInfo.put("phone", phone);
|
logInfo.put("loginType", loginType);
|
LogHelper.lgoinInfo(logInfo.toString());
|
|
// 判断手机号码是否被封禁
|
ForbiddenUserIdentifyCode identifyCode1 = forbiddenUserIdentifyCodeService
|
.listByTypeAndIdentifyCode(ForbiddenUserIdentifyCodeTypeEnum.phone, phone);
|
if (identifyCode1 != null && identifyCode1.getEffective() != null && identifyCode1.getEffective()) {
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER, Constant.FORBIDDEN_USER_REASON_DESC);
|
}
|
|
// 查询是否存在该电话历史用户
|
UserInfo userInfo = userInfoMapper.getEffectiveUserInfoByPhone(phone);
|
if (userInfo != null) {
|
// 更新账户登录信息
|
updateLonginInfo(userInfo, loginType, request);
|
} else {
|
userInfo = new UserInfo();
|
userInfo.setAppId(appId);
|
userInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
|
userInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
|
userInfo.setPhone(phone);
|
userInfo.setLoginType(loginType);
|
userInfo.setState(UserInfo.STATE_NORMAL);
|
// 创建用户
|
addUser(userInfo);
|
}
|
|
return userInfo;
|
}
|
|
@Transactional
|
@Override
|
public UserInfo loginWinXin(HttpServletRequest request,int loginType, String code, String appId) throws UserAccountException {
|
// 日志信息
|
JSONObject logInfo = new JSONObject();
|
logInfo.put("appId", appId);
|
logInfo.put("code", code);
|
logInfo.put("loginType", loginType);
|
LogHelper.lgoinInfo(logInfo.toString());
|
|
// 通过Code换取信息
|
WeiXinUser weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
|
if (weiXinUser == null) {
|
throw new UserAccountException(1, "微信帐号授权失败");
|
}
|
LogHelper.test("微信授权用户信息：" + new Gson().toJson(weiXinUser));
|
|
// 判断微信unionid是否被封禁
|
ForbiddenUserIdentifyCode identifyCode = forbiddenUserIdentifyCodeService
|
.listByTypeAndIdentifyCode(ForbiddenUserIdentifyCodeTypeEnum.wxUnionId, weiXinUser.getUnionid());
|
if (identifyCode != null && identifyCode.getEffective() != null && identifyCode.getEffective()) {
|
throw new UserAccountException(Constant.CODE_FORBIDDEN_USER, Constant.FORBIDDEN_USER_REASON_DESC);
|
}
|
|
UserInfo userInfo = userInfoMapper.getEffectiveUserInfoByWXUnionId(weiXinUser.getUnionid());
|
// 直接用的微信登录
|
if (userInfo != null) {
|
// 更新账户登录信息
|
updateLonginInfo(userInfo, loginType, request);
|
} else {
|
// 创建新账户
|
userInfo = new UserInfo();
|
userInfo.setPortrait(weiXinUser.getHeadimgurl());
|
userInfo.setAppId(appId);
|
userInfo.setNickName(weiXinUser.getNickname());
|
userInfo.setWxName(weiXinUser.getNickname());
|
userInfo.setWxOpenId(weiXinUser.getOpenid());
|
userInfo.setWxUnionId(weiXinUser.getUnionid());
|
userInfo.setWxPic(weiXinUser.getHeadimgurl());
|
userInfo.setLastLoginTime(System.currentTimeMillis());
|
userInfo.setLoginType(loginType);
|
userInfo.setLastLoginIp(request.getRemoteHost());
|
userInfo.setState(UserInfo.STATE_NORMAL);
|
addUser(userInfo);
|
}
|
return userInfo;
|
}
|
|
/**
|
* 更新账户登录信息
|
* @param userInfo
|
* @param loginType
|
* @param request
|
*/
|
public void updateLonginInfo(UserInfo userInfo, int loginType, HttpServletRequest request) {
|
// 设置登录时间与登录类型
|
UserInfo updateUserInfo = new UserInfo(userInfo.getId());
|
updateUserInfo.setLastLoginTime(System.currentTimeMillis());
|
updateUserInfo.setLoginType(loginType);
|
updateUserInfo.setLastLoginIp(request.getRemoteHost());
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
}
|
|
|
@Override
|
public void bindPhoneNew(Long uid, String phone) throws UserAccountException {
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null) {
|
throw new UserAccountException(1, "用户不存在");
|
}
|
|
String hasPhone = user.getPhone();
|
if (!StringUtil.isNullOrEmpty(hasPhone) && hasPhone.equals(phone)) {
|
throw new UserAccountException(2, "您已经绑定了该电话号码");
|
}
|
|
UserInfo phoneUser = userInfoMapper.getEffectiveUserInfoByPhone(phone);
|
if (phoneUser != null) {
|
throw new UserAccountException(2, "号码已经被占用");
|
}
|
|
// 更新电话号码
|
UserInfo update = new UserInfo(user.getId());
|
update.setPhone(phone);
|
userInfoMapper.updateByPrimaryKeySelective(update);
|
|
// 发送消息
|
userAccountMsgNotificationService.bindingSuccess(uid, MsgAccountDetailFactory.TYPE_PHONE);
|
}
|
|
|
@Override
|
public void bindWeiXin(Long uid, String code) throws UserAccountException {
|
UserInfo user = userInfoMapper.selectByPrimaryKey(uid);
|
if (user == null) {
|
throw new UserAccountException(1, "用户不存在");
|
}
|
|
WeiXinUser weiXinUser = WXLoginUtil.getWeiXinUserWithSavePortrait(code);
|
if (weiXinUser == null) {
|
throw new UserAccountException(2, "微信帐号授权失败");
|
}
|
|
if (weiXinUser.getUnionid().equalsIgnoreCase(user.getWxUnionId())) {
|
throw new UserAccountException(3, "微信帐号一致无需更换");
|
}
|
|
UserInfo newUser = userInfoMapper.getEffectiveUserInfoByWXUnionId(weiXinUser.getUnionid());
|
if (newUser != null) {
|
throw new UserAccountException(4, "该微信号已被其他帐号绑定");
|
}
|
|
String wxUnionId = user.getWxUnionId();
|
if (!StringUtil.isNullOrEmpty(wxUnionId) && StringUtil.isNullOrEmpty(user.getPhone())) {
|
throw new UserAccountException(5, "该帐号没有绑定手机号码，需绑定手机号码才能完成微信更换");
|
}
|
|
|
UserInfo updateUserInfo = new UserInfo(uid);
|
updateUserInfo.setWxName(weiXinUser.getNickname());
|
updateUserInfo.setWxOpenId(weiXinUser.getOpenid());
|
updateUserInfo.setWxPic(weiXinUser.getHeadimgurl());
|
updateUserInfo.setWxUnionId(weiXinUser.getUnionid());
|
updateUserInfo.setNickName(weiXinUser.getNickname());
|
updateUserInfo.setPortrait(weiXinUser.getHeadimgurl());
|
if (StringUtil.isNullOrEmpty(weiXinUser.getNickname())) {
|
updateUserInfo.setNickName(Constant.systemCommonConfig.getDefaultNickName());
|
}
|
|
if (StringUtil.isNullOrEmpty(weiXinUser.getHeadimgurl())) {
|
updateUserInfo.setPortrait(Constant.systemCommonConfig.getDefaultPortrait());
|
}
|
userInfoMapper.updateByPrimaryKeySelective(updateUserInfo);
|
|
userAccountMsgNotificationService.bindingSuccess(uid, MsgAccountDetailFactory.TYPE_WX);
|
}
|
|
}
|
