yovinchen/sl-express
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
shuhongfan
2023-09-04 16:40:17 +08:00
commit cf5ac25c14
8267 changed files with 1305066 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
sl-express-ms-work-service/.gitignore vendored Normal file
View File

@@ -0,0 +1,3 @@
.idea
target/
*.iml

13
sl-express-ms-work-service/Dockerfile Normal file
View File

@@ -0,0 +1,13 @@
FROM openjdk:11-jdk
LABEL maintainer="研究院研发组 <research@itcast.cn>"
# 时区修改为东八区
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
WORKDIR /app
ARG JAR_FILE=target/*.jar
ADD ${JAR_FILE} app.jar
EXPOSE 8080
ENTRYPOINT ["sh","-c","java -Djava.security.egd=file:/dev/./urandom -jar $JAVA_OPTS app.jar"]

156
sl-express-ms-work-service/pom.xml Normal file
View File

@@ -0,0 +1,156 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.sl-express</groupId>
<artifactId>sl-express-parent</artifactId>
<version>1.4</version>
</parent>
<groupId>com.sl-express.ms.work</groupId>
<artifactId>sl-express-ms-work-service</artifactId>
<version>1.1-SNAPSHOT</version>
<description>运单、取派件任务微服务</description>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<sl-express-common.version>1.2-SNAPSHOT</sl-express-common.version>
<sl-express-ms-transport-api.version>1.1-SNAPSHOT</sl-express-ms-transport-api.version>
<sl-express-ms-track-api.version>1.1-SNAPSHOT</sl-express-ms-track-api.version>
<sl-express-ms-search-api.version>1.1-SNAPSHOT</sl-express-ms-search-api.version>
<sl-express-ms-work-domain.version>1.1-SNAPSHOT</sl-express-ms-work-domain.version>
<sl-express-ms-base-api.version>1.1-SNAPSHOT</sl-express-ms-base-api.version>
<sl-express-ms-oms-api.version>1.1-SNAPSHOT</sl-express-ms-oms-api.version>
<sl-express-ms-mq-api.version>1.1-SNAPSHOT</sl-express-ms-mq-api.version>
<sl-express-ms-driver-api.version>1.1-SNAPSHOT</sl-express-ms-driver-api.version>
</properties>
<dependencies>
<dependency>
<groupId>com.sl-express.common</groupId>
<artifactId>sl-express-common</artifactId>
<version>${sl-express-common.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.ms.work</groupId>
<artifactId>sl-express-ms-work-domain</artifactId>
<version>${sl-express-ms-work-domain.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.ms.base</groupId>
<artifactId>sl-express-ms-base-api</artifactId>
<version>${sl-express-ms-base-api.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.ms.oms</groupId>
<artifactId>sl-express-ms-oms-api</artifactId>
<version>${sl-express-ms-oms-api.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.mq</groupId>
<artifactId>sl-express-mq</artifactId>
<version>${sl-express-ms-mq-api.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.ms.driver</groupId>
<artifactId>sl-express-ms-driver-api</artifactId>
<version>${sl-express-ms-driver-api.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.ms.transport</groupId>
<artifactId>sl-express-ms-transport-api</artifactId>
<version>${sl-express-ms-transport-api.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.ms.track</groupId>
<artifactId>sl-express-ms-track-api</artifactId>
<version>${sl-express-ms-track-api.version}</version>
</dependency>
<dependency>
<groupId>com.sl-express.ms.search</groupId>
<artifactId>sl-express-ms-search-api</artifactId>
<version>${sl-express-ms-search-api.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
</dependency>
<!--seata-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<dependency>
<groupId>biz.paluch.logging</groupId>
<artifactId>logstash-gelf</artifactId>
<version>1.15.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
<goal>build-info</goal>
</goals>
</execution>
</executions>
<configuration>
<!--指定主类-->
<mainClass>com.sl.WorkApplication</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>

17
sl-express-ms-work-service/src/main/java/com/sl/WorkApplication.java Normal file
View File

@@ -0,0 +1,17 @@
package com.sl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.retry.annotation.Retryable;
@Retryable
@EnableFeignClients
@SpringBootApplication
public class WorkApplication {
public static void main(String[] args) {
SpringApplication.run(WorkApplication.class, args);
}
}

35
sl-express-ms-work-service/src/main/java/com/sl/ms/work/config/RedissonConfiguration.java Normal file
View File

@@ -0,0 +1,35 @@
package com.sl.ms.work.config;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.StrUtil;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
@Configuration
public class RedissonConfiguration {
@Resource
private RedisProperties redisProperties;
@Bean
public RedissonClient redissonSingle() {
Config config = new Config();
SingleServerConfig serverConfig = config.useSingleServer()
.setAddress("redis://" + redisProperties.getHost() + ":" + redisProperties.getPort());
if (null != (redisProperties.getTimeout())) {
serverConfig.setTimeout(1000 * Convert.toInt(redisProperties.getTimeout().getSeconds()));
}
if (StrUtil.isNotEmpty(redisProperties.getPassword())) {
serverConfig.setPassword(redisProperties.getPassword());
}
return Redisson.create(config);
}
}

157
sl-express-ms-work-service/src/main/java/com/sl/ms/work/controller/PickupDispatchTaskController.java Normal file
View File

@@ -0,0 +1,157 @@
package com.sl.ms.work.controller;
import cn.hutool.core.bean.BeanUtil;
import com.sl.ms.work.domain.dto.CourierTaskCountDTO;
import com.sl.ms.work.domain.dto.PickupDispatchTaskDTO;
import com.sl.ms.work.domain.dto.request.PickupDispatchTaskPageQueryDTO;
import com.sl.ms.work.domain.dto.response.PickupDispatchTaskStatisticsDTO;
import com.sl.ms.work.domain.enums.WorkExceptionEnum;
import com.sl.ms.work.domain.enums.pickupDispatchtask.PickupDispatchTaskIsDeleted;
import com.sl.ms.work.domain.enums.pickupDispatchtask.PickupDispatchTaskStatus;
import com.sl.ms.work.domain.enums.pickupDispatchtask.PickupDispatchTaskType;
import com.sl.ms.work.entity.PickupDispatchTaskEntity;
import com.sl.ms.work.service.PickupDispatchTaskService;
import com.sl.transport.common.exception.SLException;
import com.sl.transport.common.util.ObjectUtil;
import com.sl.transport.common.util.PageResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
/**
* 取件、派件任务信息表 前端控制器
*/
@RestController
@Api(tags = "取派件任务")
@RequestMapping("pickup-dispatch-task")
public class PickupDispatchTaskController {
@Resource
private PickupDispatchTaskService pickupDispatchTaskService;
@PutMapping
@ApiOperation(value = "更新取派件任务状态", notes = "更新状态，不允许 NEW 状态")
public Boolean updateStatus(@RequestBody PickupDispatchTaskDTO pickupDispatchTaskDTO) {
return this.pickupDispatchTaskService.updateStatus(pickupDispatchTaskDTO);
}
@PutMapping("courier")
@ApiOperation(value = "批量改派快递员", notes = "批量改派快递员")
@ApiImplicitParams({
@ApiImplicitParam(name = "ids", value = "任务id列表", required = true),
@ApiImplicitParam(name = "originalCourierId", value = "原快递员id", required = true),
@ApiImplicitParam(name = "targetCourierId", value = "目标快递员id", required = true),
})
public Boolean updateCourierId(@RequestParam("ids") List<Long> ids,
@RequestParam("originalCourierId") Long originalCourierId,
@RequestParam("targetCourierId") Long targetCourierId) {
return this.pickupDispatchTaskService.updateCourierId(ids, originalCourierId, targetCourierId);
}
@PostMapping("page")
@ApiOperation(value = "分页查询", notes = "获取取派件任务分页数据")
public PageResponse<PickupDispatchTaskDTO> findByPage(@RequestBody PickupDispatchTaskPageQueryDTO dto) {
return this.pickupDispatchTaskService.findByPage(dto);
}
@GetMapping("{id}")
@ApiOperation(value = "id查询", notes = "根据id获取取派件任务信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "任务id")
})
public PickupDispatchTaskDTO findById(@PathVariable("id") Long id) {
PickupDispatchTaskEntity pickupDispatchTask = this.pickupDispatchTaskService.getById(id);
if (ObjectUtil.isEmpty(pickupDispatchTask)) {
throw new SLException(WorkExceptionEnum.PICKUP_DISPATCH_TASK_NOT_FOUND);
}
return BeanUtil.toBean(pickupDispatchTask, PickupDispatchTaskDTO.class);
}
@GetMapping("ids")
@ApiOperation(value = "id批量查询", notes = "根据id批量查询取派件任务信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "ids", value = "任务id列表")
})
public List<PickupDispatchTaskDTO> findByIds(@RequestParam("ids") List<Long> ids) {
List<PickupDispatchTaskEntity> list = this.pickupDispatchTaskService.listByIds(ids);
return BeanUtil.copyToList(list, PickupDispatchTaskDTO.class);
}
@DeleteMapping("ids")
@ApiOperation(value = "id批量删除", notes = "根据id批量删除取派件任务信息（逻辑删除）")
@ApiImplicitParams({
@ApiImplicitParam(name = "ids", value = "任务id列表")
})
public boolean deleteByIds(@RequestParam("ids") List<Long> ids) {
return this.pickupDispatchTaskService.deleteByIds(ids);
}
@GetMapping("/orderId/{orderId}/{taskType}")
@ApiOperation(value = "订单id查询", notes = "根据订单id获取取派件任务信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "orderId", value = "订单id"),
@ApiImplicitParam(name = "taskType", value = "任务类型")
})
public List<PickupDispatchTaskDTO> findByOrderId(@PathVariable("orderId") Long orderId,
@PathVariable("taskType") PickupDispatchTaskType taskType) {
List<PickupDispatchTaskEntity> entities = pickupDispatchTaskService.findByOrderId(orderId, taskType);
return BeanUtil.copyToList(entities, PickupDispatchTaskDTO.class);
}
@GetMapping("count")
@ApiOperation(value = "任务数量查询", notes = "按照当日快递员id列表查询每个快递员的取派件任务数")
@ApiImplicitParams({
@ApiImplicitParam(name = "courierIds", value = "订单id列表", required = true),
@ApiImplicitParam(name = "taskType", value = "任务类型", required = true),
@ApiImplicitParam(name = "date", value = "日期，格式：yyyy-MM-dd 或 yyyyMMdd", required = true)
})
public List<CourierTaskCountDTO> findCountByCourierIds(@RequestParam("courierIds") List<Long> courierIds,
@RequestParam("taskType") PickupDispatchTaskType taskType,
@RequestParam("date") String date) {
return this.pickupDispatchTaskService.findCountByCourierIds(courierIds, taskType, date);
}
@GetMapping("todayTasks/count")
@ApiOperation(value = "今日任务分类计数")
@ApiImplicitParams({
@ApiImplicitParam(name = "courierId", value = "快递员id", required = true, dataTypeClass = Long.class),
@ApiImplicitParam(name = "taskType", value = "任务类型，1为取件任务，2为派件任务", dataTypeClass = PickupDispatchTaskType.class),
@ApiImplicitParam(name = "status", value = "任务状态,1新任务，2已完成，3已取消", dataTypeClass = PickupDispatchTaskStatus.class),
@ApiImplicitParam(name = "isDeleted", value = "是否逻辑删除", dataTypeClass = PickupDispatchTaskIsDeleted.class)
})
public Integer todayTasksCount(@RequestParam("courierId") Long courierId,
@RequestParam(value = "taskType", required = false) PickupDispatchTaskType taskType,
@RequestParam(value = "status", required = false) PickupDispatchTaskStatus status,
@RequestParam(value = "isDeleted", required = false) PickupDispatchTaskIsDeleted isDeleted) {
return pickupDispatchTaskService.todayTasksCount(courierId, taskType, status, isDeleted);
}
@GetMapping("/all")
@ApiOperation(value = "条件查询所有")
@ApiImplicitParams({
@ApiImplicitParam(name = "courierId", value = "快递员id", dataTypeClass = Long.class),
@ApiImplicitParam(name = "taskType", value = "任务类型，1为取件任务，2为派件任务", dataTypeClass = PickupDispatchTaskType.class),
@ApiImplicitParam(name = "taskStatus", value = "任务状态,1新任务，2已完成，3已取消", dataTypeClass = PickupDispatchTaskStatus.class),
@ApiImplicitParam(name = "isDeleted", value = "是否逻辑删除", dataTypeClass = PickupDispatchTaskIsDeleted.class)
})
public List<PickupDispatchTaskDTO> findAll(@RequestParam(name = "courierId", required = false) Long courierId,
@RequestParam(name = "taskType", required = false) PickupDispatchTaskType taskType,
@RequestParam(name = "taskStatus", required = false) PickupDispatchTaskStatus taskStatus,
@RequestParam(name = "isDeleted", required = false) PickupDispatchTaskIsDeleted isDeleted) {
return pickupDispatchTaskService.findAll(courierId, taskType, taskStatus, isDeleted);
}
@GetMapping("/todayTasksStatistics")
@ApiOperation(value = "今日任务分类统计")
@ApiImplicitParams({
@ApiImplicitParam(name = "courierId", value = "快递员id", dataTypeClass = Long.class)
})
public PickupDispatchTaskStatisticsDTO todayTasksStatistics(@RequestParam(value = "courierId", required = false) Long courierId) {
return pickupDispatchTaskService.todayTaskStatistics(courierId);
}
}

