package com.yeshi.fanli.service.impl.order.tb;
|
|
import java.util.Date;
|
import java.util.HashSet;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
import javax.annotation.Resource;
|
|
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.TransactionStatus;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.support.DefaultTransactionDefinition;
|
|
import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoOrderMapper;
|
import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoOrderTradeMapMapper;
|
import com.yeshi.fanli.entity.taobao.TaoBaoOrder;
|
import com.yeshi.fanli.entity.taobao.TaoBaoOrderTradeMap;
|
import com.yeshi.fanli.log.LogHelper;
|
import com.yeshi.fanli.service.inter.order.tb.TaoBaoOrderService;
|
import com.yeshi.fanli.util.Constant;
|
import com.yeshi.fanli.util.RedisManager;
|
import com.yeshi.fanli.util.StringUtil;
|
import com.yeshi.fanli.util.taobao.TaoBaoOrderUtil;
|
|
@Service
|
public class TaoBaoOrderServiceImpl implements TaoBaoOrderService {
|
|
@Resource
|
private TaoBaoOrderMapper taoBaoOrderMapper;
|
|
@Resource
|
private RedisManager redisManager;
|
|
@Resource
|
private TaoBaoOrderTradeMapMapper taoBaoOrderTradeMapMapper;
|
|
@Resource(name = "transactionManager")
|
private DataSourceTransactionManager transactionManager;
|
|
/**
|
* 获取订单的哈希值
|
*
|
* @param list
|
* @return
|
*/
|
|
@Override
|
public void addTaoBaoOrderList(List<TaoBaoOrder> list) {
|
if (list == null || list.size() == 0)
|
return;
|
Map<String, List<TaoBaoOrder>> map = TaoBaoOrderUtil.classifyTaoBaoOrderByOrderId(list);
|
Iterator<String> its = map.keySet().iterator();
|
while (its.hasNext()) {
|
String orderId = its.next();
|
String key = "addorder-" + TaoBaoOrderUtil.getOrderDataHashCode(map.get(orderId));
|
// redis做频率限制
|
try {
|
if (Constant.IS_OUTNET) {
|
if (!StringUtil.isNullOrEmpty(redisManager.getCommonString(key))) {
|
continue;
|
}
|
}
|
|
} catch (Exception e) {
|
|
}
|
|
addTaoBaoOrder(orderId, map.get(orderId));
|
try {
|
// 6小时内不再处理
|
if (Constant.IS_OUTNET)
|
redisManager.cacheCommonString(key, "1", 60 * 60 * 6);
|
} catch (Exception e) {
|
|
}
|
}
|
}
|
|
@Transactional
|
private void addTaoBaoOrderTradeMap(TaoBaoOrder order) {
|
if (order == null || StringUtil.isNullOrEmpty(order.getTradeId()))
|
return;
|
TaoBaoOrderTradeMap map = new TaoBaoOrderTradeMap();
|
map.setCreateTime(new Date());
|
map.setTaoBaoOrder(order);
|
map.setTradeId(order.getTradeId());
|
TaoBaoOrderTradeMap oldMap = taoBaoOrderTradeMapMapper.selectByTradeId(order.getTradeId());
|
if (oldMap == null)
|
taoBaoOrderTradeMapMapper.insertSelective(map);
|
}
|
|
@Transactional
|
@Override
|
public void addTaoBaoOrder(String orderId, List<TaoBaoOrder> list) {
|
TransactionStatus transactionStatus = transactionManager.getTransaction(new DefaultTransactionDefinition());
|
try {
|
|
LogHelper.test("订单号与订单数量:" + orderId + "-" + list.size());
|
|
// 验证orderby是否正确
|
if (list != null && list.size() > 0) {
|
int maxOrderBy = list.get(0).getOrderBy();
|
if (list.size() > 1)
|
for (TaoBaoOrder order : list) {
|
if (order.getOrderBy() > maxOrderBy)
|
maxOrderBy = order.getOrderBy();
|
}
|
|
if (list.size() != maxOrderBy) {
|
LogHelper.test("捕捉到排序值错误:" + orderId);
|
throw new Exception();
|
}
|
}
|
// 验证tradeId问题
|
Set<String> tradesIds = new HashSet<>();
|
for (TaoBaoOrder order : list) {
|
tradesIds.add(order.getTradeId());
|
}
|
|
// 有重复的交易ID不处理
|
if (tradesIds.size() != list.size()) {
|
LogHelper.test("检测到交易ID重复问题:" + orderId);
|
throw new Exception();
|
}
|
|
List<TaoBaoOrder> oldOrderList = taoBaoOrderMapper.selectTaoBaoOrderByOrderId(orderId);
|
if (oldOrderList == null || oldOrderList.size() == 0) {
|
for (TaoBaoOrder taoBaoOrder : list) {
|
taoBaoOrder.setLatestUpdateTime(new Date());
|
taoBaoOrderMapper.insertSelective(taoBaoOrder);
|
addTaoBaoOrderTradeMap(taoBaoOrder);
|
}
|
} else {
|
if (StringUtil.isNullOrEmpty(oldOrderList.get(0).getTradeId())) {
|
taoBaoOrderMapper.deleteByOrderId(orderId);
|
for (TaoBaoOrder taoBaoOrder : list) {
|
taoBaoOrder.setLatestUpdateTime(new Date());
|
taoBaoOrderMapper.insertSelective(taoBaoOrder);
|
addTaoBaoOrderTradeMap(taoBaoOrder);
|
}
|
} else {
|
// 按tradeId更新
|
for (TaoBaoOrder taoBaoOrder : list) {
|
TaoBaoOrder order = taoBaoOrderMapper.selectTaoBaoOrderByTradeId(taoBaoOrder.getTradeId());
|
if (order == null) {
|
taoBaoOrder.setLatestUpdateTime(new Date());
|
taoBaoOrderMapper.insertSelective(taoBaoOrder);
|
addTaoBaoOrderTradeMap(taoBaoOrder);
|
} else {
|
taoBaoOrder.setId(order.getId());
|
if (!StringUtil.isNullOrEmpty(order.getRelationId()))
|
taoBaoOrder.setRelationId(order.getRelationId());
|
if (!StringUtil.isNullOrEmpty(order.getSpecialId()))
|
taoBaoOrder.setSpecialId(order.getSpecialId());
|
taoBaoOrder.setLatestUpdateTime(new Date());
|
taoBaoOrderMapper.updateByPrimaryKeySelective(taoBaoOrder);
|
addTaoBaoOrderTradeMap(taoBaoOrder);
|
}
|
}
|
}
|
}
|
// 提交事务
|
transactionManager.commit(transactionStatus);
|
} catch (Exception e) {
|
transactionManager.rollback(transactionStatus);
|
}
|
}
|
|
@Override
|
public List<TaoBaoOrder> getTaoBaoOrderByOrderId(String orderId) {
|
return taoBaoOrderMapper.selectTaoBaoOrderByOrderId(orderId);
|
}
|
|
@Override
|
public double countEstimate(String date) throws Exception {
|
return taoBaoOrderMapper.countEstimate(date);
|
}
|
|
@Override
|
public void bindSpecialIdAndRealtionId(String tradeId, String specialId, String realtionId) {
|
if (StringUtil.isNullOrEmpty(specialId) && StringUtil.isNullOrEmpty(realtionId))
|
return;
|
TaoBaoOrder order = taoBaoOrderMapper.selectTaoBaoOrderByTradeId(tradeId);
|
if (order != null) {
|
TaoBaoOrder update = new TaoBaoOrder();
|
update.setId(order.getId());
|
update.setSpecialId(specialId);
|
update.setRelationId(realtionId);
|
update.setLatestUpdateTime(new Date());
|
taoBaoOrderMapper.updateByPrimaryKeySelective(update);
|
}
|
}
|
|
@Override
|
public TaoBaoOrder selectByTradeId(String tradeId) {
|
return taoBaoOrderMapper.selectTaoBaoOrderByTradeId(tradeId);
|
}
|
|
@Override
|
public List<TaoBaoOrder> listAllOrder(int page, int pageSize) {
|
return taoBaoOrderMapper.listAllOrder(null, (page - 1) * pageSize, pageSize);
|
}
|
|
@Override
|
public long countAllOrder() {
|
return taoBaoOrderMapper.countAllOrder(null);
|
}
|
|
@Override
|
public TaoBaoOrder selectByPrimaryKey(Long id) {
|
return taoBaoOrderMapper.selectByPrimaryKey(id);
|
}
|
|
@Override
|
public List<TaoBaoOrder> listBySettlementTime(Long minTime, Long maxTime, int page, int pageSize) {
|
|
return taoBaoOrderMapper.listBySettlementTime(minTime, maxTime, (page - 1) * pageSize, pageSize);
|
}
|
|
@Override
|
public Long countBySettlementTime(Long minTime, Long maxTime) {
|
return taoBaoOrderMapper.countBySettlementTime(minTime, maxTime);
|
}
|
|
@Override
|
public List<TaoBaoOrder> listByStateAndCreateTime(String state, Date minCreateTime, Date maxCreateTime) {
|
return taoBaoOrderMapper.listByStateAndCreateTime(state, minCreateTime.getTime(), maxCreateTime.getTime());
|
}
|
|
}
|
