package com.hx.phip.service.userMoney.impl;
|
|
import javax.annotation.Resource;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.hx.common.service.CommonService;
|
import com.hx.phiappt.common.OperationReasonConstants;
|
import com.hx.phiappt.common.OriginChannelConstants;
|
import com.hx.phiappt.constants.tool.UserInfoTool;
|
import com.hx.phiappt.constants.tool.money.UserMoneyTool;
|
import com.hx.phiappt.model.*;
|
import com.hx.phip.common.wx.corp.WeiXinMpUtil;
|
import com.hx.phip.config.CustomParameter;
|
import com.hx.phip.dao.mapper.*;
|
import com.hx.phip.model.ApplyParameter;
|
import com.hx.phip.model.SysParameter;
|
import com.hx.phip.service.UserIntegralRecordService;
|
import com.hx.phip.service.UserMoneyService;
|
import com.hx.phip.service.UserValueAddedFundRecordService;
|
import com.hx.phip.tool.ApplyParameterTool;
|
import com.hx.phip.tool.SendSMSTool;
|
import com.hx.util.AesUtil;
|
import com.hx.util.StringUtils;
|
import com.platform.constants.PlatformPattern;
|
import com.platform.exception.PlatTipsException;
|
import com.platform.resultTool.PlatformCode;
|
import com.platform.resultTool.SystemCode;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Propagation;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.hx.exception.TipsException;
|
import com.hx.phiappt.model.userMoney.UserMoneyUnclaimed;
|
import com.hx.phip.service.userMoney.UserMoneyUnclaimedService;
|
import com.hx.mybatisTool.SqlSentence;
|
|
import java.lang.reflect.Field;
|
import java.lang.reflect.Modifier;
|
import java.math.BigDecimal;
|
import java.util.*;
|
|
@Transactional
|
@Service
|
public class UserMoneyUnclaimedServiceImpl implements UserMoneyUnclaimedService {
|
|
private static final Logger logger = LoggerFactory.getLogger(UserMoneyUnclaimedServiceImpl.class);
|
|
@Resource
|
private UserMapper userMapper;
|
@Resource
|
private CommonService commonService;
|
@Resource
|
private CustomParameter customParameter;
|
@Resource
|
private UserInfoMapper userInfoMapper;
|
@Resource
|
private UserMoneyService userMoneyService;
|
@Resource
|
private UserMoneyUnclaimedMapper userMoneyUnclaimedMapper;
|
@Resource
|
private UserIntegralRecordService userIntegralRecordService;
|
@Resource
|
private UserValueAddedFundRecordService userValueAddedFundRecordService;
|
|
/**
|
* 查询列表
|
*/
|
@Override
|
public List<UserMoneyUnclaimed> selectList(SqlSentence sqlSentence) {
|
return userMoneyUnclaimedMapper.selectList(sqlSentence);
|
}
|
|
/**
|
* 查询列表
|
*/
|
@Override
|
public List<Map<String, Object>> selectListMap(SqlSentence sqlSentence) {
|
return userMoneyUnclaimedMapper.selectListMap(sqlSentence);
|
}
|
|
/**
|
* 查询单个
|
*/
|
@Override
|
public UserMoneyUnclaimed selectOne(SqlSentence sqlSentence) {
|
return userMoneyUnclaimedMapper.selectOne(sqlSentence);
|
}
|
|
/**
|
* 查询单个
|
*/
|
@Override
|
public Map<String, Object> selectOneMap(SqlSentence sqlSentence) {
|
return userMoneyUnclaimedMapper.selectOneMap(sqlSentence);
|
}
|
|
/**
|
* 查询单个，大数据不拿取
|
*/
|
@Override
|
public UserMoneyUnclaimed selectOneByKey(Object object) {
|
return userMoneyUnclaimedMapper.selectOneByKey(object);
|
}
|
|
/**
|
* 查询单个，大数据拿取
|
*/
|
@Override
|
public UserMoneyUnclaimed selectOneByKeyBlob(Object object) {
|
return userMoneyUnclaimedMapper.selectOneByKeyBlob(object);
|
}
|
|
/**
|
* 获取操作用户资金信息消息
|
* @param userMoneyUnclaimed 参数
|
* @param type 是否领取资金
|
* @return 返回
|
*/
|
private JSONObject getOpInfo(UserMoneyUnclaimed userMoneyUnclaimed, Integer type) {
|
BigDecimal before = BigDecimal.ZERO;
|
BigDecimal after = BigDecimal.ZERO;
|
JSONObject jsonObject = new JSONObject();
|
// 获取处理信息
|
StringBuilder info = new StringBuilder();
|
info.append(userMoneyUnclaimed.getOriginSubject());
|
// 查询用户资金信息
|
UserMoney userMoney = userMoneyService.selectUserIdDecrypt(userMoneyUnclaimed.getUserId());
|
switch (userMoneyUnclaimed.getFundType()) {
|
case UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND:
|
info.append(", 储值金");
|
before = new BigDecimal(userMoney.getStoredValueFund());
|
after = before.add(userMoneyUnclaimed.getOpNumber());
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND:
|
info.append(", 增值金");
|
before = new BigDecimal(userMoney.getValueAddedFund());
|
after = before.add(userMoneyUnclaimed.getOpNumber());
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_INTEGRAL:
|
info.append(", 积分");
|
before = new BigDecimal(userMoney.getIntegral());
|
after = before.add(userMoneyUnclaimed.getOpNumber());
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_DEPOSIT:
|
info.append(", 预定金");
|
before = new BigDecimal(userMoney.getDeposit());
|
after = before.add(userMoneyUnclaimed.getOpNumber());
|
break;
|
}
|
info.append(", 操作数量：").append(userMoneyUnclaimed.getOpNumber());
|
if (UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND == userMoneyUnclaimed.getFundType()) {
|
// 增值金添加是否需要领取
|
int opType = userMoneyUnclaimed.getOpType() == null ? BaseEntity.YES : userMoneyUnclaimed.getOpType();
|
info.append(", 是否需要领取：").append(BaseEntity.YES.equals(opType) ? "是" : "否");
|
if (BaseEntity.YES.equals(opType)){
|
before = null;
|
after = null;
|
}
|
}
|
if (BaseEntity.YES.equals(type)){
|
info.append(", 领取资金: ").append(userMoneyUnclaimed.getOpNumber());
|
}
|
if (3 == type){
|
info.append(", 作废待领取资金: ").append(userMoneyUnclaimed.getOpNumber());
|
before = null;
|
after = null;
|
}
|
jsonObject.put("key", info.toString());
|
jsonObject.put("before", before);
|
jsonObject.put("after", after);
|
return jsonObject;
|
}
|
|
/**
|
* 添加用户日志
|
* @param userMoneyUnclaimed 用户资金对象
|
* @param type 是否领取资金
|
*/
|
private void addUserLog(UserMoneyUnclaimed userMoneyUnclaimed, Integer type){
|
// 处理用户日志
|
User user = userMapper.selectOneByKey(userMoneyUnclaimed.getUserId());
|
if (user != null) {
|
// 用户日志
|
JSONArray logArray = new JSONArray();
|
JSONObject jsonObject = getOpInfo(userMoneyUnclaimed, type);
|
logArray.add(jsonObject);
|
// 操作人转换
|
UserUpdateLog userUpdateLog = new UserUpdateLog();
|
switch (userMoneyUnclaimed.getOperatorType()) {
|
case UserMoneyUnclaimed.OPERATOR_TYPE_USER:
|
userUpdateLog.setOperatorType(UserUpdateLog.OPERATOR_TYPE_USER);
|
userUpdateLog.setOperatorId(userMoneyUnclaimed.getOperatorId());
|
userUpdateLog.setOperatorName(userMoneyUnclaimed.getOperatorName());
|
break;
|
case UserMoneyUnclaimed.OPERATOR_TYPE_EMPLOYEE:
|
userUpdateLog.setOperatorType(UserUpdateLog.OPERATOR_TYPE_EMPLOYEE);
|
userUpdateLog.setOperatorId(userMoneyUnclaimed.getOperatorId());
|
userUpdateLog.setOperatorName(userMoneyUnclaimed.getOperatorName());
|
break;
|
case UserMoneyUnclaimed.OPERATOR_TYPE_ADMIN:
|
userUpdateLog.setOperatorType(UserUpdateLog.OPERATOR_TYPE_ADMIN);
|
userUpdateLog.setOperatorId(userMoneyUnclaimed.getOperatorId());
|
userUpdateLog.setOperatorName(userMoneyUnclaimed.getOperatorName());
|
break;
|
case UserMoneyUnclaimed.OPERATOR_TYPE_SYSTEM:
|
userUpdateLog.setOperatorType(UserUpdateLog.OPERATOR_TYPE_SYSTEM);
|
break;
|
}
|
// 添加用户日志
|
UserInfoTool.addUserUpdateLogOp(commonService, user, user.getShopId(), userUpdateLog, "用户资金调整", logArray, userMoneyUnclaimed.getRemarks());
|
}
|
}
|
|
/**
|
* 新增
|
*/
|
@Override
|
@Transactional(propagation = Propagation.REQUIRES_NEW)
|
public void insert(UserMoneyUnclaimed userMoneyUnclaimed) {
|
int count = userMoneyUnclaimedMapper.insert(userMoneyUnclaimed);
|
if (count != 1) {
|
throw new TipsException("新增失败！");
|
} else {
|
// 重新获取下数据
|
UserMoneyUnclaimed checkUserMoneyUnclaimed = userMoneyUnclaimedMapper.selectOneByKey(userMoneyUnclaimed.getId());
|
if(checkUserMoneyUnclaimed != null) {
|
// 过滤待领取的数据
|
this.handlerReceiveData(checkUserMoneyUnclaimed, BaseEntity.YES);
|
// 添加用户日志
|
addUserLog(userMoneyUnclaimed, BaseEntity.NO);
|
}
|
|
}
|
}
|
|
/**
|
* 修改
|
*/
|
@Override
|
public void updateAll(UserMoneyUnclaimed userMoneyUnclaimed) {
|
if(BaseEntity.YES.equals(userMoneyUnclaimed.getIsDel())){
|
// 添加用户日志
|
addUserLog(userMoneyUnclaimed, 3);
|
}
|
int count = userMoneyUnclaimedMapper.updateAll(userMoneyUnclaimed);
|
if (count != 1) {
|
throw new TipsException("保存失败！");
|
}
|
}
|
|
/**
|
* 修改
|
*/
|
@Override
|
public void updateWhere(SqlSentence sqlSentence) {
|
int count = userMoneyUnclaimedMapper.updateWhere(sqlSentence);
|
if (count != 1) {
|
throw new TipsException("保存失败！");
|
}
|
}
|
|
/**
|
* 删除一个
|
*/
|
@Override
|
public void deleteOne(String delId) {
|
int count = userMoneyUnclaimedMapper.deleteById(delId);
|
if (count != 1) {
|
throw new TipsException("删除失败！");
|
}
|
}
|
|
/**
|
* 查询条数
|
*/
|
@Override
|
public int selectCount(SqlSentence sqlSentence) {
|
int count = userMoneyUnclaimedMapper.selectCount(sqlSentence);
|
return count;
|
}
|
|
/**
|
* 校验参数
|
*
|
* @param userMoneyUnclaimed 用户待领取列表
|
*/
|
@Override
|
@Transactional(propagation = Propagation.REQUIRES_NEW)
|
public void checkParam(UserMoneyUnclaimed userMoneyUnclaimed) {
|
// 用户校验
|
if (StringUtils.isEmpty(userMoneyUnclaimed.getUserId())) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "用户id不能为空");
|
}
|
|
// 资金类型判断
|
if (userMoneyUnclaimed.getFundType() == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "资金类型不能为空");
|
} else {
|
// 资金类型判断是否匹配
|
switch (userMoneyUnclaimed.getFundType()) {
|
case UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND:
|
case UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND:
|
case UserMoneyUnclaimed.FUND_TYPE_INTEGRAL:
|
case UserMoneyUnclaimed.FUND_TYPE_DEPOSIT:
|
break;
|
default:
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "资金类型错误,类型不存在");
|
}
|
}
|
|
// 来源渠道
|
if (StringUtils.isEmpty(userMoneyUnclaimed.getOriginChannel())) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "来源渠道不能为空");
|
} else {
|
if (checkConstantNotHaveValue(OriginChannelConstants.class, userMoneyUnclaimed.getOriginChannel())) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "来源渠道错误,渠道不存在");
|
}
|
}
|
|
// 操作原因
|
if (StringUtils.isEmpty(userMoneyUnclaimed.getOperationReason())) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "操作原因不能为空");
|
} else {
|
if (checkConstantNotHaveValue(OperationReasonConstants.class, userMoneyUnclaimed.getOperationReason())) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "操作原因错误,渠道不存在");
|
}
|
}
|
|
// 操作类型
|
if (userMoneyUnclaimed.getOpType() == null) {
|
// 默认为系统处理
|
userMoneyUnclaimed.setOpType(UserMoneyUnclaimed.OP_TYPE_SYSTEM);
|
// 增值金默认需要领取
|
if (UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND == userMoneyUnclaimed.getFundType()) {
|
// 增值金默认需要领取 负数不用用户领取和判断是否需要发送短信提醒领取
|
if (BigDecimal.ZERO.compareTo(userMoneyUnclaimed.getOpNumber()) < 0) {
|
userMoneyUnclaimed.setOpType(UserMoneyUnclaimed.OP_TYPE_RECEIVE);
|
}
|
}
|
} else {
|
// 判断是否是支持的类型
|
if (UserMoneyUnclaimed.OP_TYPE_SYSTEM != userMoneyUnclaimed.getOpType() && UserMoneyUnclaimed.OP_TYPE_RECEIVE != userMoneyUnclaimed.getOpType()) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "操作类型错误");
|
}
|
}
|
|
// 是否发送短信
|
if (UserMoneyUnclaimed.OP_TYPE_RECEIVE == userMoneyUnclaimed.getOpType()) {
|
boolean flag = true;
|
// 查询用户设置是否领取状态
|
UserInfo userInfo = userInfoMapper.selectOneByUserId(userMoneyUnclaimed.getUserId());
|
if (userInfo != null) {
|
// 不需要领取处理数据
|
if (userInfo.getIsReceiveValueAddedFund() != null && BaseEntity.NO.equals(userInfo.getIsReceiveValueAddedFund())) {
|
flag = false;
|
userMoneyUnclaimed.setOpType(UserMoneyUnclaimed.OP_TYPE_SYSTEM);
|
// 用户设置了不用再领取增值金
|
logger.info("操作用户资金(待领取记录)-用户设置是否需要领取状态：{}", userInfo.getIsReceiveValueAddedFund());
|
}
|
}
|
// 校验是否要发送短信
|
if (flag) {
|
checkIsNeedSentSMS(userMoneyUnclaimed);
|
}
|
}
|
|
// 判断操作数量或金额
|
if (userMoneyUnclaimed.getOpNumber() == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "操作数量或金额不能为空");
|
} else {
|
// 判断操作数量或金额 是否为 0
|
if (BigDecimal.ZERO.compareTo(userMoneyUnclaimed.getOpNumber()) == 0) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "操作数量或金额不能为0");
|
} else if (BigDecimal.ZERO.compareTo(userMoneyUnclaimed.getOpNumber()) < 0) {
|
// 资金操作类型-增加
|
userMoneyUnclaimed.setFundOpType(UserMoneyUnclaimed.FUND_OP_TYPE_INCREASE);
|
} else if (BigDecimal.ZERO.compareTo(userMoneyUnclaimed.getOpNumber()) > 0) {
|
// 资金操作类型-减少
|
userMoneyUnclaimed.setFundOpType(UserMoneyUnclaimed.FUND_OP_TYPE_REDUCE);
|
}
|
|
// 用户资金数据校验
|
UserMoney userMoney = userMoneyService.selectUserIdDecrypt(userMoneyUnclaimed.getUserId());
|
if (userMoney == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "用户的资产数据不存在");
|
} else {
|
// 判断数量减扣数量是否充足
|
if (UserMoneyUnclaimed.FUND_OP_TYPE_REDUCE == userMoneyUnclaimed.getFundOpType()) {
|
// 资金类型判断是否匹配
|
switch (userMoneyUnclaimed.getFundType()) {
|
case UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND:
|
// 金额操作
|
BigDecimal storedValueFund = new BigDecimal(userMoney.getStoredValueFund());
|
checkCanOperation(storedValueFund, userMoneyUnclaimed.getOpNumber());
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND:
|
// 金额操作 不做校验可以减成负数
|
BigDecimal valueAddedFund = new BigDecimal(userMoney.getValueAddedFund());
|
checkCanOperation(valueAddedFund, userMoneyUnclaimed.getOpNumber());
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_INTEGRAL:
|
// 积分操作
|
BigDecimal integral = new BigDecimal(userMoney.getIntegral());
|
checkCanOperation(integral, userMoneyUnclaimed.getOpNumber());
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_DEPOSIT:
|
// 金额操作
|
BigDecimal deposit = new BigDecimal(userMoney.getDeposit());
|
checkCanOperation(deposit, userMoneyUnclaimed.getOpNumber());
|
break;
|
}
|
}
|
}
|
}
|
|
// 操作人信息判断
|
if (userMoneyUnclaimed.getOperatorType() == null) {
|
// 操作人类型默认为员工
|
userMoneyUnclaimed.setOperatorType(UserMoneyUnclaimed.OPERATOR_TYPE_EMPLOYEE);
|
} else {
|
// 操作人类型判断是否匹配
|
switch (userMoneyUnclaimed.getOperatorType()) {
|
case UserMoneyUnclaimed.OPERATOR_TYPE_ADMIN:
|
case UserMoneyUnclaimed.OPERATOR_TYPE_USER:
|
case UserMoneyUnclaimed.OPERATOR_TYPE_EMPLOYEE:
|
break;
|
default:
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "操作人类型错误");
|
}
|
}
|
|
// 判断是否传了操作人id
|
if (StringUtils.isEmpty(userMoneyUnclaimed.getOperatorId())) {
|
throw new PlatTipsException(PlatformCode.ERROR_PARAMETER_NULL, "操作人id不能为空");
|
}
|
|
// 操作人为员工
|
if (UserMoneyUnclaimed.OPERATOR_TYPE_EMPLOYEE == userMoneyUnclaimed.getOperatorType()) {
|
Employee employee = commonService.selectOneByKey(EmployeeMapper.class, userMoneyUnclaimed.getOperatorId());
|
if (employee == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "操作人的信息不存在");
|
} else {
|
// 填充名称
|
userMoneyUnclaimed.setOperatorName(employee.getCnName());
|
}
|
}
|
|
// 操作人为后台用户
|
if (UserMoneyUnclaimed.OPERATOR_TYPE_ADMIN == userMoneyUnclaimed.getOperatorType()) {
|
SysAdmin sysAdmin = commonService.selectOneByKey(SysAdminMapper.class, userMoneyUnclaimed.getOperatorId());
|
if (sysAdmin == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "操作人的信息不存在");
|
} else {
|
// 填充名称
|
userMoneyUnclaimed.setOperatorName(sysAdmin.getName());
|
}
|
}
|
|
// 操作人为用户
|
if (UserMoneyUnclaimed.OPERATOR_TYPE_USER == userMoneyUnclaimed.getOperatorType()) {
|
User user = commonService.selectOneByKey(UserMapper.class, userMoneyUnclaimed.getOperatorId());
|
if (user == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "操作人的信息不存在");
|
} else {
|
// 填充名称
|
userMoneyUnclaimed.setOperatorName(user.getName());
|
}
|
}
|
|
/*// 判断订单 先不判断订单
|
if(!StringUtils.isEmpty(userMoneyUnclaimed.getOrderId())){
|
OrdersTotal ordersTotal = commonService.selectOneByKey(OrdersTotalMapper.class, userMoneyUnclaimed.getOrderId());
|
if(ordersTotal == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "主订单的信息不存在");
|
}
|
}
|
|
// 判断子订单
|
if(!StringUtils.isEmpty(userMoneyUnclaimed.getOrderItemId())){
|
if(StringUtils.isEmpty(userMoneyUnclaimed.getOrderId())){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "主订单id不能为空！");
|
}
|
OrderItem orderItem = commonService.selectOneByKey(OrderItemMapper.class, userMoneyUnclaimed.getOrderItemId());
|
if(orderItem == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "子订单的信息不存在");
|
} else {
|
if(!orderItem.getOrderId().equals(userMoneyUnclaimed.getOrderId())){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "子订单的信息与主订单的信息不匹配");
|
}
|
}
|
}*/
|
|
// 获取有效期时间配置 待领取默认30天领取
|
Date validityTime = UserMoneyTool.getUnclaimedValidityTime(commonService);
|
// 设置有效期时间
|
userMoneyUnclaimed.setLimitEndTime(validityTime);
|
}
|
|
/**
|
* 校验常量值是否存在
|
* @param classObj 类对象
|
* @param value 校验值
|
* @return 返回
|
*/
|
@Override
|
public boolean checkConstantNotHaveValue(Class classObj, String value) {
|
boolean flag = true;
|
// 判断是否存在这个来源渠道
|
Field[] fields = classObj.getDeclaredFields();
|
for (Field field : fields) {
|
field.setAccessible(true);
|
// 获取常量名称
|
String fieldName = field.getName();
|
// 判断常量值是否存在
|
if (field.getType().toString().endsWith("java.lang.String") && Modifier.isStatic(field.getModifiers())) {
|
try {
|
// 获取常量值
|
String fieldValue = field.get(classObj).toString();
|
if (fieldValue.equals(value)) {
|
flag = false;
|
break;
|
}
|
}catch (Exception ex){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "常量获取配置出现错误");
|
|
}
|
}
|
}
|
return flag;
|
}
|
|
/**
|
* 判断数据是否支持减扣
|
*/
|
private void checkCanOperation(BigDecimal value, BigDecimal opNumber) {
|
// 负数取反计算
|
if(BigDecimal.ZERO.compareTo(opNumber) > 0){
|
opNumber = opNumber.negate();
|
}
|
|
// 计算账户余额是否支持减扣
|
BigDecimal subtractValue = value.subtract(opNumber);
|
if (subtractValue.compareTo(BigDecimal.ZERO) < 0) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "您的数量不足已减扣！");
|
}
|
}
|
|
/**
|
* 根据平台判断是否需要发送短信
|
* @param userMoneyUnclaimed 用户待领取信息
|
*/
|
private void checkIsNeedSentSMS(UserMoneyUnclaimed userMoneyUnclaimed) {
|
// CRM不用发送短信领取其他平台需要发送短信领取
|
// if(!OriginChannelConstants.ORIGIN_CHANNEL_CRM.equals(userMoneyUnclaimed.getOriginChannel())) {
|
userMoneyUnclaimed.setIsSentSMS(BaseEntity.YES);
|
String url = getSMSUrl();
|
if (StringUtils.isEmpty(url)) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "获取发送短信链接地址出现异常！");
|
}
|
userMoneyUnclaimed.setSMSUrl(url);
|
//}
|
}
|
|
/**
|
* 生成需要发送短信的地址
|
* @return 返回
|
*/
|
private String getSMSUrl() {
|
// 生成小程序链接
|
String urlLink = null;
|
// 正式区在拿取链接
|
if (PlatformPattern.PROD.equals(customParameter.getPlatformPatternMoney())) {
|
//获取用户CRM小程序token
|
ApplyParameter applyParameter = ApplyParameterTool.getMpParameter("wx71e6babac80abcee", commonService);
|
if (applyParameter == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS, "mpId is error");
|
}
|
|
SysParameter sysParameter = WeiXinMpUtil.getAccessToken(commonService, applyParameter.getMpAppId(), AesUtil.aesDecryp(applyParameter.getMpSecretKey()));
|
if (sysParameter == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_SYSTEM, "服务错误" + SystemCode.ERROR_GET_CORP_TOKEN);
|
}
|
|
// 更换链接 原CRM 1.0 /pages/recharge/incrementInfo
|
String result = SendSMSTool.getAooLetUrl(sysParameter.getParamValue(), "/pages/portClient_me/incrementValue/incrementValue", "", "release");
|
if (!StringUtils.isEmpty(result)) {
|
JSONObject jsonObject = JSON.parseObject(result);
|
if (jsonObject.getInteger("errcode") != 0) {
|
throw new PlatTipsException(PlatformCode.ERROR_SYSTEM, "生成短信小程序路径错误：" + jsonObject.getString("msg") + SystemCode.ERROR_GET_CORP_TOKEN);
|
}
|
urlLink = jsonObject.getString("url_link");
|
}
|
} else {
|
// 测试区跳转百度
|
urlLink = "https://wxaurl.cn/6666";
|
}
|
return urlLink;
|
}
|
|
/**
|
* 待领取资产处理
|
* @param userMoneyUnclaimed 待领取数据
|
* @param isReceive 是否过滤领取数据 0 否 1 是
|
*/
|
@Override
|
public void handlerReceiveData(UserMoneyUnclaimed userMoneyUnclaimed, Integer isReceive) {
|
if (userMoneyUnclaimed != null) {
|
// 多线程添加锁
|
synchronized (this) {
|
// 判断是不是要领取的数据
|
if(BaseEntity.YES.equals(isReceive)) {
|
if (UserMoneyUnclaimed.OP_TYPE_RECEIVE == userMoneyUnclaimed.getOpType()) {
|
logger.info("待领取资产处理跳过,数据id：{},原因:需要领取数据", userMoneyUnclaimed.getId());
|
return;
|
}
|
}
|
// 判断是否处理了
|
if(UserMoneyUnclaimed.STATUS_SUCCEED == userMoneyUnclaimed.getStatus()){
|
logger.info("待领取资产处理跳过,数据id：{},原因:数据已领取不需要再处理", userMoneyUnclaimed.getId());
|
return;
|
}
|
// 判断数据是否有效
|
if(UserMoneyUnclaimed.NO.equals(userMoneyUnclaimed.getIsValid())){
|
logger.info("待领取资产处理跳过,数据id：{},原因:数据已失效无法领取", userMoneyUnclaimed.getId());
|
return;
|
}
|
// 操作资金处理
|
switch (userMoneyUnclaimed.getFundType()) {
|
case UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND:
|
case UserMoneyUnclaimed.FUND_TYPE_DEPOSIT:
|
// 储值金和预定金只处理总资金信息
|
userMoneyService.handleMoneyData(userMoneyUnclaimed);
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND:
|
// 处理增值金
|
userValueAddedFundRecordService.handleData(userMoneyUnclaimed);
|
break;
|
case UserMoneyUnclaimed.FUND_TYPE_INTEGRAL:
|
// 处理积分
|
userIntegralRecordService.handleData(userMoneyUnclaimed);
|
break;
|
}
|
|
// 更新状态成已处理
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String, Object> sqlValue = new HashMap<>();
|
String sql = " status=#{m.status},receiveTime=#{m.nowTime},limitEndTime=#{m.limitEndTime},editTime=#{m.nowTime} WHERE id=#{m.id}";
|
sqlValue.put("id", userMoneyUnclaimed.getId());
|
sqlValue.put("status", UserMoneyUnclaimed.STATUS_SUCCEED);
|
// 已领取调整领取时间
|
Date receivedValidityTime = UserMoneyTool.getReceivedValidityTime(commonService);
|
sqlValue.put("limitEndTime", receivedValidityTime);
|
sqlValue.put("nowTime",new Date());
|
sqlSentence.sqlSentence(sql, sqlValue);
|
commonService.updateWhere(UserMoneyUnclaimedMapper.class, sqlSentence);
|
|
// 添加用户日志
|
if(BaseEntity.NO.equals(isReceive)) {
|
addUserLog(userMoneyUnclaimed, BaseEntity.YES);
|
}
|
}
|
}
|
}
|
}
|