176
sl-express-ms-work-service/src/main/java/com/sl/ms/work/controller/TransportOrderController.java Normal file
View File

@@ -0,0 +1,176 @@
package com.sl.ms.work.controller;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sl.ms.work.domain.dto.TransportOrderDTO;
import com.sl.ms.work.domain.dto.request.TransportOrderQueryDTO;
import com.sl.ms.work.domain.dto.response.OrderToTransportOrderDTO;
import com.sl.ms.work.domain.dto.response.TransportOrderStatusCountDTO;
import com.sl.ms.work.domain.enums.WorkExceptionEnum;
import com.sl.ms.work.domain.enums.transportorder.TransportOrderSchedulingStatus;
import com.sl.ms.work.domain.enums.transportorder.TransportOrderStatus;
import com.sl.ms.work.entity.TransportOrderEntity;
import com.sl.ms.work.service.TransportOrderService;
import com.sl.transport.common.exception.SLException;
import com.sl.transport.common.util.PageResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 运单表 前端控制器
*/
@Slf4j
@RestController
@Api(tags = "运单服务")
@RequestMapping("transport-order")
public class TransportOrderController {
@Resource
private TransportOrderService transportOrderService;
@PostMapping
@ApiOperation(value = "新增运单", notes = "新增运单（订单转运单）")
@ApiImplicitParam(name = "orderId", value = "订单id", required = true)
public OrderToTransportOrderDTO orderToTransportOrder(@RequestParam("orderId") Long orderId) {
TransportOrderEntity transportOrderEntity = this.transportOrderService.orderToTransportOrder(orderId);
return BeanUtil.toBean(transportOrderEntity, OrderToTransportOrderDTO.class);
}
@PutMapping
@ApiOperation(value = "更新状态", notes = "更新状态，不允许 CREATED 状态")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "运单id", required = true),
@ApiImplicitParam(name = "status", value = "订单状态", required = true),
})
public Boolean updateStatus(@RequestParam("id") String id,
@RequestParam("status") TransportOrderStatus status) {
return this.transportOrderService.updateStatus(Arrays.asList(id), status);
}
@PostMapping("page")
@ApiOperation(value = "分页查询", notes = "获取运单分页数据")
public PageResponse<TransportOrderDTO> findByPage(@RequestBody TransportOrderQueryDTO transportOrderQueryDTO) {
Page<TransportOrderEntity> pageResult = this.transportOrderService.findByPage(transportOrderQueryDTO);
return new PageResponse<>(pageResult, TransportOrderDTO.class);
}
@GetMapping("{id}")
@ApiOperation(value = "id查询", notes = "根据id获取运单信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "运单号", required = true)
})
public TransportOrderDTO findById(@PathVariable("id") String id) {
TransportOrderEntity transportOrder = this.transportOrderService.getById(id);
if (ObjectUtil.isEmpty(transportOrder)) {
throw new SLException(WorkExceptionEnum.TRANSPORT_ORDER_NOT_FOUND);
}
return BeanUtil.toBean(transportOrder, TransportOrderDTO.class);
}
@ApiOperation(value = "id查询", notes = "根据运单ids批量获取订单id")
@GetMapping("/batch")
List<TransportOrderDTO> findByIds(@RequestParam("ids") String[] ids) {
List<TransportOrderEntity> list = this.transportOrderService.findByIds(ids);
if (CollUtil.isEmpty(list)) {
throw new SLException(WorkExceptionEnum.TRANSPORT_ORDER_NOT_FOUND);
}
return BeanUtil.copyToList(list, TransportOrderDTO.class);
}
@GetMapping("orderId/{orderId}")
@ApiOperation(value = "订单id查询", notes = "根据订单id获取运单信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "orderId", value = "订单id", required = true)
})
public TransportOrderDTO findByOrderId(@PathVariable("orderId") Long orderId) {
TransportOrderEntity transportOrder = this.transportOrderService.findByOrderId(orderId);
if (ObjectUtil.isEmpty(transportOrder)) {
throw new SLException(WorkExceptionEnum.TRANSPORT_ORDER_NOT_FOUND);
}
return BeanUtil.toBean(transportOrder, TransportOrderDTO.class);
}
@PostMapping("list")
@ApiOperation(value = "订单id列表查询", notes = "根据多个订单id查询运单信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "orderIds", value = "订单id列表", required = true)
})
public List<TransportOrderDTO> findByOrderIds(@RequestParam(name = "orderIds") Long[] orderIds) {
List<TransportOrderEntity> list = this.transportOrderService.findByOrderIds(orderIds);
if (CollUtil.isEmpty(list)) {
return new ArrayList<>();
}
return BeanUtil.copyToList(list, TransportOrderDTO.class);
}
@GetMapping("search")
@ApiOperation(value = "搜索运单", notes = "根据运单号搜索运单")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "运单号", required = true)
})
public List<TransportOrderDTO> searchById(@RequestParam("id") String id) {
List<TransportOrderEntity> entityList = this.transportOrderService.searchById(id);
if (CollUtil.isEmpty(entityList)) {
return ListUtil.empty();
}
return BeanUtil.copyToList(entityList, TransportOrderDTO.class);
}
@GetMapping("count")
@ApiOperation(value = "统计", notes = "统计各个状态的数量")
public List<TransportOrderStatusCountDTO> findStatusCount() {
return this.transportOrderService.findStatusCount();
}
@PutMapping("updateByTaskId/{taskId}")
@ApiOperation(value = "根据运输任务id修改运单", notes = "根据运输任务id批量修改运单，其中会涉及到下一个节点的流转，已经发送消息的业务")
@ApiImplicitParams({
@ApiImplicitParam(name = "taskId", value = "运输任务id", required = true)
})
public boolean updateByTaskId(@PathVariable("taskId") String taskId) {
return transportOrderService.updateByTaskId(Long.valueOf(taskId));
}
@PutMapping("batchUpdate")
@ApiOperation(value = "批量更新状态", notes = "批量更新状态，不允许 CREATED 状态")
@ApiImplicitParams({
@ApiImplicitParam(name = "ids", value = "运单id列表", required = true),
@ApiImplicitParam(name = "status", value = "订单状态", required = true),
})
public Boolean updateStatus(@RequestParam("ids") List<String> ids,
@RequestParam("status") TransportOrderStatus status) {
return this.transportOrderService.updateStatus(ids, status);
}
@GetMapping("pageQueryByTaskId")
@ApiOperation(value = "分页条件查询运单列表", notes = "根据运输任务id分页查询运单列表，并模糊查询运单id")
@ApiImplicitParams({
@ApiImplicitParam(name = "page", value = "页码", required = true, example = "1", dataTypeClass = Integer.class),
@ApiImplicitParam(name = "pageSize", value = "页面大小", required = true, example = "10", dataTypeClass = Integer.class),
@ApiImplicitParam(name = "taskId", value = "运输任务id", required = true, dataTypeClass = String.class),
@ApiImplicitParam(name = "transportOrderId", value = "运单id", dataTypeClass = String.class)
})
public PageResponse<TransportOrderDTO> pageQueryByTaskId(@RequestParam(name = "page", defaultValue = "1") Integer page,
@RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
@RequestParam(name = "taskId") String taskId,
@RequestParam(name = "transportOrderId", required = false) String transportOrderId) {
return transportOrderService.pageQueryByTaskId(page, pageSize, taskId, transportOrderId);
}
}

