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.WxOrderCountException;
|
import com.taoke.autopay.factory.OrderFactory;
|
import com.taoke.autopay.service.ClientInfoService;
|
import com.taoke.autopay.service.KeyOrderService;
|
import com.taoke.autopay.service.WxUserOrderCountService;
|
import com.taoke.autopay.service.WxUserSettingService;
|
import com.taoke.autopay.utils.JsonUtil;
|
import com.taoke.autopay.utils.StringUtil;
|
import com.taoke.autopay.utils.TimeUtil;
|
import com.taoke.autopay.utils.order.DYOrderApi;
|
import com.taoke.autopay.vo.AcceptData;
|
import com.taoke.autopay.vo.KeyOrderVO;
|
import com.taoke.autopay.vo.OrderFilter;
|
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.util.*;
|
|
/**
|
* @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;
|
|
|
@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();
|
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);
|
}
|
|
/**
|
* @return java.lang.String 返回是否可以去支付
|
* @author hxh
|
* @description 设置订单号
|
* @date 23:08 2024/6/24
|
* @param: acceptData
|
* @param: id 订单ID
|
* @param: orderNo 订单号
|
* @param: orderStatus 订单状态：订单已取消/已支付
|
**/
|
@ResponseBody
|
@RequestMapping("setOrderNo")
|
public String setOrderNo(AcceptData acceptData, String id, String orderNo, String orderStatus) {
|
loggerPay.info("setOrderNo: {}-{}-{}", id, orderNo, orderStatus);
|
if (StringUtil.isNullOrEmpty(id)) {
|
return JsonUtil.loadFalseResult("请上传id");
|
}
|
if (StringUtil.isNullOrEmpty(orderNo)) {
|
return JsonUtil.loadFalseResult("orderNo");
|
}
|
|
KeyOrder order = keyOrderService.selectById(id);
|
if (order == null) {
|
return JsonUtil.loadFalseResult("口令不存在");
|
}
|
|
try {
|
if (order.getOrderNo() != null && !order.getOrderNo().equalsIgnoreCase(orderNo)) {
|
throw new KeyOrderException("已经处理过，与之前处理的订单号不一致");
|
}
|
} catch (KeyOrderException e) {
|
return JsonUtil.loadFalseResult(e.getMessage());
|
}
|
|
try {
|
if (!StringUtil.isNullOrEmpty(orderStatus)) {
|
throw new KeyOrderException(orderStatus);
|
}
|
DYOrderDto dto = DYOrderApi.getOrderDetail(orderNo);
|
// dto.setOrder_status(1);
|
if (dto.getOrder_status() != DYOrderDto.ORDER_STATUS_NOT_PAY) {
|
// 订单不处于尚未付款状态
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setOrderState(dto.getOrder_status());
|
orderUpdate.setOrderType(1);
|
orderUpdate.setOrderNo(orderNo);
|
if (order.getState() == KeyOrder.STATE_NOT_PROCESS) {
|
if (dto.getOrder_status() == DYOrderDto.ORDER_STATUS_CANCELED) {
|
orderUpdate.setState(KeyOrder.STATE_PAY);
|
orderUpdate.setStateDesc(dto.getOrder_status_desc());
|
} else {
|
orderUpdate.setState(KeyOrder.STATE_PAY);
|
orderUpdate.setStateDesc(dto.getOrder_status_desc());
|
}
|
}
|
keyOrderService.update(orderUpdate);
|
if (dto.getOrder_status() == DYOrderDto.ORDER_STATUS_CANCELED) {
|
throw new Exception("订单已取消");
|
} else {
|
throw new Exception("订单已支付");
|
}
|
}
|
|
if (order.getUid() != null) {
|
WxUserOrderCount countInfo = wxUserOrderCountService.get(order.getUid(), OrderCountTypeEnum.DY_ORDER_PAY, TimeUtil.getGernalTime(System.currentTimeMillis(), "yyyyMMdd"));
|
if (countInfo != null) {
|
WxUserSettings settings = wxUserSettingService.selectByUid(order.getUid());
|
if (settings.getDyOrderCountPerDay() <= countInfo.getOrderCount()) {
|
throw new Exception("今日已达支付次数上限：" + settings.getDyOrderCountPerDay());
|
}
|
}
|
}
|
|
// 设置进入
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setOrderType(1);
|
orderUpdate.setOrderState(dto.getOrder_status());
|
orderUpdate.setOrderNo(orderNo);
|
orderUpdate.setExcutePayTime(new Date());
|
keyOrderService.update(orderUpdate);
|
order = keyOrderService.selectById(id);
|
return JsonUtil.loadTrueResult(gson.toJson(OrderFactory.create(order)));
|
} catch (KeyOrderException e) {
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setOrderType(1);
|
orderUpdate.setOrderState(0);
|
orderUpdate.setOrderNo(orderNo);
|
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());
|
}
|
}
|
|
@ResponseBody
|
@RequestMapping("setPayResult")
|
public String setPayResult(AcceptData acceptData, String id, boolean paySuccess, String msg) {
|
loggerPay.info("setPayResult: {}-{}", id, paySuccess);
|
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) {
|
// 支付失败
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setState(KeyOrder.STATE_NOT_PAY);
|
orderUpdate.setStateDesc("支付失败");
|
keyOrderService.update(orderUpdate);
|
} else {
|
KeyOrder orderUpdate = new KeyOrder();
|
orderUpdate.setId(id);
|
orderUpdate.setState(KeyOrder.STATE_PAY);
|
if (order.getPayTime() == null) {
|
orderUpdate.setPayTime(new Date());
|
}
|
orderUpdate.setStateDesc("支付成功");
|
try {
|
keyOrderService.paySuccess(id, "支付成功", TimeUtil.getGernalTime(System.currentTimeMillis(), "yyyyMMdd"));
|
} catch (WxOrderCountException e) {
|
e.printStackTrace();
|
return JsonUtil.loadFalseResult(e.getMessage());
|
}
|
}
|
}
|
return JsonUtil.loadTrueResult("");
|
}
|
|
|
@ResponseBody
|
@RequestMapping("rejectPay")
|
public String rejectPay(AcceptData acceptData, Long uid, String id) {
|
loggerPay.info("rejectPay: {}-{}", uid, 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("只有管理员才能删除");
|
}
|
|
// 删除24小时之前的数据
|
// keyOrderService.deleteAll(new Date(System.currentTimeMillis() - 24*60*60*1000L));
|
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);
|
}
|
}
|
}
|
