package com.taoke.autopay.service.impl.js2;
|
|
import com.taoke.autopay.dao.OrderTaskExecutionDetailMapper;
|
import com.taoke.autopay.dao.OrderTaskMapper;
|
import com.taoke.autopay.dto.js2.ClientCountDTO;
|
import com.taoke.autopay.entity.ClientInfo;
|
import com.taoke.autopay.entity.js2.OrderTask;
|
import com.taoke.autopay.entity.js2.OrderTaskExecutionDetail;
|
import com.taoke.autopay.exception.OrderTaskException;
|
import com.taoke.autopay.service.ClientInfoService;
|
import com.taoke.autopay.service.js2.OrderTaskExecutionDetailService;
|
import com.taoke.autopay.service.js2.OrderTaskService;
|
import com.taoke.autopay.utils.StringUtil;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
|
/**
|
* @author
|
* @title: OrderTaskServiceImpl
|
* @description: 下单任务服务实现类
|
* @date 2025/7/28
|
*/
|
@Service
|
public class OrderTaskServiceImpl implements OrderTaskService {
|
|
@Resource
|
private OrderTaskMapper orderTaskMapper;
|
|
@Resource
|
private OrderTaskExecutionDetailMapper orderTaskExecutionDetailMapper;
|
|
@Resource
|
private ClientInfoService clientInfoService;
|
@Autowired
|
private OrderTaskExecutionDetailService orderTaskExecutionDetailService;
|
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public OrderTask createOrderTask(OrderTask orderTask) throws OrderTaskException {
|
// 参数校验
|
if (orderTask == null) {
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "下单任务不能为空");
|
}
|
|
if(StringUtil.isNullOrEmpty(orderTask.getKeywordContent())){
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "下单任务口令不能为空");
|
}
|
|
if(orderTask.getProductSource()==null){
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "下单任务商品来源不能为空");
|
}
|
|
if(orderTask.getRequiredOrderCount()==null){
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "下单任务需求下单数量不能为空");
|
}
|
|
if(orderTask.getReceiveCycleMinutes()==null){
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "下单任务收货周期不能为空");
|
}
|
|
if(orderTask.getOrderStartTime()==null){
|
orderTask.setOrderStartTime(new Date());
|
}
|
|
if(orderTask.getOrderEndTime()==null){
|
orderTask.setOrderEndTime(new Date(System.currentTimeMillis()+1000*60*60*24L));
|
}
|
|
orderTask.setCompletedOrderCount(0);
|
orderTask.setReceivedOrderCount(0);
|
orderTask.setReviewedOrderCount(0);
|
|
// 设置创建时间
|
if (orderTask.getCreateTime() == null) {
|
orderTask.setCreateTime(new Date());
|
}
|
|
// 设置更新时间
|
orderTask.setUpdateTime(new Date());
|
|
// 插入数据库
|
orderTaskMapper.insertSelective(orderTask);
|
|
return orderTask;
|
}
|
|
@Override
|
public OrderTask getOrderTaskById(Long id) {
|
if (id == null) {
|
return null;
|
}
|
return orderTaskMapper.selectByPrimaryKey(id);
|
}
|
|
@Override
|
public List<OrderTask> getOrderTaskByIds(List<Long> ids) {
|
if(ids==null||ids.isEmpty()){
|
return new ArrayList<>();
|
}
|
return orderTaskMapper.listByIds(ids);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public OrderTask getOrderTaskByIdForUpdate(Long id) {
|
if (id == null) {
|
return null;
|
}
|
return orderTaskMapper.selectByPrimaryKeyForUpdate(id);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public void updateOrderTask(OrderTask orderTask) throws OrderTaskException {
|
// 参数校验
|
if (orderTask == null || orderTask.getId() == null) {
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "下单任务或任务ID不能为空");
|
}
|
|
// 设置更新时间
|
orderTask.setUpdateTime(new Date());
|
|
// 更新数据库
|
orderTaskMapper.updateByPrimaryKeySelective(orderTask);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public void deleteOrderTask(Long id) throws OrderTaskException {
|
if (id == null) {
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "任务ID不能为空");
|
}
|
|
// 删除数据库记录
|
orderTaskMapper.deleteByPrimaryKey(id);
|
}
|
|
@Override
|
public List<OrderTask> listOrderTasks(OrderTaskMapper.DaoQuery query, int page, int pageSize) {
|
if (query == null) {
|
query = new OrderTaskMapper.DaoQuery();
|
}
|
query.start = (long) (page - 1) * pageSize;
|
query.count = pageSize;
|
return orderTaskMapper.list(query);
|
}
|
|
@Override
|
public long countOrderTasks(OrderTaskMapper.DaoQuery query) {
|
if (query == null) {
|
query = new OrderTaskMapper.DaoQuery();
|
}
|
return orderTaskMapper.count(query);
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public int assignTask(Long taskId) throws OrderTaskException {
|
// 如果任务id对应的任务不存在，要抛出异常
|
if (taskId == null) {
|
throw new OrderTaskException(OrderTaskException.CODE_COMMON, "任务ID不能为空");
|
}
|
|
OrderTask orderTask = orderTaskMapper.selectByPrimaryKeyForUpdate(taskId);
|
if (orderTask == null) {
|
throw new OrderTaskException(OrderTaskException.CODE_TASK_NOT_FOUND, "任务不存在");
|
}
|
|
// 如果任务状态是已分配状态，返回状态
|
if (orderTask.getStatus() != null && orderTask.getStatus() == OrderTask.STATUS_ASSIGNED) {
|
return orderTask.getStatus();
|
}
|
|
// 通过查询OrderTaskExecutionDetail获取已经分配的客户端数量与客户端id；
|
OrderTaskExecutionDetailMapper.DaoQuery query = new OrderTaskExecutionDetailMapper.DaoQuery();
|
query.taskId = taskId;
|
query.count = Integer.MAX_VALUE;
|
List<OrderTaskExecutionDetail> executionDetails = orderTaskExecutionDetailMapper.list(query);
|
|
// 得到剩余的客户端数量
|
int assignedClientCount = executionDetails.size();
|
int requiredOrderCount = orderTask.getRequiredOrderCount() != null ? orderTask.getRequiredOrderCount() : 0;
|
int remainingClientCount = requiredOrderCount - assignedClientCount;
|
if(remainingClientCount<=0){
|
if(orderTask.getStatus() != OrderTask.STATUS_ASSIGNED){
|
orderTask.setStatus(OrderTask.STATUS_ASSIGNED);
|
orderTaskMapper.updateByPrimaryKeySelective(OrderTask.builder()
|
.id(orderTask.getId())
|
.status(OrderTask.STATUS_ASSIGNED)
|
.updateTime(new Date())
|
.build());
|
}
|
return OrderTask.STATUS_ASSIGNED;
|
}
|
|
// 获取可分配的设备
|
List<ClientInfo> clientInfoList = clientInfoService.getAvailableClientsForOrder();
|
// 剔除已经分配了的设备
|
Set<Long> excludeClientIds=new HashSet<>();
|
executionDetails.forEach(detail -> {
|
excludeClientIds.add( detail.getClientId());
|
});
|
for(int i=0;i<clientInfoList.size();i++){
|
if (excludeClientIds.contains(clientInfoList.get(i).getId())){
|
clientInfoList.remove(i);
|
i--;
|
}
|
}
|
// 统计所有设备正在执行任务的数量
|
List<ClientCountDTO> clientCountList = orderTaskExecutionDetailMapper.statisticClientIdsCountByStatus(Arrays.asList( new Integer[]{OrderTaskExecutionDetail.STATUS_NOT_ORDERED}));
|
Map<Long, Integer> clientCountMap = new HashMap<>();
|
for(ClientCountDTO dto:clientCountList){
|
clientCountMap.put(dto.getClientId(), dto.getCount());
|
}
|
// 剔除已经存在2个任务以上的设备
|
for(int i=0;i<clientInfoList.size();i++){
|
if(clientCountMap.containsKey(clientInfoList.get(i).getId())&&clientCountMap.get(clientInfoList.get(i).getId())>=2){
|
clientInfoList.remove(i);
|
i--;
|
}
|
}
|
|
clientInfoList.sort(new Comparator<ClientInfo>() {
|
@Override
|
public int compare(ClientInfo o1, ClientInfo o2) {
|
int count1 = clientCountMap.get(o1.getId())==null?0:clientCountMap.get(o1.getId());
|
int count2 = clientCountMap.get(o2.getId())==null?0:clientCountMap.get(o2.getId());
|
if(count1!=count2){
|
return count1-count2;
|
}
|
// 根据活跃时间排序
|
long time1 = o1.getActiveTime()==null?0:o1.getActiveTime().getTime();
|
long time2 = o2.getActiveTime()==null?0:o2.getActiveTime().getTime();
|
return time2-time1 > 0 ? 1:-1;
|
}
|
});
|
if(clientInfoList.size()>remainingClientCount){
|
clientInfoList = clientInfoList.subList(0, remainingClientCount);
|
}
|
|
// 分配任务
|
for(ClientInfo clientInfo:clientInfoList) {
|
OrderTaskExecutionDetail detail = OrderTaskExecutionDetail.builder()
|
.id(taskId + "-" + clientInfo.getId())
|
.taskId(taskId)
|
.clientId(clientInfo.getId())
|
.executionStatus(OrderTaskExecutionDetail.STATUS_NOT_ORDERED)
|
.createTime(new Date())
|
.statusDescription("未下单")
|
.build();
|
orderTaskExecutionDetailMapper.insertSelective(detail);
|
}
|
|
// 统计已经分配的客户端数量
|
OrderTaskExecutionDetailMapper.DaoQuery daoQuery=new OrderTaskExecutionDetailMapper.DaoQuery();
|
daoQuery.taskId = taskId;
|
long assignedCount = orderTaskExecutionDetailService.countOrderTaskExecutionDetails(daoQuery);
|
if(orderTask.getRequiredOrderCount()<=assignedCount){
|
// 更新状态
|
orderTaskMapper.updateByPrimaryKeySelective( OrderTask.builder().id(taskId)
|
.updateTime(new Date())
|
.statusDescription("已分配")
|
.status(OrderTask.STATUS_ASSIGNED).build());
|
}else{
|
orderTaskMapper.updateByPrimaryKeySelective( OrderTask.builder().id(taskId)
|
.updateTime(new Date())
|
.statusDescription("分配中")
|
.status(OrderTask.STATUS_ASSIGNING).build());
|
}
|
return orderTask.getStatus();
|
}
|
}
|