135
sl-express-ms-work-service/src/main/java/com/sl/ms/work/controller/TransportTaskController.java Normal file
View File

@@ -0,0 +1,135 @@
package com.sl.ms.work.controller;
import com.sl.ms.work.domain.dto.TaskTransportUpdateDTO;
import com.sl.ms.work.domain.dto.TransportTaskDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskCompleteDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskDelayDeliveryDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskPageQueryDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskStartDTO;
import com.sl.ms.work.domain.dto.response.TransportTaskMonthlyDistanceDTO;
import com.sl.ms.work.domain.dto.response.TransportTaskStatusCountDTO;
import com.sl.ms.work.domain.enums.transporttask.TransportTaskStatus;
import com.sl.ms.work.service.TransportTaskService;
import com.sl.transport.common.util.PageResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
/**
* 运输任务表 前端控制器
*/
@Slf4j
@RestController
@Api(tags = "运输任务")
@RequestMapping("transport-task")
public class TransportTaskController {
@Resource
private TransportTaskService transportTaskService;
@PutMapping
@ApiOperation(value = "更新状态", notes = "更新状态，不允许 CREATED 状态")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "运输任务id", required = true),
@ApiImplicitParam(name = "status", value = "运输任务状态", required = true),
})
public Boolean updateStatus(@RequestParam("id") Long id,
@RequestParam("status") TransportTaskStatus status) {
return this.transportTaskService.updateStatus(id, status);
}
/**
* 获取运输任务分页数据
*
* @return 运输任务分页数据
*/
@PostMapping("page")
PageResponse<TransportTaskDTO> findByPage(@RequestBody TransportTaskPageQueryDTO pageQueryDTO) {
return this.transportTaskService.findByPage(pageQueryDTO);
}
@GetMapping("{id}")
@ApiOperation(value = "id查询", notes = "根据id获取运输任务信息")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "运输任务id")
})
public TransportTaskDTO findById(@PathVariable("id") Long id) {
return transportTaskService.findById(id);
}
@GetMapping("listByOrderIdOrTaskId")
@ApiOperation(value = "查询列表", notes = "根据运单id或运输任务id获取运输任务列表")
@ApiImplicitParams({
@ApiImplicitParam(name = "transportOrderId", value = "运单id"),
@ApiImplicitParam(name = "taskTransportId", value = "运输任务id"),
})
public List<TransportTaskDTO> findAllByOrderIdOrTaskId(@RequestParam(name = "transportOrderId", required = false) String transportOrderId,
@RequestParam(name = "taskTransportId", required = false) Long taskTransportId) {
return this.transportTaskService.findAllByOrderIdOrTaskId(transportOrderId, taskTransportId);
}
@GetMapping("count")
@ApiOperation(value = "统计", notes = "统计各个状态的数量")
public List<TransportTaskStatusCountDTO> count() {
return transportTaskService.groupByStatus();
}
/**
* 手动调整
*
* @param id 运输任务id
* @param dto 运输任务信息
* @return 运输任务信息
*/
@PutMapping("adjust/{id}")
public void adjust(@PathVariable(name = "id") Long id,
@RequestBody TaskTransportUpdateDTO dto) {
dto.setId(id);
this.transportTaskService.adjust(dto);
}
@PutMapping("startTransportTask")
@ApiOperation(value = "开始运输任务")
public void startTransportTask(@RequestBody TransportTaskStartDTO transportTaskStartDTO) {
transportTaskService.startTransportTask(transportTaskStartDTO);
}
@PutMapping("completeTransportTask")
@ApiOperation(value = "完成运输任务")
public void completeTransportTask(@RequestBody TransportTaskCompleteDTO transportTaskCompleteDTO) {
transportTaskService.completeTransportTask(transportTaskCompleteDTO);
}
@GetMapping("queryTransportOrderIdListById/{id}")
@ApiOperation(value = "根据运输任务id查询运单id列表", notes = "根据运输任务id查询所对应的运单id列表")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "运输任务id"),
})
public List<String> queryTransportOrderIdListById(@PathVariable("id") Long id) {
return transportTaskService.queryTransportOrderIdListById(id);
}
@PutMapping("delayDelivery")
@ApiOperation(value = "延迟提货", notes = "延迟时间以提货时间往后推最多不超过2小时")
public void delayedDelivery(@RequestBody TransportTaskDelayDeliveryDTO transportTaskDelayDeliveryDTO) {
transportTaskService.delayedDelivery(transportTaskDelayDeliveryDTO);
}
@GetMapping("monthlyDistanceStatistics")
@ApiOperation(value = "任务里程统计", notes = "按月统计已完成任务的每日里程")
@ApiImplicitParams({
@ApiImplicitParam(name = "transportTaskIds", value = "运输任务id列表", required = true, dataTypeClass = String.class),
@ApiImplicitParam(name = "month", value = "月份", required = true, example = "2022-07", dataTypeClass = String.class)
})
public List<TransportTaskMonthlyDistanceDTO> monthlyDistanceStatistics(@RequestParam(name = "transportTaskIds") List<String> transportTaskIds,
@RequestParam(name = "month") String month) {
return transportTaskService.monthlyDistanceStatistics(transportTaskIds, month);
}
}

107
sl-express-ms-work-service/src/main/java/com/sl/ms/work/entity/PickupDispatchTaskEntity.java Normal file
View File

@@ -0,0 +1,107 @@
package com.sl.ms.work.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.sl.ms.work.domain.enums.pickupDispatchtask.*;
import com.sl.transport.common.entity.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.time.LocalDateTime;
/**
* 取件、派件任务信息表
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sl_pickup_dispatch_task")
public class PickupDispatchTaskEntity extends BaseEntity {
/**
* 关联订单id
*/
private Long orderId;
/**
* 任务类型，1为取件任务，2为派件任务
*/
private PickupDispatchTaskType taskType;
/**
* 任务状态
*/
private PickupDispatchTaskStatus status;
/**
* 签收状态(1为已签收，2为拒收)
*/
private PickupDispatchTaskSignStatus signStatus;
/**
* 签收人
*/
private SignRecipientEnum signRecipient;
/**
* 网点ID
*/
private Long agencyId;
/**
* 快递员ID
*/
private Long courierId;
/**
* 预计开始时间
*/
private LocalDateTime estimatedStartTime;
/**
* 实际开始时间
*/
private LocalDateTime actualStartTime;
/**
* 预计完成时间
*/
private LocalDateTime estimatedEndTime;
/**
* 实际完成时间
*/
private LocalDateTime actualEndTime;
/**
* 取消时间
*/
private LocalDateTime cancelTime;
/**
* 任务分配状态(1未分配2已分配3待人工分配)
*/
private PickupDispatchTaskAssignedStatus assignedStatus;
/**
* 备注
*/
private String mark;
/**
* 删除：0-否，1-是
*/
private PickupDispatchTaskIsDeleted isDeleted;
/**
* 取消原因
*/
private PickupDispatchTaskCancelReason cancelReason;
/**
* 取消原因具体描述
*/
private String cancelReasonDescription;
}

92
sl-express-ms-work-service/src/main/java/com/sl/ms/work/entity/TransportOrderEntity.java Normal file
View File

@@ -0,0 +1,92 @@
package com.sl.ms.work.entity;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.sl.ms.work.domain.enums.transportorder.TransportOrderSchedulingStatus;
import com.sl.ms.work.domain.enums.transportorder.TransportOrderStatus;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 运单表
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sl_transport_order")
public class TransportOrderEntity implements Serializable {
@TableId
private String id; //主键id
/**
* 订单ID
*/
private Long orderId;
/**
* 运单状态(1.新建 2.已装车，发往x转运中心 3.到达 4.到达终端网点)
* {@link TransportOrderStatus}
*/
private TransportOrderStatus status;
/**
* 调度状态调度状态(1.待调度2.未匹配线路3.已调度)
* <p>
* {@link TransportOrderSchedulingStatus}
*/
private TransportOrderSchedulingStatus schedulingStatus;
/**
* 起始网点id
*/
private Long startAgencyId;
/**
* 终点网点id
*/
private Long endAgencyId;
/**
* 当前所在机构id
*/
private Long currentAgencyId;
/**
* 下一个机构id
*/
private Long nextAgencyId;
/**
* 完整的运输路线
*/
private String transportLine;
/**
* 货品总体积，单位：立方米
*/
private BigDecimal totalVolume;
/**
* 货品总重量，单位：kg
*/
private BigDecimal totalWeight;
/**
* 是否为拒收运单
*/
private Boolean isRejection;
@TableField(fill = FieldFill.INSERT) //MP自动填充
private LocalDateTime created;
@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updated;
}

27
sl-express-ms-work-service/src/main/java/com/sl/ms/work/entity/TransportOrderTaskEntity.java Normal file
View File

@@ -0,0 +1,27 @@
package com.sl.ms.work.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.sl.transport.common.entity.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* 运单与运输任务关联表
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sl_transport_order_task")
public class TransportOrderTaskEntity extends BaseEntity {
/**
* 运单Id
*/
private String transportOrderId;
/**
* 运输任务Id
*/
private Long transportTaskId;
}

