package com.taoke.autopay.controller.client;
|
|
|
import com.google.gson.Gson;
|
import com.google.gson.GsonBuilder;
|
import com.google.gson.TypeAdapter;
|
import com.google.gson.stream.JsonReader;
|
import com.google.gson.stream.JsonWriter;
|
import com.taoke.autopay.dao.KeyOrderMapper;
|
import com.taoke.autopay.dto.DYOrderDto;
|
import com.taoke.autopay.entity.*;
|
|
import com.taoke.autopay.exception.KeyOrderException;
|
import com.taoke.autopay.exception.KeyVerifyException;
|
import com.taoke.autopay.exception.WxOrderCountException;
|
import com.taoke.autopay.factory.OrderFactory;
|
import com.taoke.autopay.manager.OrderPayFailProcessor;
|
import com.taoke.autopay.manager.PayCountVerifyManager;
|
import com.taoke.autopay.service.*;
|
import com.taoke.autopay.utils.*;
|
import com.taoke.autopay.utils.order.DYOrderApi;
|
import com.taoke.autopay.utils.order.OrderChannelApiUtil;
|
import com.taoke.autopay.utils.order.OrderChannelUtil;
|
import com.taoke.autopay.vo.AcceptData;
|
import com.taoke.autopay.vo.KeyOrderVO;
|
import com.taoke.autopay.vo.OrderFilter;
|
import net.sf.json.JSONArray;
|
import net.sf.json.JSONObject;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.web.bind.annotation.RequestMapping;
|
import org.springframework.web.bind.annotation.ResponseBody;
|
|
import javax.annotation.Resource;
|
import java.io.IOException;
|
import java.io.UnsupportedEncodingException;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
/**
|
* @author hxh
|
* @title: OrderController
|
* @description: TODO
|
* @date 2024/6/14 19:57
|
*/
|
@Controller
|
@RequestMapping("api/order")
|
public class OrderController {
|
|
private Logger loggerPay = LoggerFactory.getLogger("payLogger");
|
|
private Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new TypeAdapter<Date>() {
|
@Override
|
public void write(JsonWriter out, Date value) throws IOException {
|
String desc = "";
|
if (value != null) {
|
// 判断是否是同一天
|
desc = TimeUtil.getGernalTime(value.getTime(), "yyyy-MM-dd HH:mm:ss");
|
out.value(desc);
|
} else {
|
out.value("");
|
}
|
}
|
|
@Override
|
public Date read(JsonReader in) throws IOException {
|
return new Date();
|
}
|
}).create();
|
|
@Resource
|
private KeyOrderService keyOrderService;
|
|
@Resource
|
private ClientInfoService clientInfoService;
|
|
@Resource
|
private WxUserOrderCountService wxUserOrderCountService;
|
|
@Resource
|
private WxUserSettingService wxUserSettingService;
|
|
@Resource
|
private SystemConfigService systemConfigService;
|
|
@Resource
|
private OrderPayFailProcessor orderPayFailProcessor;
|
|
@Resource
|
private PayMoneySettingService payMoneySettingService;
|
|
@Resource
|
private UserSettingService userSettingService;
|
|
@Resource
|
private PayCountVerifyManager payCountVerifyManager;
|
|
|
@ResponseBody
|
@RequestMapping("listOrder")
|
public String listOrder(AcceptData acceptData, OrderFilter filter) {
|
KeyOrderMapper.DaoQuery query = new KeyOrderMapper.DaoQuery();
|
Long uid = filter.getUid();
|
ClientInfo info = clientInfoService.selectByPrimaryKey(uid);
|
query.distributeClientUid = filter.getUid();
|
if (info == null) {
|
return JsonUtil.loadFalseResult("客户端ID不存在");
|
}
|
if (info.getRule() == 1) {
|
// 超级管理员
|
query.distributeClientUid = null;
|
}
|
clientInfoService.setActiveTime(filter.getUid(), new Date());
|
query.start = (filter.getPage() - 1) * filter.getPageSize();
|
query.count = filter.getPageSize();
|
query.minCreateTime = new Date(System.currentTimeMillis() - 1000 * 60 * 30L);
|
if (filter.getState() != null) {
|
switch (filter.getState()) {
|
case OrderFilter.STATE_NOT_PROCESS:
|
query.stateList = Arrays.asList(new Integer[]{KeyOrder.STATE_NOT_PROCESS});
|
break;
|
case OrderFilter.STATE_PROCESSED:
|
query.stateList = Arrays.asList(new Integer[]{KeyOrder.STATE_PAY, KeyOrder.STATE_REJECT_PAY});
|
break;
|
case OrderFilter.STATE_PROCESS_ERROR:
|
query.stateList = Arrays.asList(new Integer[]{KeyOrder.STATE_NOT_PAY});
|
break;
|
}
|
}
|
|
if (filter.getTimeType() != null) {
|
long now = System.currentTimeMillis();
|
String nowDay = TimeUtil.getGernalTime(now, "yyyy-MM-dd");
|
switch (filter.getTimeType()) {
|
case OrderFilter.TIME_TYPE_TODAY:
|
query.minCreateTime = new Date(TimeUtil.convertToTimeTemp(nowDay, "yyyy-MM-dd"));
|
break;
|
case OrderFilter.TIME_TYPE_YESTERDAY:
|
query.maxCreateTime = new Date(TimeUtil.convertToTimeTemp(nowDay, "yyyy-MM-dd"));
|
query.minCreateTime = new Date(TimeUtil.convertToTimeTemp(TimeUtil.getGernalTime(now - 24 * 60 * 60 * 1000L, "yyyy-MM-dd"), "yyyy-MM-dd"));
|
break;
|
case OrderFilter.TIME_TYPE_WEEK:
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(new Date(now));
|
int day = calendar.get(Calendar.DAY_OF_WEEK);
|
day -= 1;
|
if (day == 0) {
|
// 星期天
|
day = 7;
|
}
|
query.minCreateTime = new Date(TimeUtil.convertToTimeTemp(TimeUtil.getGernalTime(now - 24 * 60 * 60 * 1000L * (day - 1), "yyyy-MM-dd"), "yyyy-MM-dd"));
|
break;
|
case OrderFilter.TIME_TYPE_MONTH:
|
query.minCreateTime = new Date(TimeUtil.convertToTimeTemp(TimeUtil.getGernalTime(now, "yyyy-MM"), "yyyy-MM"));
|
break;
|
}
|
|
}
|
|
if (filter.getSort() == 0) {
|
query.sortList = Arrays.asList(new String[]{"create_time asc"});
|
} else {
|
query.sortList = Arrays.asList(new String[]{"create_time desc"});
|
}
|
List<KeyOrder> list = keyOrderService.list(query);
|
List<KeyOrderVO> voList = new ArrayList<>();
|
for (KeyOrder order : list) {
|
voList.add(OrderFactory.create(order));
|
}
|
long count = keyOrderService.count(query);
|
JSONObject data = new JSONObject();
|
data.put("count", count);
|
data.put("list", gson.toJson(voList));
|
return JsonUtil.loadTrueResult(data);
|
}
|
|
@ResponseBody
|
@RequestMapping("setOrderNoV2")
|
public String setOrderNoV2(AcceptData acceptData, String id, String orderNoDesc, String orderStatus, String money) {
|
loggerPay.info("setOrderNo[{}]: {}-{}-{}-{}", acceptData.getUid(), id, orderNoDesc, orderStatus, money);
|
if (StringUtil.isNullOrEmpty(id)) {
|
return JsonUtil.loadFalseResult("请上传id");
|
}
|
if (StringUtil.isNullOrEmpty(money)) {
|
return JsonUtil.loadFalseResult("请上传money");
|
}
|
|
KeyOrder order = keyOrderService.selectById(id);
|
if (order == null) {
|
return JsonUtil.loadFalseResult("口令不存在");
|
}
|
|
money = money.replace("¥", "");
|
|
int orderType = Constant.ORDER_TYPE_UNKNOWN;
|
|
if (orderNoDesc.contains("抖音") || orderNoDesc.contains("上海格物致品")) {
|
orderType = Constant.ORDER_TYPE_DY;
|
} else if (orderNoDesc.contains("快手")) {
|
orderType = Constant.ORDER_TYPE_KS;
|
}
|
|
String orderNo = "";
|
try {
|
if (orderType == Constant.ORDER_TYPE_UNKNOWN) {
|
throw new KeyOrderException("未定义的订单类型");
|
}
|
|
if (!StringUtil.isNullOrEmpty(orderStatus)) {
|
throw new KeyOrderException(orderStatus);
|
}
|
|
DYOrderDto dyOrderDto = null;
|
try {
|
// 验证订单是否可以支付
|
dyOrderDto = keyOrderService.verifyKey(orderNoDesc, orderStatus, money, null, null);
|
} catch (KeyVerifyException ve) {
|
throw new KeyOrderException("口令验证失败：" + ve.getMessage());
|
}
|
// if(dyOrderDto!=null&&order.getOrderMoney()!=null){
|
// // 判断订单支付金额与用户提交的金额是否匹配
|
// if(dyOrderDto.getPay_amount()!=order.getOrderMoney().multiply(new BigDecimal(100)).setScale(0, RoundingMode.FLOOR).intValue()){
|
// throw new KeyOrderException(String.format("订单接口金额不匹配：%s-%s",dyOrderDto.getPay_amount(),MoneyUtil.getMoneyStr(order.getOrderMoney())));
|
// }
|
// }
|
if (dyOrderDto != null) {
|
orderNo = dyOrderDto.getOrder_id();
|
}
|
|
OrderChannelEnum orderChannel = null;
|
if (dyOrderDto != null) {
|
orderChannel = OrderChannelUtil.getChannelByKey(dyOrderDto.getOrderChannel());
|
} else {
|
orderChannel = OrderChannelEnum.unknown;
|
}
|
|
// 验证渠道支付次数是否达到上限
|
if (order.getUid() != null) {
|
payCountVerifyManager.verifyPayCount(order.getUid(), orderType, orderChannel);
|
}
|
|
// 设置进入
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setOrderType(orderType);
|
orderUpdate.setOrderNo(orderNo);
|
orderUpdate.setOrderMoney(new BigDecimal(money));
|
if (dyOrderDto != null) {
|
orderUpdate.setOrderState(dyOrderDto.getOrder_status());
|
orderUpdate.setOrderChannel(dyOrderDto.getOrderChannel());
|
orderUpdate.setPayType(Constant.PAY_TYPE_WITH_ORDER_NO);
|
} else {
|
orderUpdate.setPayType(Constant.PAY_TYPE_WITH_MONEY);
|
orderUpdate.setOrderChannel(OrderChannelEnum.unknown.getKey());
|
}
|
orderUpdate.setExcutePayTime(new Date());
|
keyOrderService.update(orderUpdate);
|
order = keyOrderService.selectById(id);
|
order.setPayType(orderUpdate.getPayType());
|
return JsonUtil.loadTrueResult(gson.toJson(OrderFactory.create(order)));
|
} catch (KeyOrderException e) {
|
loggerPay.info(String.format("设置订单号出错：%s-%s", id, e.getMessage()));
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setOrderType(orderType);
|
orderUpdate.setOrderNo(orderNo);
|
orderUpdate.setOrderMoney(new BigDecimal(money));
|
orderUpdate.setOrderState(0);
|
orderUpdate.setState(KeyOrder.STATE_REJECT_PAY);
|
if (order.getExcutePayTime() == null) {
|
orderUpdate.setExcutePayTime(new Date());
|
}
|
orderUpdate.setStateDesc(e.getMessage());
|
keyOrderService.update(orderUpdate);
|
return JsonUtil.loadFalseResult(e.getMessage());
|
} catch (Exception e) {
|
e.printStackTrace();
|
return JsonUtil.loadFalseResult(e.getMessage());
|
}
|
}
|
|
/**
|
* @author hxh
|
* @description 设置商家是否可支付
|
* @date 1:26 2025/2/8
|
* @param: acceptData
|
* @param: id
|
* @param: merchant
|
* @return java.lang.String
|
**/
|
|
@ResponseBody
|
@RequestMapping("isMerchantCanPay")
|
public String isMerchantCanPay(AcceptData acceptData, String id, String merchant) {
|
loggerPay.info("isMerchantCanPay[{}]: {}-{}", acceptData.getUid(), id, merchant);
|
// 判断是否为卡金额
|
KeyOrder keyOrder = keyOrderService.selectById(id);
|
if (keyOrder == null) {
|
return JsonUtil.loadFalseResult("订单ID不存在");
|
}
|
OrderChannelEnum orderChannel = OrderChannelUtil.getChannelByKey(keyOrder.getOrderChannel());
|
if (orderChannel != OrderChannelEnum.unknown) {
|
// 确定渠道的订单可直接支付
|
return JsonUtil.loadTrueResult("");
|
}
|
|
// 获取卡金额的设置信息
|
PayMoneySetting payMoneySetting = payMoneySettingService.getSettingByMoney(keyOrder.getOrderMoney());
|
if (payMoneySetting == null) {
|
keyOrderService.rejectPay(keyOrder.getId(),"付款金额不属于卡金额范围");
|
return JsonUtil.loadFalseResult("付款金额不属于卡金额范围");
|
}
|
if (payMoneySetting.getVerifyMerchantChannel() == null || payMoneySetting.getVerifyMerchantChannel() == OrderChannelEnum.unknown) {
|
// 没有设置校验渠道
|
return JsonUtil.loadTrueResult("");
|
}
|
|
try {
|
// 目前只判断超享佣
|
boolean isCanPay = OrderChannelApiUtil.isMerchantCanPay(payMoneySetting.getVerifyMerchantChannel(), merchant, keyOrder.getOrderMoney());
|
if (isCanPay) {
|
// 通过商家校验
|
try {
|
payCountVerifyManager.verifyPayCount(keyOrder.getUid(), keyOrder.getOrderType(), payMoneySetting.getVerifyMerchantChannel());
|
}catch (KeyOrderException ee){
|
// 拒绝支付
|
keyOrderService.rejectPay(keyOrder.getId(), ee.getMessage());
|
return JsonUtil.loadFalseResult(ee.getMessage());
|
}finally {
|
// 更新渠道
|
KeyOrder update = new KeyOrder();
|
update.setId(keyOrder.getId());
|
update.setOrderChannel(payMoneySetting.getVerifyMerchantChannel().getKey());
|
keyOrderService.update(update);
|
}
|
return JsonUtil.loadTrueResult("");
|
} else {
|
// 未通过商家校验
|
keyOrderService.rejectPay(keyOrder.getId(),"商家校验未通过");
|
return JsonUtil.loadFalseResult("商家校验未通过");
|
}
|
} catch (UnsupportedEncodingException e) {
|
return JsonUtil.loadFalseResult(e.getMessage());
|
}
|
}
|
|
/**
|
* @return java.lang.String
|
* @author hxh
|
* @description 是否可以执行支付
|
* @date 0:22 2024/12/28
|
* @param: acceptData
|
* @param: id
|
**/
|
@ResponseBody
|
@RequestMapping("canExcutePay")
|
public String canExcutePay(AcceptData acceptData, String id) {
|
try {
|
KeyOrder keyOrder = keyOrderService.selectByIdForUpdate(id);
|
if (keyOrder == null) {
|
throw new Exception("订单不存在");
|
}
|
if (keyOrder.getState() == KeyOrder.STATE_PAY) {
|
throw new Exception("订单已支付");
|
}
|
loggerPay.info("canExcutePay[{}]: {}-{}", acceptData.getUid(), id, "可以支付");
|
return JsonUtil.loadTrueResult("");
|
} catch (Exception e) {
|
loggerPay.error("canExcutePay[{}]: {}-{}", acceptData.getUid(), id, "不可以支付：" + e.getMessage());
|
return JsonUtil.loadFalseResult(e.getMessage());
|
}
|
}
|
|
|
@ResponseBody
|
@RequestMapping("setPayResult")
|
public String setPayResult(AcceptData acceptData, String id, boolean paySuccess, String msg, String payMerchant) {
|
loggerPay.info("setPayResult[{}]: {}-{}-{}-{}", acceptData.getUid(), id, paySuccess, msg, payMerchant);
|
if (StringUtil.isNullOrEmpty(id)) {
|
return JsonUtil.loadFalseResult("请上传id");
|
}
|
KeyOrder order = keyOrderService.selectById(id);
|
if (order == null) {
|
return JsonUtil.loadFalseResult("口令不存在");
|
}
|
// if (StringUtil.isNullOrEmpty(order.getOrderNo())) {
|
// return JsonUtil.loadFalseResult("没有匹配到订单号");
|
// }
|
|
if (order.getState() == KeyOrder.STATE_NOT_PROCESS) {
|
if (!paySuccess) {
|
// 支付失败
|
if (msg != null && msg.contains("超时")) {
|
loggerPay.info(String.format("因为超时支付失败不处理：%s-%s", order.getId(), msg));
|
orderPayFailProcessor.processPayFail(order.getId(), msg);
|
} else {
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setState(KeyOrder.STATE_NOT_PAY);
|
orderUpdate.setStateDesc("支付失败：" + msg);
|
orderUpdate.setPayMerchant(payMerchant);
|
keyOrderService.update(orderUpdate);
|
}
|
loggerPay.info("处理支付失败完成");
|
} else {
|
try {
|
keyOrderService.paySuccess(id, "支付成功", TimeUtil.getGernalTime(System.currentTimeMillis(), Constant.DB_DAY_FORMAT), payMerchant);
|
loggerPay.info("处理支付成功完成");
|
} catch (WxOrderCountException e) {
|
loggerPay.error(e.getMessage());
|
e.printStackTrace();
|
return JsonUtil.loadFalseResult(e.getMessage());
|
}
|
}
|
}
|
return JsonUtil.loadTrueResult("");
|
}
|
|
|
@ResponseBody
|
@RequestMapping("rejectPay")
|
public String rejectPay(AcceptData acceptData, String id) {
|
loggerPay.info("rejectPay: {}-{}", acceptData.getUid(), id);
|
if (StringUtil.isNullOrEmpty(id)) {
|
return JsonUtil.loadFalseResult("请上传id");
|
}
|
KeyOrder order = keyOrderService.selectById(id);
|
if (order == null) {
|
return JsonUtil.loadFalseResult("口令不存在");
|
}
|
|
if (order.getState() != KeyOrder.STATE_NOT_PROCESS) {
|
return JsonUtil.loadFalseResult("只能驳回未执行状态的口令");
|
}
|
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setState(KeyOrder.STATE_REJECT_PAY);
|
orderUpdate.setStateDesc("人工驳回");
|
keyOrderService.update(orderUpdate);
|
|
return JsonUtil.loadTrueResult("");
|
}
|
|
|
@ResponseBody
|
@RequestMapping("deleteAll")
|
public String deleteAll(AcceptData acceptData, Long uid) {
|
|
ClientInfo user = clientInfoService.selectByPrimaryKey(uid);
|
if (user == null) {
|
return JsonUtil.loadFalseResult("用户不存在");
|
}
|
|
if (user.getRule() != ClientInfo.RULE_ADMIN) {
|
return JsonUtil.loadFalseResult("只有管理员才能删除");
|
}
|
|
// 删除10天之前的数据
|
keyOrderService.deleteAll(new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L * 10));
|
// keyOrderService.deleteAll(new Date(System.currentTimeMillis()));
|
// 刪除所有數據
|
return JsonUtil.loadTrueResult("");
|
}
|
|
|
public static void main(String[] args) {
|
|
Calendar calendar = Calendar.getInstance();
|
for (int i = 0; i < 7; i++) {
|
calendar.setTime(new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L * i));
|
int day = calendar.get(Calendar.DAY_OF_WEEK);
|
System.out.println(day - 1);
|
}
|
}
|
}
|
