package com.yeshi.fanli.service.impl.order;
|
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
|
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;
|
|
import javax.annotation.Resource;
|
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.yeshi.fanli.dao.mybatis.order.LostOrderMapper;
|
import com.yeshi.fanli.entity.bus.user.HongBaoV2;
|
import com.yeshi.fanli.entity.bus.user.LostOrder;
|
import com.yeshi.fanli.entity.bus.user.Order;
|
import com.yeshi.fanli.service.inter.config.ConfigService;
|
import com.yeshi.fanli.service.inter.order.HongBaoOrderService;
|
import com.yeshi.fanli.service.inter.order.LostOrderService;
|
import com.yeshi.fanli.service.inter.order.OrderService;
|
import com.yeshi.fanli.service.inter.order.msg.UserOrderMsgNotificationService;
|
import com.yeshi.fanli.service.inter.taobao.TaoBaoPunishOrderService;
|
import com.yeshi.fanli.util.Utils;
|
|
@Service
|
public class LostOrderServiceImpl implements LostOrderService {
|
|
@Resource
|
private OrderService orderService;
|
|
@Resource
|
private HongBaoOrderService hongBaoOrderService;
|
|
@Resource
|
private LostOrderMapper lostOrderMapper;
|
|
@Resource
|
private ConfigService configService;
|
|
@Resource
|
private UserOrderMsgNotificationService userOrderMsgNotificationService;
|
|
@Resource
|
private TaoBaoPunishOrderService taoBaoPunishOrderService;
|
|
@Transactional
|
@Override
|
public int addLostOrder(LostOrder lostOrder) {
|
String orderId = lostOrder.getOrderId();
|
Integer type = lostOrder.getType();
|
if (type == null) { // 默认为淘宝订单
|
lostOrder.setType(1);
|
type = 1;
|
}
|
|
// 是否处于违规订单中
|
if (type == 1) {
|
int count = taoBaoPunishOrderService.countByTradeParentId(orderId);
|
if (count > 0) {
|
return -1001;
|
}
|
}
|
|
// 订单是否已申诉
|
List<LostOrder> orderList = lostOrderMapper.selectByOrderIdAndType(orderId, type);
|
if (orderList != null && orderList.size() > 0) {
|
if (orderList.get(0).getState() == 0 || orderList.get(0).getResultCode() == LostOrder.RESULT_CODE_VERFING) {
|
return -2;
|
} else if (orderList.get(0).getState() == 1
|
&& orderList.get(0).getResultCode() == LostOrder.RESULT_CODE_SUCCESS) {
|
return -1;
|
} else {
|
return -6;
|
}
|
}
|
|
// 订单已存在
|
Order order = orderService.findOrderByOrderIdAndType(orderId, type);
|
if (order != null) {
|
return -3;
|
}
|
|
// 是否为分享赚订单
|
if (hongBaoOrderService.countByOrderNoAndHongBaoType(orderId, HongBaoV2.TYPE_SHARE_GOODS, type) > 0)
|
return -5;
|
|
// 次数限制
|
long count = lostOrderMapper.countTodayAppeal(lostOrder.getUserInfo().getId());
|
String countMax = configService.get("order_appeal_count_day");
|
if (countMax != null && countMax.trim().length() > 0 && count >= Long.parseLong(countMax)) {
|
return -7;
|
}
|
|
WriteLock lostOrderwriteLock = lostOrderLock.writeLock();
|
ReadLock lostOrderReadLock = lostOrderLock.readLock();
|
try {
|
try {
|
lostOrderwriteLock.lock();
|
List<Integer> stateList = new ArrayList<>();
|
stateList.add(0);
|
stateList.add(1);
|
List<LostOrder> list = lostOrderMapper.listByOrderIdAndTypeAndState(orderId, type, stateList);
|
if (list.size() > 0) {
|
LostOrder find = list.get(0);
|
Integer state = find.getState();
|
if (state == 0) {
|
return -2;
|
} else if (state == 1) {
|
return -1;
|
}
|
}
|
} finally {
|
lostOrderReadLock.lock();
|
lostOrderwriteLock.unlock();
|
}
|
|
Order or = orderService.getSystemOrderByUid(type, lostOrder.getUserInfo().getId());
|
if (or != null) {
|
boolean b = Utils.isUserOrder(or.getOrderId(), lostOrder.getOrderId());
|
if (b) {
|
lostOrder.setJudge("匹配");
|
|
} else {
|
lostOrder.setJudge("不匹配");
|
}
|
} else {
|
lostOrder.setJudge("不匹配");
|
}
|
|
try {
|
Order addorder = new Order();
|
addorder.setBeizhu("补单");
|
addorder.setCreatetime(lostOrder.getCreateTime());
|
addorder.setOrderId(lostOrder.getOrderId());
|
addorder.setOrderType(lostOrder.getType());
|
addorder.setState(1);
|
addorder.setUserInfo(lostOrder.getUserInfo());
|
|
boolean b = orderService.addOrder(addorder);
|
if (b) {
|
lostOrder.setRemake("处理成功");
|
lostOrder.setState(LostOrder.STATE_PASS);
|
lostOrder.setOrder(order);
|
} else {
|
lostOrder.setRemake("订单已存在!");
|
lostOrder.setState(LostOrder.STATE_REJECT);
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
String message = e.getMessage();
|
if (message.length() > 255) {
|
message = message.substring(0, 255);
|
}
|
lostOrder.setRemake(e.getMessage());
|
lostOrder.setState(LostOrder.STATE_REJECT);
|
}
|
|
lostOrder.setResultCode(LostOrder.RESULT_CODE_VERFING);
|
lostOrder.setHandleTime(System.currentTimeMillis());
|
lostOrder.setCreateTime(System.currentTimeMillis());
|
lostOrderMapper.insertSelective(lostOrder);
|
|
} finally {
|
lostOrderReadLock.unlock();
|
}
|
return 0;
|
}
|
|
public void pass(LostOrder lostOrder) {
|
Order order = new Order();
|
order.setBeizhu("补单");
|
order.setCreatetime(lostOrder.getCreateTime());
|
order.setOrderId(lostOrder.getOrderId());
|
order.setOrderType(lostOrder.getType());
|
order.setState(1);
|
order.setUserInfo(lostOrder.getUserInfo());
|
try {
|
boolean b = orderService.addOrder(order);
|
if (b) {
|
lostOrder.setRemake("处理成功");
|
lostOrder.setState(1);
|
lostOrder.setOrder(order);
|
} else {
|
lostOrder.setRemake("订单已存在!");
|
lostOrder.setState(2);
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
String message = e.getMessage();
|
if (message.length() > 255) {
|
message = message.substring(0, 255);
|
}
|
lostOrder.setRemake(e.getMessage());
|
lostOrder.setState(2);
|
}
|
lostOrder.setHandleTime(System.currentTimeMillis());
|
lostOrder.setResultCode(LostOrder.RESULT_CODE_VERFING);
|
lostOrderMapper.updateByPrimaryKeySelective(lostOrder);
|
}
|
|
public void reject(LostOrder lostOrder) {
|
lostOrder.setHandleTime(System.currentTimeMillis());
|
lostOrder.setState(2);
|
lostOrderMapper.updateByPrimaryKeySelective(lostOrder);
|
}
|
|
@Override
|
public LostOrder getOne(long id) {
|
return lostOrderMapper.selectByPrimaryKey(id);
|
}
|
|
@Override
|
public List<LostOrder> getLostOrderListByUid(Long uid, int page, int pageSize) {
|
|
return lostOrderMapper.listByUidOrderByCreateTimeDesc(uid, (page - 1) * pageSize, pageSize);
|
}
|
|
@Override
|
public long getLostOrderCountByUid(Long uid) {
|
return lostOrderMapper.countAllByUid(uid);
|
}
|
|
@Transactional
|
@Override
|
public void processSuceess(String orderId, int orderType) {
|
// 查询订单号是否在申诉列表中
|
List<LostOrder> list = lostOrderMapper.selectByOrderIdAndType(orderId, orderType);
|
if (list == null || list.size() == 0)
|
return;
|
for (LostOrder lo : list) {
|
if (lo.getState() == LostOrder.STATE_PASS && lo.getResultCode() != null
|
&& lo.getResultCode() == LostOrder.RESULT_CODE_VERFING) {
|
LostOrder update = new LostOrder();
|
update.setId(lo.getId());
|
update.setResultCode(LostOrder.RESULT_CODE_SUCCESS);
|
lostOrderMapper.updateByPrimaryKeySelective(update);
|
Order order = orderService.findOrderByOrderIdAndType(orderId, Order.ORDER_TYPE_TAOBAO);
|
if (order != null)
|
// 添加通知
|
userOrderMsgNotificationService.orderFoundSuccess(lo.getUserInfo().getId(), lo.getOrderId(),
|
order.getMoney(), 1, new Date(lo.getHandleTime()));
|
}
|
}
|
}
|
|
@Override
|
public void processFail(String orderId, int orderType) {
|
List<LostOrder> list = lostOrderMapper.selectByOrderIdAndType(orderId, orderType);
|
if (list != null)
|
for (LostOrder order : list) {
|
LostOrder update = new LostOrder();
|
update.setId(order.getId());
|
update.setResultCode(LostOrder.RESULT_CODE_FAIL);
|
lostOrderMapper.updateByPrimaryKeySelective(update);
|
// 添加通知
|
userOrderMsgNotificationService.orderFoundFail(order.getUserInfo().getId(), order.getOrderId(), null, 1,
|
new Date(order.getHandleTime()));
|
}
|
}
|
|
@Override
|
public void processFail() {
|
// 订单申诉人工通过后，但是隔了3天还未处理成功就视为该订单申诉失败
|
List<LostOrder> list = lostOrderMapper.listByMaxHandleTimeAndStateAndResultCode(
|
System.currentTimeMillis() - 1000 * 60 * 60 * 24 * 3L, LostOrder.STATE_PASS,
|
LostOrder.RESULT_CODE_VERFING);
|
if (list != null)
|
for (LostOrder order : list) {
|
LostOrder update = new LostOrder();
|
update.setId(order.getId());
|
update.setResultCode(LostOrder.RESULT_CODE_FAIL);
|
lostOrderMapper.updateByPrimaryKeySelective(update);
|
// 添加通知
|
userOrderMsgNotificationService.orderFoundFail(order.getUserInfo().getId(), order.getOrderId(), null, 1,
|
new Date(order.getHandleTime()));
|
}
|
}
|
|
@Override
|
public void deleteLostOrder(long id) {
|
lostOrderMapper.deleteByPrimaryKey(id);
|
}
|
|
@Override
|
public void deleteLostOrderByUid(long uid) {
|
|
lostOrderMapper.deleteByUid(uid);
|
}
|
|
@Override
|
public Map<String, Object> countByUid(long uid) {
|
return lostOrderMapper.countByUid(uid);
|
}
|
|
/**
|
* 后端列表查询
|
*
|
* @param start
|
* @param count
|
* @param key
|
* @return
|
*/
|
@Override
|
public List<LostOrder> listQuery(long start, int count, String key, Integer state, Integer handleType,
|
Integer type) {
|
return lostOrderMapper.listQuery(start, count, key, state, handleType, type);
|
}
|
|
@Override
|
public long countQuery(String key, Integer state, Integer handleType, Integer type) {
|
return lostOrderMapper.countQuery(key, state, handleType, type);
|
}
|
|
@Override
|
public List<Map<String, Object>> countLostNum(Integer dateType, Integer resultCode, String year, String startTime,
|
String endTime) throws Exception {
|
return lostOrderMapper.countLostNum(dateType, resultCode, year, startTime, endTime);
|
}
|
|
@Override
|
public List<Map<String, Object>> countAppealMoney(Integer dateType, String year, String startTime, String endTime)
|
throws Exception {
|
return lostOrderMapper.countAppealMoney(dateType, year, startTime, endTime);
|
}
|
|
@Override
|
public List<LostOrder> listByStateAndResultCode(int state, int resultCode, int page, int pageSize) {
|
return lostOrderMapper.listByStateAndResultCode(state, resultCode, (page - 1) * pageSize, pageSize);
|
}
|
|
@Override
|
public void saveLostOrder(LostOrder lostOrder) {
|
lostOrderMapper.insertSelective(lostOrder);
|
}
|
|
}
|