130
sl-express-ms-work-service/src/main/java/com/sl/ms/work/entity/TransportTaskEntity.java Normal file
View File

@@ -0,0 +1,130 @@
package com.sl.ms.work.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.sl.ms.work.domain.enums.transporttask.TransportTaskAssignedStatus;
import com.sl.ms.work.domain.enums.transporttask.TransportTaskLoadingStatus;
import com.sl.ms.work.domain.enums.transporttask.TransportTaskStatus;
import com.sl.transport.common.entity.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.time.LocalDateTime;
/**
* 运输任务表
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sl_transport_task")
public class TransportTaskEntity extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 车辆计划id
*/
private Long truckPlanId;
/**
* 车次id
*/
private Long transportTripsId;
/**
* 起始机构id
*/
private Long startAgencyId;
/**
* 目的机构id
*/
private Long endAgencyId;
/**
* 任务状态，1为待执行（对应 待提货）、2为进行中（对应在途）、3为待确认（保留状态）、4为已完成（对应 已交付）、5为已取消
*/
private TransportTaskStatus status;
/**
* 任务分配状态(1未分配2已分配3待人工分配)
*/
private TransportTaskAssignedStatus assignedStatus;
/**
* 满载状态(1.半载2.满载3.空载)
*/
private TransportTaskLoadingStatus loadingStatus;
/**
* 车辆id
*/
private Long truckId;
/**
* 提货凭证
*/
private String cargoPickUpPicture;
/**
* 货物照片
*/
private String cargoPicture;
/**
* 运回单凭证
*/
private String transportCertificate;
/**
* 计划发车时间
*/
private LocalDateTime planDepartureTime;
/**
* 实际发车时间
*/
private LocalDateTime actualDepartureTime;
/**
* 计划到达时间
*/
private LocalDateTime planArrivalTime;
/**
* 实际到达时间
*/
private LocalDateTime actualArrivalTime;
/**
* 交付货物照片
*/
private String deliverPicture;
/**
* 提货纬度
*/
private String deliveryLatitude;
/**
* 提货经度
*/
private String deliveryLongitude;
/**
* 交付纬度
*/
private String deliverLatitude;
/**
* 交付经度
*/
private String deliverLongitude;
/**
* 备注
*/
private String mark;
/**
* 距离，单位：米
*/
private Double distance;
}

22
sl-express-ms-work-service/src/main/java/com/sl/ms/work/mapper/TaskPickupDispatchMapper.java Normal file
View File

@@ -0,0 +1,22 @@
package com.sl.ms.work.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sl.ms.work.domain.dto.CourierTaskCountDTO;
import com.sl.ms.work.entity.PickupDispatchTaskEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.time.LocalDateTime;
import java.util.List;
/**
* 取件、派件任务信息表 Mapper 接口
*/
@Mapper
public interface TaskPickupDispatchMapper extends BaseMapper<PickupDispatchTaskEntity> {
List<CourierTaskCountDTO> findCountByCourierIds(@Param("courierIds") List<Long> courierIds,
@Param("type") Integer type,
@Param("startDateTime") LocalDateTime startDateTime,
@Param("endDateTime") LocalDateTime endDateTime);
}

22
sl-express-ms-work-service/src/main/java/com/sl/ms/work/mapper/TransportOrderMapper.java Normal file
View File

@@ -0,0 +1,22 @@
package com.sl.ms.work.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sl.ms.work.domain.dto.response.TransportOrderStatusCountDTO;
import com.sl.ms.work.entity.TransportOrderEntity;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 运单表 Mapper 接口
*/
@Mapper
public interface TransportOrderMapper extends BaseMapper<TransportOrderEntity> {
/**
* 统计各个状态的数量
*
* @return 状态 -> 数量
*/
List<TransportOrderStatusCountDTO> findStatusCount();
}

12
sl-express-ms-work-service/src/main/java/com/sl/ms/work/mapper/TransportOrderTaskMapper.java Normal file
View File

@@ -0,0 +1,12 @@
package com.sl.ms.work.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sl.ms.work.entity.TransportOrderTaskEntity;
import org.apache.ibatis.annotations.Mapper;
/**
* 运单与运输任务表 Mapper 接口
*/
@Mapper
public interface TransportOrderTaskMapper extends BaseMapper<TransportOrderTaskEntity> {
}

32
sl-express-ms-work-service/src/main/java/com/sl/ms/work/mapper/TransportTaskMapper.java Normal file
View File

@@ -0,0 +1,32 @@
package com.sl.ms.work.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.sl.ms.work.domain.dto.response.TransportTaskMonthlyDistanceDTO;
import com.sl.ms.work.domain.dto.response.TransportTaskStatusCountDTO;
import com.sl.ms.work.entity.TransportTaskEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.time.LocalDateTime;
import java.util.List;
/**
* 运输任务表 Mapper 接口
*/
@Mapper
public interface TransportTaskMapper extends BaseMapper<TransportTaskEntity> {
List<TransportTaskStatusCountDTO> findStatusCount();
/**
* 任务里程统计
*
* @param transportTaskIds 运输任务id列表
* @param startTime 开始时间
* @param endTime 结束时间
* @return 每日里程数据
*/
List<TransportTaskMonthlyDistanceDTO> monthlyDistanceStatistics(@Param("transportTaskIds") List<String> transportTaskIds,
@Param("startTime") LocalDateTime startTime,
@Param("endTime") LocalDateTime endTime);
}

60
sl-express-ms-work-service/src/main/java/com/sl/ms/work/mq/CourierMQListener.java Normal file
View File

@@ -0,0 +1,60 @@
package com.sl.ms.work.mq;
import cn.hutool.json.JSONUtil;
import com.sl.transport.common.constant.Constants;
import com.sl.transport.common.vo.CourierMsg;
import com.sl.transport.common.vo.CourierTaskMsg;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* 快递员的消息处理，该处理器处理两个消息：
* 1. 生成快递员取派件任务
* 2. 快递员取件成功，订单转运单
*/
@Component
@Slf4j
public class CourierMQListener {
/**
* 生成快递员取派件任务
*
* @param msg 消息
*/
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = Constants.MQ.Queues.WORK_PICKUP_DISPATCH_TASK_CREATE),
exchange = @Exchange(name = Constants.MQ.Exchanges.PICKUP_DISPATCH_TASK_DELAYED, type = ExchangeTypes.TOPIC, delayed = Constants.MQ.DELAYED),
key = Constants.MQ.RoutingKeys.PICKUP_DISPATCH_TASK_CREATE
))
public void listenCourierTaskMsg(String msg) {
//{"taskType":1,"orderId":225125208064,"created":1654767899885,"courierId":1001,"agencyId":8001,"estimatedStartTime":1654224658728,"mark":"带包装"}
log.info("接收到快递员任务的消息 >>> msg = {}", msg);
//解析消息
CourierTaskMsg courierTaskMsg = JSONUtil.toBean(msg, CourierTaskMsg.class);
//TODO 未实现具体逻辑
}
/**
* 快递员取件成功
*
* @param msg 消息
*/
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = Constants.MQ.Queues.WORK_COURIER_PICKUP_SUCCESS),
exchange = @Exchange(name = Constants.MQ.Exchanges.COURIER, type = ExchangeTypes.TOPIC),
key = Constants.MQ.RoutingKeys.COURIER_PICKUP
))
public void listenCourierPickupMsg(String msg) {
log.info("接收到快递员取件成功的消息 >>> msg = {}", msg);
//解析消息
CourierMsg courierMsg = JSONUtil.toBean(msg, CourierMsg.class);
System.out.println(courierMsg);
//TODO 未实现具体逻辑
}
}

111
sl-express-ms-work-service/src/main/java/com/sl/ms/work/service/PickupDispatchTaskService.java Normal file
View File

@@ -0,0 +1,111 @@
package com.sl.ms.work.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.sl.ms.work.domain.dto.CourierTaskCountDTO;
import com.sl.ms.work.domain.dto.PickupDispatchTaskDTO;
import com.sl.ms.work.domain.dto.request.PickupDispatchTaskPageQueryDTO;
import com.sl.ms.work.domain.dto.response.PickupDispatchTaskStatisticsDTO;
import com.sl.ms.work.domain.enums.pickupDispatchtask.PickupDispatchTaskIsDeleted;
import com.sl.ms.work.domain.enums.pickupDispatchtask.PickupDispatchTaskStatus;
import com.sl.ms.work.domain.enums.pickupDispatchtask.PickupDispatchTaskType;
import com.sl.ms.work.entity.PickupDispatchTaskEntity;
import com.sl.transport.common.util.PageResponse;
import java.util.List;
/**
* 取件、派件任务信息表 服务类
*/
public interface PickupDispatchTaskService extends IService<PickupDispatchTaskEntity> {
/**
* 更新取派件状态，不允许 NEW 状态
*
* @param pickupDispatchTaskDTO 修改的数据
* @return 是否成功
*/
Boolean updateStatus(PickupDispatchTaskDTO pickupDispatchTaskDTO);
/**
* 改派快递员
*
* @param ids 任务id列表
* @param originalCourierId 原快递员id
* @param targetCourierId 目标快递员id
* @return 是否成功
*/
Boolean updateCourierId(List<Long> ids, Long originalCourierId, Long targetCourierId);
/**
* 新增取派件任务
*
* @param taskPickupDispatch 取派件任务信息
* @return 取派件任务信息
*/
PickupDispatchTaskEntity saveTaskPickupDispatch(PickupDispatchTaskEntity taskPickupDispatch);
/**
* 分页查询取派件任务
*
* @param dto 查询条件
* @return 分页结果
*/
PageResponse<PickupDispatchTaskDTO> findByPage(PickupDispatchTaskPageQueryDTO dto);
/**
* 按照当日快递员id列表查询每个快递员的取派件任务数
*
* @param courierIds 快递员id列表
* @param pickupDispatchTaskType 任务类型
* @param date 日期，格式：yyyy-MM-dd 或 yyyyMMdd
* @return 任务数
*/
List<CourierTaskCountDTO> findCountByCourierIds(List<Long> courierIds, PickupDispatchTaskType pickupDispatchTaskType, String date);
/**
* 根据订单id查询取派件任务
*
* @param orderId 订单id
* @param taskType 任务类型
* @return 任务
*/
List<PickupDispatchTaskEntity> findByOrderId(Long orderId, PickupDispatchTaskType taskType);
/**
* 根据id批量删除取派件任务信息（逻辑删除）
*
* @param ids id列表
* @return 是否成功
*/
boolean deleteByIds(List<Long> ids);
/**
* 今日任务分类计数
*
* @param courierId 快递员id
* @param taskType 任务类型，1为取件任务，2为派件任务
* @param status 任务状态,1新任务，2已完成，3已取消
* @param isDeleted 是否逻辑删除
* @return 任务数量
*/
Integer todayTasksCount(Long courierId, PickupDispatchTaskType taskType, PickupDispatchTaskStatus status, PickupDispatchTaskIsDeleted isDeleted);
/**
* 条件查询所有
*
* @param courierId 快递员id
* @param taskType 任务类型，1为取件任务，2为派件任务
* @param taskStatus 任务状态,1新任务，2已完成，3已取消
* @param isDeleted 是否逻辑删除
* @return 取派件任务列表
*/
List<PickupDispatchTaskDTO> findAll(Long courierId, PickupDispatchTaskType taskType, PickupDispatchTaskStatus taskStatus, PickupDispatchTaskIsDeleted isDeleted);
/**
* 今日任务分类统计
*
* @param courierId 快递员id
* @return 统计结果
*/
PickupDispatchTaskStatisticsDTO todayTaskStatistics(Long courierId);
}

108
sl-express-ms-work-service/src/main/java/com/sl/ms/work/service/TransportOrderService.java Normal file
View File

@@ -0,0 +1,108 @@
package com.sl.ms.work.service;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.sl.ms.work.domain.dto.TransportOrderDTO;
import com.sl.ms.work.domain.dto.request.TransportOrderQueryDTO;
import com.sl.ms.work.domain.dto.response.TransportOrderStatusCountDTO;
import com.sl.ms.work.domain.enums.transportorder.TransportOrderStatus;
import com.sl.ms.work.entity.TransportOrderEntity;
import com.sl.transport.common.util.PageResponse;
import com.sl.transport.common.vo.OrderMsg;
import java.util.List;
/**
* 运单表 服务类
*/
public interface TransportOrderService extends IService<TransportOrderEntity> {
/**
* 订单转运单
*
* @param orderId 订单号
* @return 运单号
*/
TransportOrderEntity orderToTransportOrder(Long orderId);
/**
* 获取运单分页数据
*
* @return 运单分页数据
*/
Page<TransportOrderEntity> findByPage(TransportOrderQueryDTO transportOrderQueryDTO);
/**
* 通过订单id获取运单信息
*
* @param orderId 订单id
* @return 运单信息
*/
TransportOrderEntity findByOrderId(Long orderId);
/**
* 通过订单id列表获取运单列表
*
* @param orderIds 订单id列表
* @return 运单列表
*/
List<TransportOrderEntity> findByOrderIds(Long[] orderIds);
/**
* 通过运单id列表获取运单列表
*
* @param ids 订单id列表
* @return 运单列表
*/
List<TransportOrderEntity> findByIds(String[] ids);
/**
* 根据运单号搜索运单
*
* @param id 运单号
* @return 运单列表
*/
List<TransportOrderEntity> searchById(String id);
/**
* 修改运单状态
*
* @param ids 运单id列表
* @param transportOrderStatus 修改的状态
* @return 是否成功
*/
boolean updateStatus(List<String> ids, TransportOrderStatus transportOrderStatus);
/**
* 根据运输任务id批量修改运单，其中会涉及到下一个节点的流转，已经发送消息的业务
*
* @param taskId 运输任务id
* @return 是否成功
*/
boolean updateByTaskId(Long taskId);
/**
* 统计各个状态的数量
*
* @return 状态数量数据
*/
List<TransportOrderStatusCountDTO> findStatusCount();
/**
* 发送消息到调度中心，用于生成取派件任务
*
* @param transportOrder 运单对象
* @param orderMsg 消息对象
*/
void sendPickupDispatchTaskMsgToDispatch(TransportOrderEntity transportOrder, OrderMsg orderMsg);
/**
* 根据运输任务id分页查询运单信息
*
* @param page 页码
* @param pageSize 页面大小
* @param taskId 运输任务id
* @param transportOrderId 运单id
* @return 运单对象分页数据
*/
PageResponse<TransportOrderDTO> pageQueryByTaskId(Integer page, Integer pageSize, String taskId, String transportOrderId);
}

57
sl-express-ms-work-service/src/main/java/com/sl/ms/work/service/TransportOrderTaskService.java Normal file
View File

@@ -0,0 +1,57 @@
package com.sl.ms.work.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.sl.ms.work.entity.TransportOrderTaskEntity;
import java.util.List;
/**
* 运单和运输任务关联表 服务类
*/
public interface TransportOrderTaskService extends IService<TransportOrderTaskEntity> {
/**
* 批量添加运单与运输任务关联关系
*
* @param transportOrderTaskList 关联关系列表
*/
void batchSaveTransportOrder(List<TransportOrderTaskEntity> transportOrderTaskList);
/**
* 获取运单与运输任务关联关系分页数据
*
* @param page 页码
* @param pageSize 页尺寸
* @param transportOrderId 运单id
* @param transportTaskId 订单id
* @return 运单与运输任务关联关系分页数据
*/
IPage<TransportOrderTaskEntity> findByPage(Integer page, Integer pageSize, String transportOrderId, Long transportTaskId);
/**
* 获取运单与运输任务关联关系列表
*
* @param transportOrderId 运单id
* @param transportTaskId 运输任务id
* @return 运单与运输任务关联关系列表
*/
List<TransportOrderTaskEntity> findAll(String transportOrderId, Long transportTaskId);
/**
* 统计关联数量
*
* @param transportOrderId 运单Id
* @param transportTaskId 运输任务Id
* @return 数量
*/
Long count(String transportOrderId, Long transportTaskId);
/**
* 根据条件删除关联关系
*
* @param transportOrderId 运单id
* @param transportTaskId 运输任务id
*/
void del(String transportOrderId, Long transportTaskId);
}

136
sl-express-ms-work-service/src/main/java/com/sl/ms/work/service/TransportTaskService.java Normal file
View File

@@ -0,0 +1,136 @@
package com.sl.ms.work.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.sl.ms.work.domain.dto.TaskTransportUpdateDTO;
import com.sl.ms.work.domain.dto.TransportTaskDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskCompleteDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskDelayDeliveryDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskPageQueryDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskStartDTO;
import com.sl.ms.work.domain.dto.response.TransportTaskMonthlyDistanceDTO;
import com.sl.ms.work.domain.dto.response.TransportTaskStatusCountDTO;
import com.sl.ms.work.domain.enums.transporttask.TransportTaskStatus;
import com.sl.ms.work.entity.TransportTaskEntity;
import com.sl.transport.common.util.PageResponse;
import java.util.List;
/**
* 运输任务表 服务类
*/
public interface TransportTaskService extends IService<TransportTaskEntity> {
/**
* 更新状态
*
* @param id 运输任务id
* @param status 任务状态 PROCESSING：开始任务，COMPLETED：完成任务
* @return 是否成功
*/
Boolean updateStatus(Long id, TransportTaskStatus status);
/**
* 获取运输任务分页数据
*
* @return 运输任务分页数据
*/
PageResponse<TransportTaskDTO> findByPage(TransportTaskPageQueryDTO pageQueryDTO);
/**
* 获取运输任务列表
*
* @param ids 运输任务id列表
* @param id 运输任务Id
* @param status 运单状态
* @param transportTaskDTO 运输任务对象
* @return 运输任务列表
*/
List<TransportTaskEntity> findAll(List<Long> ids, Long id, Integer status, TransportTaskDTO transportTaskDTO);
/**
* 完成运输任务
*
* @param transportTaskCompleteDTO 交付对象
*/
void completeTransportTask(TransportTaskCompleteDTO transportTaskCompleteDTO);
/**
* 开始运输任务
*
* @param transportTaskStartDTO 提货对象
*/
void startTransportTask(TransportTaskStartDTO transportTaskStartDTO);
/**
* 根据运输任务id查询所对应的运单id列表
*
* @param id 运输任务id
* @return 运单id列表
*/
List<String> queryTransportOrderIdListById(Long id);
/**
* 根据运单id 或 运输任务id 查询运输任务列表
*
* @param transportOrderId 运单id
* @param transportTaskId 运输任务id
* @return 运输任务列表
*/
List<TransportTaskDTO> findAllByOrderIdOrTaskId(String transportOrderId, Long transportTaskId);
/**
* 根据id获取运输任务信息
*
* @param id 运输任务id
* @return 运输任务信息
*/
TransportTaskDTO findById(Long id);
/**
* 统计各个状态的数量
*
* @return 状态数量数据
*/
List<TransportTaskStatusCountDTO> groupByStatus();
/**
* 手动调整运输任务
*
* @param dto 调整的数据
*/
void adjust(TaskTransportUpdateDTO dto);
/**
* 延迟提货
*
* @param transportTaskDelayDeliveryDTO 延迟提货对象
*/
void delayedDelivery(TransportTaskDelayDeliveryDTO transportTaskDelayDeliveryDTO);
/**
* 任务里程统计
*
* @param transportTaskIds 运输任务id列表
* @param month 月份，格式：2022-06
* @return 每日里程数据
*/
List<TransportTaskMonthlyDistanceDTO> monthlyDistanceStatistics(List<String> transportTaskIds, String month);
/**
* 根据起始机构查询运输任务id列表
*
* @param startAgencyId 起始机构id
* @param endAgencyId 结束机构id
* @return 运输任务id列表
*/
List<Long> findByAgencyId(Long startAgencyId, Long endAgencyId);
/**
* 根据车辆ID统计
*
* @param truckId 车辆ID
* @return 个数
*/
Long countByTruckId(Long truckId);
}

65
sl-express-ms-work-service/src/main/java/com/sl/ms/work/service/impl/TransportOrderTaskServiceImpl.java Normal file
View File

@@ -0,0 +1,65 @@
package com.sl.ms.work.service.impl;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sl.ms.work.entity.TransportOrderTaskEntity;
import com.sl.ms.work.mapper.TransportOrderTaskMapper;
import com.sl.ms.work.service.TransportOrderTaskService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* 运单表 服务实现类
*/
@Service
public class TransportOrderTaskServiceImpl extends
ServiceImpl<TransportOrderTaskMapper, TransportOrderTaskEntity> implements TransportOrderTaskService {
@Override
public void batchSaveTransportOrder(List<TransportOrderTaskEntity> transportOrderTaskList) {
saveBatch(transportOrderTaskList);
}
@Override
public IPage<TransportOrderTaskEntity> findByPage(Integer page, Integer pageSize, String transportOrderId, Long transportTaskId) {
Page<TransportOrderTaskEntity> iPage = new Page(page, pageSize);
LambdaQueryWrapper<TransportOrderTaskEntity> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(ObjectUtil.isNotEmpty(transportOrderId), TransportOrderTaskEntity::getTransportOrderId, transportOrderId);
lambdaQueryWrapper.like(ObjectUtil.isNotEmpty(transportTaskId), TransportOrderTaskEntity::getTransportTaskId, transportTaskId);
return super.page(iPage, lambdaQueryWrapper);
}
@Override
public List<TransportOrderTaskEntity> findAll(String transportOrderId, Long transportTaskId) {
LambdaQueryWrapper<TransportOrderTaskEntity> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(ObjectUtil.isNotEmpty(transportOrderId), TransportOrderTaskEntity::getTransportOrderId, transportOrderId);
lambdaQueryWrapper.like(ObjectUtil.isNotEmpty(transportTaskId), TransportOrderTaskEntity::getTransportTaskId, transportTaskId);
lambdaQueryWrapper.orderBy(true, false, TransportOrderTaskEntity::getCreated);
return list(lambdaQueryWrapper);
}
@Override
public Long count(String transportOrderId, Long transportTaskId) {
LambdaQueryWrapper<TransportOrderTaskEntity> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.like(ObjectUtil.isNotEmpty(transportOrderId), TransportOrderTaskEntity::getTransportOrderId, transportOrderId);
lambdaQueryWrapper.like(ObjectUtil.isNotEmpty(transportTaskId), TransportOrderTaskEntity::getTransportTaskId, transportTaskId);
return super.count(lambdaQueryWrapper);
}
@Override
public void del(String transportOrderId, Long transportTaskId) {
if (ObjectUtil.isAllEmpty(transportOrderId, transportTaskId)) {
return;
}
LambdaQueryWrapper<TransportOrderTaskEntity> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(ObjectUtil.isNotEmpty(transportOrderId), TransportOrderTaskEntity::getTransportOrderId, transportOrderId);
lambdaQueryWrapper.eq(ObjectUtil.isNotEmpty(transportTaskId), TransportOrderTaskEntity::getTransportTaskId, transportTaskId);
super.remove(lambdaQueryWrapper);
}
}

372
sl-express-ms-work-service/src/main/java/com/sl/ms/work/service/impl/TransportTaskServiceImpl.java Normal file
View File

@@ -0,0 +1,372 @@
package com.sl.ms.work.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.sl.ms.driver.api.DriverJobFeign;
import com.sl.ms.driver.domain.dto.request.DriverJobPageQueryDTO;
import com.sl.ms.driver.domain.dto.response.DriverJobDTO;
import com.sl.ms.driver.domain.enums.DriverJobStatus;
import com.sl.ms.work.domain.dto.TaskTransportUpdateDTO;
import com.sl.ms.work.domain.dto.TransportTaskDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskCompleteDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskDelayDeliveryDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskPageQueryDTO;
import com.sl.ms.work.domain.dto.request.TransportTaskStartDTO;
import com.sl.ms.work.domain.dto.response.TransportTaskMonthlyDistanceDTO;
import com.sl.ms.work.domain.dto.response.TransportTaskStatusCountDTO;
import com.sl.ms.work.domain.enums.WorkExceptionEnum;
import com.sl.ms.work.domain.enums.transporttask.TransportTaskStatus;
import com.sl.ms.work.entity.TransportOrderTaskEntity;
import com.sl.ms.work.entity.TransportTaskEntity;
import com.sl.ms.work.mapper.TransportTaskMapper;
import com.sl.ms.work.service.TransportOrderTaskService;
import com.sl.ms.work.service.TransportTaskService;
import com.sl.transport.common.exception.SLException;
import com.sl.transport.common.util.PageResponse;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import static com.sl.ms.work.domain.enums.WorkExceptionEnum.TRANSPORT_TASK_CANCEL_FAILED;
/**
* 运输任务表 服务实现类
*/
@Service
public class TransportTaskServiceImpl extends
ServiceImpl<TransportTaskMapper, TransportTaskEntity> implements TransportTaskService {
@Resource
private TransportOrderTaskService transportOrderTaskService;
@Resource
private DriverJobFeign driverJobFeign;
@Override
@Transactional
public Boolean updateStatus(Long id, TransportTaskStatus status) {
if (TransportTaskStatus.PENDING == status) {
//修改运输任务状态不能为 待执行 状态
throw new SLException(WorkExceptionEnum.TRANSPORT_TASK_STATUS_NOT_PENDING);
}
if (TransportTaskStatus.PROCESSING == status) {
// 开始任务
TransportTaskStartDTO transportTaskStartDTO = new TransportTaskStartDTO();
transportTaskStartDTO.setTransportTaskId(String.valueOf(id));
this.startTransportTask(transportTaskStartDTO);
return true;
} else if (TransportTaskStatus.COMPLETED == status) {
// 完成任务
TransportTaskCompleteDTO transportTaskCompleteDTO = new TransportTaskCompleteDTO();
transportTaskCompleteDTO.setTransportTaskId(String.valueOf(id));
this.completeTransportTask(transportTaskCompleteDTO);
return true;
} else if (TransportTaskStatus.CANCELLED == status) {
//根据运输任务id查询运单id列表
List<String> transportOrderIdList = this.queryTransportOrderIdListById(id);
//如果存在关联运单不可取消
if (CollUtil.isNotEmpty(transportOrderIdList)) {
throw new SLException(TRANSPORT_TASK_CANCEL_FAILED);
}
// 取消运输任务
TransportTaskEntity transportTaskEntity = new TransportTaskEntity();
transportTaskEntity.setId(id);
transportTaskEntity.setStatus(status);
this.updateById(transportTaskEntity);
//取消运输任务关联的司机作业单
DriverJobPageQueryDTO driverJobPageQueryDTO = DriverJobPageQueryDTO.builder().page(1).pageSize(999).transportTaskId(id).build();
PageResponse<DriverJobDTO> driverJobPage = driverJobFeign.pageQuery(driverJobPageQueryDTO);
driverJobPage.getItems().forEach(dto -> driverJobFeign.updateStatus(dto.getId(), DriverJobStatus.CANCELLED));
return true;
} else {
//修改其他状态
TransportTaskEntity transportTaskEntity = new TransportTaskEntity();
transportTaskEntity.setId(id);
transportTaskEntity.setStatus(status);
return super.updateById(transportTaskEntity);
}
}
@Override
public PageResponse<TransportTaskDTO> findByPage(TransportTaskPageQueryDTO pageQueryDTO) {
Page<TransportTaskEntity> pageQuery = new Page<>(pageQueryDTO.getPage(), pageQueryDTO.getPageSize());
//查询运输任务
LambdaQueryWrapper<TransportTaskEntity> lambdaQueryWrapper = Wrappers.<TransportTaskEntity>lambdaQuery()
.like(ObjectUtil.isNotEmpty(pageQueryDTO.getId()), TransportTaskEntity::getId, pageQueryDTO.getId())
.eq(ObjectUtil.isNotEmpty(pageQueryDTO.getStatus()), TransportTaskEntity::getStatus, pageQueryDTO.getStatus())
.eq(ObjectUtil.isNotEmpty(pageQueryDTO.getAssignedStatus()), TransportTaskEntity::getAssignedStatus, pageQueryDTO.getAssignedStatus())
.eq(ObjectUtil.isNotEmpty(pageQueryDTO.getLoadingStatus()), TransportTaskEntity::getLoadingStatus, pageQueryDTO.getLoadingStatus())
.eq(ObjectUtil.isNotEmpty(pageQueryDTO.getStartAgencyId()), TransportTaskEntity::getStartAgencyId, pageQueryDTO.getStartAgencyId())
.eq(ObjectUtil.isNotEmpty(pageQueryDTO.getEndAgencyId()), TransportTaskEntity::getEndAgencyId, pageQueryDTO.getEndAgencyId())
.in(ObjectUtil.isNotEmpty(pageQueryDTO.getTruckIds()), TransportTaskEntity::getTruckId, pageQueryDTO.getTruckIds())
.eq(ObjectUtil.isNotEmpty(pageQueryDTO.getTruckId()), TransportTaskEntity::getTruckId, pageQueryDTO.getTruckId())
.orderByDesc(TransportTaskEntity::getPlanDepartureTime);
Page<TransportTaskEntity> pageResult = super.page(pageQuery, lambdaQueryWrapper);
if (CollUtil.isEmpty(pageResult.getRecords())) {
return new PageResponse<>(pageResult);
}
PageResponse<TransportTaskDTO> pageResponse = new PageResponse<>(pageResult, TransportTaskDTO.class);
//补充数据
pageResponse.getItems().forEach(transportTask -> {
//查询运输任务中的运单号
List<TransportOrderTaskEntity> list = this.transportOrderTaskService.findAll(null, transportTask.getId());
List<String> transportOrderIdList = CollUtil.getFieldValues(list, "transportOrderId", String.class);
transportTask.setTransportOrderIds(transportOrderIdList);
transportTask.setTransportOrderCount(CollUtil.size(transportOrderIdList));
});
return pageResponse;
}
@Override
public List<TransportTaskEntity> findAll(List<Long> ids, Long id, Integer status, TransportTaskDTO dto) {
LambdaQueryWrapper<TransportTaskEntity> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(CollUtil.isNotEmpty(ids), TransportTaskEntity::getId, ids);
lambdaQueryWrapper.eq(ObjectUtil.isNotEmpty(id), TransportTaskEntity::getId, id);
lambdaQueryWrapper.eq(ObjectUtil.isNotEmpty(status), TransportTaskEntity::getStatus, status);
if (ObjectUtil.isNotEmpty(dto)) {
lambdaQueryWrapper.eq(ObjectUtil.isNotEmpty(dto.getTruckId()), TransportTaskEntity::getTruckId, dto.getTruckId());
}
lambdaQueryWrapper.orderByDesc(TransportTaskEntity::getCreated);
return list(lambdaQueryWrapper);
}
/**
* 完成运输任务
*
* @param transportTaskCompleteDTO 交付对象
*/
@Override
public void completeTransportTask(TransportTaskCompleteDTO transportTaskCompleteDTO) {
TransportTaskEntity transportTaskEntity = new TransportTaskEntity();
transportTaskEntity.setId(Long.valueOf(transportTaskCompleteDTO.getTransportTaskId()));
// 已完成
transportTaskEntity.setStatus(TransportTaskStatus.COMPLETED);
transportTaskEntity.setTransportCertificate(transportTaskCompleteDTO.getTransportCertificate());
transportTaskEntity.setDeliverPicture(transportTaskCompleteDTO.getDeliverPicture());
//实际到达时间
transportTaskEntity.setActualArrivalTime(LocalDateTime.now());
super.updateById(transportTaskEntity);
}
/**
* 开始运输任务
*
* @param transportTaskStartDTO 提货对象
*/
@Override
public void startTransportTask(TransportTaskStartDTO transportTaskStartDTO) {
TransportTaskEntity transportTaskEntity = new TransportTaskEntity();
transportTaskEntity.setId(Long.valueOf(transportTaskStartDTO.getTransportTaskId()));
// 进行中
transportTaskEntity.setStatus(TransportTaskStatus.PROCESSING);
transportTaskEntity.setCargoPickUpPicture(transportTaskStartDTO.getCargoPickUpPicture());
transportTaskEntity.setCargoPicture(transportTaskStartDTO.getCargoPicture());
//实际发车时间
transportTaskEntity.setActualDepartureTime(LocalDateTime.now());
super.updateById(transportTaskEntity);
}
@Override
public List<String> queryTransportOrderIdListById(Long id) {
//通过运输任务找到运单id列表
LambdaQueryWrapper<TransportOrderTaskEntity> queryWrapper = new LambdaQueryWrapper<TransportOrderTaskEntity>()
.eq(TransportOrderTaskEntity::getTransportTaskId, id);
List<TransportOrderTaskEntity> orderList = this.transportOrderTaskService.list(queryWrapper);
if (CollUtil.isEmpty(orderList)) {
return Collections.emptyList();
}
//运单id列表
return orderList.stream()
.map(TransportOrderTaskEntity::getTransportOrderId)
.collect(Collectors.toList());
}
@Override
public List<TransportTaskDTO> findAllByOrderIdOrTaskId(String transportOrderId, Long transportTaskId) {
if (ObjectUtil.isAllEmpty(transportOrderId, transportTaskId)) {
throw new SLException(WorkExceptionEnum.TRANSPORT_TASK_QUERY_PARAM_ERROR);
}
if (ObjectUtil.isNotEmpty(transportTaskId)) {
TransportTaskEntity transportTask = super.getById(transportTaskId);
if (ObjectUtil.isEmpty(transportTask)) {
throw new SLException(WorkExceptionEnum.TRANSPORT_TASK_NOT_FOUND);
}
return ListUtil.toList(BeanUtil.toBean(transportTask, TransportTaskDTO.class));
}
//通过关联表查询出运输任务id列表
List<TransportOrderTaskEntity> transportOrderTaskList = transportOrderTaskService.findAll(transportOrderId, null);
if (CollUtil.isEmpty(transportOrderTaskList)) {
return ListUtil.empty();
}
//根据运输任务id列表查询 运输任务数据列表
List<Long> transportTaskIds = CollUtil.getFieldValues(transportOrderTaskList, "transportTaskId", Long.class);
List<TransportTaskEntity> transportTasList = super.listByIds(transportTaskIds);
return BeanUtil.copyToList(transportTasList, TransportTaskDTO.class);
}
@Override
public TransportTaskDTO findById(Long id) {
TransportTaskEntity transportTask = super.getById(id);
if (ObjectUtil.isEmpty(transportTask)) {
throw new SLException(WorkExceptionEnum.TRANSPORT_TASK_NOT_FOUND);
}
TransportTaskDTO transportTaskDTO = BeanUtil.toBean(transportTask, TransportTaskDTO.class);
List<TransportOrderTaskEntity> list = this.transportOrderTaskService.findAll(null, transportTask.getId());
List<String> transportOrderIdList = CollUtil.getFieldValues(list, "transportOrderId", String.class);
transportTaskDTO.setTransportOrderIds(transportOrderIdList);
transportTaskDTO.setTransportOrderCount(CollUtil.size(transportOrderIdList));
return transportTaskDTO;
}
@Override
public List<TransportTaskStatusCountDTO> groupByStatus() {
//将所有的枚举状态放到集合中
List<TransportTaskStatusCountDTO> statusCountList = Arrays.stream(TransportTaskStatus.values())
.map(status -> TransportTaskStatusCountDTO.builder()
.status(status)
.statusCode(status.getCode())
.count(0L)
.build())
.collect(Collectors.toList());
//将数量值放入到集合中，如果没有的数量为0
List<TransportTaskStatusCountDTO> statusCount = super.baseMapper.findStatusCount();
for (TransportTaskStatusCountDTO statusCountDTO : statusCountList) {
for (TransportTaskStatusCountDTO countDTO : statusCount) {
if (ObjectUtil.equal(statusCountDTO.getStatusCode(), countDTO.getStatusCode())) {
statusCountDTO.setCount(countDTO.getCount());
break;
}
}
}
return statusCountList;
}
@Transactional
@Override
public void adjust(TaskTransportUpdateDTO dto) {
if (ObjectUtil.hasEmpty(dto, dto.getId())
|| ObjectUtil.isAllEmpty(dto.getTransportTripsId(), dto.getTruckId(), dto.getDriverIds())) {
throw new SLException(WorkExceptionEnum.TRANSPORT_TASK_UPDATE_PARAM_ERROR);
}
//修改任务
TransportTaskEntity transportTaskEntity = BeanUtil.toBean(dto, TransportTaskEntity.class);
super.updateById(transportTaskEntity);
// 删除之前对于的司机作业单
this.driverJobFeign.removeByTransportTaskId(dto.getId());
// 创建新的司机作业单
dto.getDriverIds().forEach(driverId -> this.driverJobFeign.createDriverJob(dto.getId(), driverId));
}
/**
* 延迟提货
*
* @param transportTaskDelayDeliveryDTO 延迟提货对象
*/
@Override
public void delayedDelivery(TransportTaskDelayDeliveryDTO transportTaskDelayDeliveryDTO) {
//1.将时间字符串转换格式
LocalDateTime delayTime = LocalDateTimeUtil.parse(transportTaskDelayDeliveryDTO.getDelayTime(), DatePattern.NORM_DATETIME_PATTERN);
//2.构建更新条件,根据任务id更新计划出发时间和备注
LambdaUpdateWrapper<TransportTaskEntity> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(ObjectUtil.isNotEmpty(transportTaskDelayDeliveryDTO.getTransportTaskId()), TransportTaskEntity::getId, transportTaskDelayDeliveryDTO.getTransportTaskId())
.set(ObjectUtil.isNotEmpty(delayTime), TransportTaskEntity::getPlanDepartureTime, delayTime)
.set(ObjectUtil.isNotEmpty(transportTaskDelayDeliveryDTO.getDelayReason()), TransportTaskEntity::getMark, transportTaskDelayDeliveryDTO.getDelayReason());
//3.更新运输任务
this.update(updateWrapper);
}
/**
* 任务里程统计
*
* @param transportTaskIds 运输任务id列表
* @param month 月份，格式：2022-06
* @return 每日里程数据
*/
@Override
public List<TransportTaskMonthlyDistanceDTO> monthlyDistanceStatistics(List<String> transportTaskIds, String month) {
//月度起止时间
DateTime dateTime = DateUtil.parse(month, DatePattern.NORM_MONTH_PATTERN);
LocalDateTime startTime = LocalDateTimeUtil.of(dateTime);
LocalDateTime endTime = LocalDateTimeUtil.of(DateUtil.endOfMonth(dateTime));
//根据任务id列表查询
return this.baseMapper.monthlyDistanceStatistics(transportTaskIds, startTime, endTime);
}
/**
* 根据起始机构查询运输任务id列表
*
* @param startAgencyId 起始机构id
* @param endAgencyId 结束机构id
* @return 运输任务id列表
*/
@Override
public List<Long> findByAgencyId(Long startAgencyId, Long endAgencyId) {
//1.构造查询条件
LambdaQueryWrapper<TransportTaskEntity> queryWrapper = Wrappers.<TransportTaskEntity>lambdaQuery()
.eq(ObjectUtil.isNotEmpty(startAgencyId), TransportTaskEntity::getStartAgencyId, startAgencyId)
.eq(ObjectUtil.isNotEmpty(endAgencyId), TransportTaskEntity::getEndAgencyId, endAgencyId);
//2.根据起始机构查询运输任务
List<TransportTaskEntity> transportTaskEntityList = this.list(queryWrapper);
//3.从运输任务中抽取id
return transportTaskEntityList.stream().map(TransportTaskEntity::getId).collect(Collectors.toList());
}
/**
* 根据车辆ID和状态统计
*
* @param truckId 车辆ID
* @return 个数
*/
@Override
public Long countByTruckId(Long truckId) {
return count(Wrappers.<TransportTaskEntity>lambdaQuery()
.in(TransportTaskEntity::getStatus, TransportTaskStatus.PENDING.getCode(), TransportTaskStatus.PROCESSING.getCode())
.eq(TransportTaskEntity::getTruckId, truckId)
);
}
}

7
sl-express-ms-work-service/src/main/resources/banner.txt Normal file
View File

@@ -0,0 +1,7 @@
_ ${spring.application.name} ${application.version}
___ | | ___ __ __ _ __ _ __ ___ ___ ___ Port: ${server.port}
/ __|| | _____ / _ \\ \/ /| '_ \ | '__|/ _ \/ __|/ __| Pid: ${pid} Profile(s): ${AnsiColor.GREEN}${spring.profiles.active}${AnsiColor.DEFAULT}
\__ \| ||_____|| __/ > < | |_) || | | __/\__ \\__ \
|___/|_| \___|/_/\_\| .__/ |_| \___||___/|___/ https://sl-express.itheima.net/
|_|

41
sl-express-ms-work-service/src/main/resources/bootstrap-local.yml Normal file
View File

@@ -0,0 +1,41 @@
server:
port: 18085
tomcat:
uri-encoding: UTF-8
threads:
max: 1000
min-spare: 30
spring:
cloud:
nacos:
username: nacos
password: nacos
server-addr: 192.168.150.101:8848
discovery:
namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
ip: 192.168.150.1
config:
namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
shared-configs: #共享配置
- data-id: shared-spring-seata.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-rabbitmq.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mysql.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-redis.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mybatis-plus.yml
group: SHARED_GROUP
refresh: false
# sentinel:
# transport:
# dashboard: 127.0.0.1:8080
# client-ip: 127.0.0.1
sl:
id:
leaf: ${sl.id.leaf} #指定美团leaf服务地址

36
sl-express-ms-work-service/src/main/resources/bootstrap-prod.yml Normal file
View File

@@ -0,0 +1,36 @@
server:
port: 18085
tomcat:
uri-encoding: UTF-8
threads:
max: 1000
min-spare: 30
spring:
cloud:
nacos:
username: nacos
password: vO5/dZ9,iL
server-addr: nacos-service.yjy-public-slwl-java-prod.svc.cluster.local:8848
discovery:
namespace: 92312ba8-1119-440f-81af-c29618df303b
config:
namespace: 92312ba8-1119-440f-81af-c29618df303b
shared-configs: #共享配置
- data-id: shared-spring-seata.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-rabbitmq.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mysql.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-redis.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mybatis-plus.yml
group: SHARED_GROUP
refresh: false
sl:
id:
leaf: ${sl.id.leaf} #指定美团leaf服务地址

40
sl-express-ms-work-service/src/main/resources/bootstrap-stu.yml Normal file
View File

@@ -0,0 +1,40 @@
server:
port: 18085
tomcat:
uri-encoding: UTF-8
threads:
max: 1000
min-spare: 30
spring:
cloud:
nacos:
username: nacos
password: nacos
server-addr: 192.168.150.101:8848
discovery:
namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
config:
namespace: ecae68ba-7b43-4473-a980-4ddeb6157bdc
shared-configs: #共享配置
- data-id: shared-spring-seata.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-rabbitmq.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mysql.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-redis.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mybatis-plus.yml
group: SHARED_GROUP
refresh: false
# sentinel:
# transport:
# dashboard: 127.0.0.1:8080
# client-ip: 127.0.0.1
sl:
id:
leaf: ${sl.id.leaf} #指定美团leaf服务地址

36
sl-express-ms-work-service/src/main/resources/bootstrap-test.yml Normal file
View File

@@ -0,0 +1,36 @@
server:
port: 18085
tomcat:
uri-encoding: UTF-8
threads:
max: 1000
min-spare: 30
spring:
cloud:
nacos:
username: nacos
password: nacos
server-addr: nacos-service.yjy-public-slwl-java.svc.cluster.local:8848
discovery:
namespace: 92312ba8-1119-440f-81af-c29618df303b
config:
namespace: 92312ba8-1119-440f-81af-c29618df303b
shared-configs: #共享配置
- data-id: shared-spring-seata.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-rabbitmq.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mysql.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-redis.yml
group: SHARED_GROUP
refresh: false
- data-id: shared-spring-mybatis-plus.yml
group: SHARED_GROUP
refresh: false
sl:
id:
leaf: ${sl.id.leaf} #指定美团leaf服务地址

27
sl-express-ms-work-service/src/main/resources/bootstrap.yml Normal file
View File

@@ -0,0 +1,27 @@
application:
version: v1.0
logging:
config: classpath:logback-spring.xml
# level:
# com.sl: debug
spring:
main:
allow-circular-references: true #允许bean循环依赖
application:
name: sl-express-ms-work
profiles:
active: local
mvc:
pathmatch:
#解决异常：swagger Failed to start bean 'documentationPluginsBootstrapper'; nested exception is java.lang.NullPointerException
#因为Springfox使用的路径匹配是基于AntPathMatcher的，而Spring Boot 2.6.X使用的是PathPatternMatcher
matching-strategy: ant_path_matcher
sl:
swagger:
package-path: com.sl.ms.work.controller
title: 神领物流 - work微服务接口文档
description: 提供运输任务、取派件任务等相关服务。
contact-name: 传智教育·研究院
contact-url: http://www.itcast.cn/
contact-email: yjy@itcast.cn
version: ${application.version}

56
sl-express-ms-work-service/src/main/resources/logback-spring.xml Normal file
View File

@@ -0,0 +1,56 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--scan: 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。-->
<!--scanPeriod: 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。-->
<!--debug: 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。-->
<configuration debug="false" scan="false" scanPeriod="60 seconds">
<springProperty scope="context" name="appName" source="spring.application.name"/>
<!--文件名-->
<property name="logback.appname" value="${appName}"/>
<!--文件位置-->
<property name="logback.logdir" value="/data/logs"/>
<!-- 定义控制台输出 -->
<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} - [%thread] - %-5level - %logger{50} - %msg%n</pattern>
</layout>
</appender>
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>DEBUG</level>
</filter>
<File>${logback.logdir}/${logback.appname}/${logback.appname}.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<FileNamePattern>${logback.logdir}/${logback.appname}/${logback.appname}.%d{yyyy-MM-dd}.log.zip</FileNamePattern>
<maxHistory>90</maxHistory>
</rollingPolicy>
<encoder>
<charset>UTF-8</charset>
<pattern>%d [%thread] %-5level %logger{36} %line - %msg%n</pattern>
</encoder>
</appender>
<appender name="GELF" class="biz.paluch.logging.gelf.logback.GelfLogbackAppender">
<!--GrayLog服务地址-->
<host>udp:192.168.150.101</host>
<!--GrayLog服务端口-->
<port>12201</port>
<version>1.1</version>
<!--当前服务名称-->
<facility>${appName}</facility>
<extractStackTrace>true</extractStackTrace>
<filterStackTrace>true</filterStackTrace>
<mdcProfiling>true</mdcProfiling>
<timestampPattern>yyyy-MM-dd HH:mm:ss,SSS</timestampPattern>
<maximumMessageSize>8192</maximumMessageSize>
</appender>
<!--evel:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，-->
<!--不能设置为INHERITED或者同义词NULL。默认是DEBUG。-->
<root level="INFO">
<appender-ref ref="stdout"/>
<!--<appender-ref ref="GELF"/>-->
</root>
</configuration>

17
sl-express-ms-work-service/src/main/resources/mapper/TaskPickupDispatchMapper.xml Normal file
View File

@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sl.ms.work.mapper.TaskPickupDispatchMapper">
<select id="findCountByCourierIds" resultType="com.sl.ms.work.domain.dto.CourierTaskCountDTO">
SELECT
COUNT(1) `count`,
courier_id
FROM sl_pickup_dispatch_task t
WHERE
t.courier_id IN <foreach collection="courierIds" item="courierId" open="(" close=")" separator=",">#{courierId}</foreach>
AND t.created BETWEEN #{startDateTime} AND #{endDateTime}
AND t.task_type = #{type}
GROUP BY courier_id
</select>
</mapper>

15
sl-express-ms-work-service/src/main/resources/mapper/TransportOrderMapper.xml Normal file
View File

@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sl.ms.work.mapper.TransportOrderMapper">
<select id="findStatusCount" resultType="com.sl.ms.work.domain.dto.response.TransportOrderStatusCountDTO">
SELECT
`status` AS statusCode,
count(1) AS count
FROM
sl_transport_order
GROUP BY
`status`
</select>
</mapper>

35
sl-express-ms-work-service/src/main/resources/mapper/TransportTaskMapper.xml Normal file
View File

@@ -0,0 +1,35 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.sl.ms.work.mapper.TransportTaskMapper">
<select id="findStatusCount" resultType="com.sl.ms.work.domain.dto.response.TransportTaskStatusCountDTO">
SELECT `status` AS statusCode,
count(1) AS count
FROM
sl_transport_task
GROUP BY
`status`
</select>
<select id="monthlyDistanceStatistics"
resultType="com.sl.ms.work.domain.dto.response.TransportTaskMonthlyDistanceDTO">
SELECT DATE_FORMAT(actual_arrival_time, '%Y-%m-%d') AS dateTime, sum(distance) AS mileage
FROM sl_transport_task
<where>
<if test="transportTaskIds!=null">
and id IN
<foreach collection="transportTaskIds" separator="," item="item" open="(" close=")">
#{item}
</foreach>
</if>
<if test="startTime !=null">
and actual_arrival_time &gt;= #{startTime}
</if>
<if test="endTime !=null">
and actual_arrival_time &lt; #{endTime}
</if>
</where>
GROUP BY dateTime
</select>
</mapper>