Merge remote-tracking branch 'origin/develop' into develop

project-dispatch/pom.xml

@@ -62,6 +62,11 @@
         </dependency>
 
         <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
+        </dependency>
+
+        <dependency>
             <groupId>com.alibaba.cloud</groupId>
             <artifactId>project-interface</artifactId>
             <version>${revision}</version>
@@ -146,6 +151,17 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-quartz</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.vladmihalcea</groupId>
+            <artifactId>hibernate-types-55</artifactId>
+            <version>2.21.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.8.22</version>
+        </dependency>
 
     </dependencies>
     <build>

project-dispatch/src/main/java/com/dituhui/pea/dispatch/DispatchServiceApplication.java

@@ -18,6 +18,7 @@ package com.dituhui.pea.dispatch;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.openfeign.EnableFeignClients;
 import org.springframework.scheduling.annotation.EnableScheduling;
 
 /**
@@ -25,6 +26,7 @@ import org.springframework.scheduling.annotation.EnableScheduling;
  */
 @SpringBootApplication
 @EnableScheduling
+@EnableFeignClients(basePackages = {"com.dituhui.pea.user"})
 public class DispatchServiceApplication {
 
 	public static void main(String[] args) {

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/DateSplit.java

+package com.dituhui.pea.dispatch.common;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.Date;
+
+
+@Getter
+@RequiredArgsConstructor
+@AllArgsConstructor
+public class DateSplit {
+    private Date startDateTime;
+    private Date endDateTime;
+
+
+    public void setStartDateTime(Date startDateTime) {
+        this.startDateTime = startDateTime;
+    }
+
+    public void setEndDateTime(Date endDateTime) {
+        this.endDateTime = endDateTime;
+    }
+
+    public LocalDateTime getStartLocalDateTime() {
+        return DateUtil.fromDate(this.startDateTime);
+    }
+
+    public LocalDateTime getLocalEndDateTime() {
+        return DateUtil.fromDate(this.endDateTime);
+    }
+
+    /**
+     * 获取开始时间片
+     *
+     * @return 开始时间
+     */
+    public LocalTime getStartTime() {
+        return this.getStartLocalDateTime().toLocalTime();
+    }
+
+    /**
+     * 获取结束时间片
+     *
+     * @return 结束时间
+     */
+    public LocalTime getEndTime() {
+        return this.getLocalEndDateTime().toLocalTime();
+    }
+}
\ No newline at end of file

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/DateUtils.java

+package com.dituhui.pea.dispatch.common;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.time.format.TextStyle;
+import java.time.temporal.ChronoUnit;
+import java.util.Locale;
+
+public class DateUtils {
+
+    public static String toWeekChinese(String date) {
+        LocalDate d = LocalDate.parse(date);
+        return DateUtils.toWeekChinese(d.getDayOfWeek().getValue());
+    }
+
+    public static String toWeekChinese(int dayOfWeek) {
+        // TextStyle: SHORT 周一；LONG 星期一；NARROW 一
+        return DayOfWeek.of(dayOfWeek).getDisplayName(TextStyle.SHORT, Locale.CHINESE);
+    }
+
+    public static String formatDateTime(LocalDateTime d, String format) {
+        return d.format(DateTimeFormatter.ofPattern(format));
+    }
+
+    public static String formatDateTime(LocalDateTime d) {
+        return formatDateTime(d, DateUtil.PATTERN_DATETIME);
+    }
+
+    public static String formatDate(LocalDate d, String format) {
+        return d.format(DateTimeFormatter.ofPattern(format));
+    }
+
+    public static String formatDate(LocalDate d) {
+        return formatDate(d, DateUtil.PATTERN_DATE);
+    }
+
+    public static long getAge(String birth) {
+        return ChronoUnit.YEARS.between(LocalDate.parse(birth), LocalDate.now());
+    }
+
+    public static LocalDate localDateFromStr(String dateStr) {
+        return localDateFromStr(dateStr, "yyyy-MM-dd");
+    }
+
+    public static LocalDate localDateFromStr(String str, String pattern) {
+        if (str.length() > pattern.length()) {
+            str = str.substring(0, pattern.length());
+        }
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
+        return LocalDate.parse(str, formatter);
+    }
+
+    public static LocalDateTime localDateTimeFromStr(String str) {
+        return localDateTimeFromStr(str, "yyyy-MM-dd HH:mm:ss");
+    }
+
+    public static LocalDateTime localDateTimeFromStr(String str, String pattern) {
+        if (str.length() > pattern.length()) {
+            str = str.substring(0, pattern.length());
+        }
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
+        return LocalDateTime.parse(str, formatter);
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/EngineerUtils.java

+package com.dituhui.pea.dispatch.common;
+
+import com.dituhui.pea.dispatch.dao.EngineerInfoRepository;
+import com.dituhui.pea.dispatch.dao.OrgGroupRepository;
+import com.dituhui.pea.dispatch.dao.OrgTeamEngineerDao;
+import com.dituhui.pea.dispatch.entity.EngineerInfo;
+import com.dituhui.pea.dispatch.entity.OrgGroup;
+import com.dituhui.pea.dispatch.entity.OrgTeamEngineerEntity;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.stereotype.Component;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+public class EngineerUtils {
+
+    @Autowired
+    private OrgTeamEngineerDao orgTeamEngineerDao;
+
+    @Autowired
+    private EngineerInfoRepository engineerInfoDao;
+
+    @Autowired
+    private OrgGroupRepository orgGroupDao;
+
+    public List<EngineerInfo> getEngineersByLevel(String levelType, String levelValue) {
+        List<EngineerInfo> engineers = null;
+        List<String> groupIds = null;
+        switch (levelType) {
+            case "team":
+                List<String> engineerCodes = orgTeamEngineerDao.findAllByTeamId(levelValue).stream()
+                        .map(OrgTeamEngineerEntity::getEngineerCode).collect(Collectors.toList());
+                engineers = engineerInfoDao.findByEngineerCodeIn(engineerCodes);
+                break;
+            case "group":
+                engineers = engineerInfoDao.findByGroupId(levelValue);
+                break;
+            case "branch":
+                groupIds = orgGroupDao.findAllByBranchId(levelValue).stream()
+                        .map(OrgGroup::getGroupId).collect(Collectors.toList());
+                engineers = engineerInfoDao.findByGroupIdIn(groupIds);
+                break;
+            default:
+                // "cluster".equals(levelType)
+                groupIds = orgGroupDao.findByClusterId(levelValue).stream()
+                        .map(OrgGroup::getGroupId).collect(Collectors.toList());
+                engineers = engineerInfoDao.findByGroupIdIn(groupIds);
+                break;
+        }
+        return engineers;
+    }
+
+
+    public Page<EngineerInfo> filterEngineersByKeyAndPage(List<String> engineerCodes, String key, Integer page, Integer size) {
+        Pageable pageable = PageRequest.of(page - 1, size);
+        return engineerInfoDao.findAllByEngineerCodeIn(engineerCodes, buildSpecification(key), pageable);
+    }
+
+    public List<EngineerInfo> filterEngineersByKey(List<String> engineerCodes, String key) {
+        return engineerInfoDao.findAllByEngineerCodeIn(engineerCodes, buildSpecification(key));
+    }
+
+
+    private Specification<EngineerInfo> buildSpecification(String keyword) {
+        // 动态查询
+        return new Specification<EngineerInfo>() {
+            @Override
+            public Predicate toPredicate(Root<EngineerInfo> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
+                List<Predicate> predicates = new ArrayList<>();
+
+                // 构建查询条件
+                Predicate engineerCodePredicate = criteriaBuilder.like(root.get("engineerCode"), "%" + keyword + "%");
+                Predicate mobilePredicate = criteriaBuilder.like(root.get("phone"), "%" + keyword + "%");
+                Predicate msgContentPredicate = criteriaBuilder.like(root.get("name"), "%" + keyword + "%");
+                predicates.add(criteriaBuilder.or(engineerCodePredicate, mobilePredicate, msgContentPredicate));
+
+                return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
+            }
+        };
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/OccupyInfo.java

+package com.dituhui.pea.dispatch.common;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+@Data
+@Accessors(chain = true)
+@AllArgsConstructor
+@NoArgsConstructor
+public class OccupyInfo {
+    protected LocalDateTime beginTime;
+    protected LocalDateTime endTime;
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/OccupyInfoDetail.java

+package com.dituhui.pea.dispatch.common;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.time.LocalDateTime;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+@Accessors(chain = true)
+@NoArgsConstructor
+public class OccupyInfoDetail extends OccupyInfo implements Comparable<OccupyInfoDetail> {
+    /**
+     * 时间片时长（分钟）
+     */
+    private long duration;
+
+    public OccupyInfoDetail(LocalDateTime beginTime, LocalDateTime endTime, long duration) {
+        super(beginTime, endTime);
+        this.duration = duration;
+    }
+
+    public OccupyInfoDetail(LocalDateTime beginTime, LocalDateTime endTime) {
+        super(beginTime, endTime);
+    }
+
+    // 判断两个时间片是否有交集
+    public boolean overlaps(OccupyInfoDetail other) {
+        // 如果一个时间片的开始时间在另一个时间片的结束时间之后，或者一个时间片的结束时间在另一个时间片的开始时间之前，那么他们没有交集
+        LocalDateTime maxStart = this.beginTime.isAfter(other.beginTime) ? this.beginTime : other.beginTime;
+        LocalDateTime minEnd = this.endTime.isAfter(other.endTime) ? other.endTime : this.endTime;
+        return maxStart.isBefore(minEnd);
+    }
+
+    // 计算两个时间片的交集
+    public OccupyInfoDetail intersection(OccupyInfoDetail other) {
+        // 如果两个时间片没有交集，返回null
+        if (!this.overlaps(other)) {
+            return null;
+        }
+        // 否则，返回一个新的时间片，其开始时间是两个时间片中较晚的开始时间，其结束时间是两个时间片中较早的结束时间
+        return new OccupyInfoDetail(this.beginTime.isAfter(other.beginTime) ? this.beginTime : other.beginTime, this.endTime.isBefore(other.endTime) ? this.endTime : other.endTime);
+    }
+
+    @Override
+    public int compareTo(OccupyInfoDetail o) {
+        return this.beginTime.compareTo(o.beginTime);
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/jackson/DateTimeUtil.java

+package com.dituhui.pea.dispatch.common.jackson;
+
+import com.dituhui.pea.dispatch.common.DateUtil;
+import lombok.experimental.UtilityClass;
+
+import java.time.*;
+import java.time.format.DateTimeFormatter;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAccessor;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * DateTime 工具类
+ *
+ * @author liuxin
+ */
+@UtilityClass
+public class DateTimeUtil {
+    /**
+     * yyyy-MM-dd HH:mm:ss
+     */
+    public static final DateTimeFormatter DATETIME_FORMAT = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATETIME);
+
+    /**
+     * yyyy-MM-dd HH:mm
+     */
+    public static final DateTimeFormatter DATETIME_FORMAT_NON_SECONDS = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATETIME_NON_SECONDS);
+    /**
+     * 日期格式 yyyy-MM-dd
+     */
+    public static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern(DateUtil.PATTERN_DATE);
+    /**
+     * 时间格式 HH:mm:ss
+     */
+    public static final DateTimeFormatter TIME_FORMAT = DateTimeFormatter.ofPattern(DateUtil.PATTERN_TIME);
+
+    /**
+     * 日期时间格式化
+     *
+     * @param temporal 时间
+     * @return 格式化后的时间
+     */
+    public static String formatDateTime(TemporalAccessor temporal) {
+        return DATETIME_FORMAT.format(temporal);
+    }
+
+    /**
+     * 日期时间格式化
+     *
+     * @param temporal 时间
+     * @return 格式化后的时间
+     */
+    public static String formatDate(TemporalAccessor temporal) {
+        return DATE_FORMAT.format(temporal);
+    }
+
+    /**
+     * 时间格式化
+     *
+     * @param temporal 时间
+     * @return 格式化后的时间
+     */
+    public static String formatTime(TemporalAccessor temporal) {
+        return TIME_FORMAT.format(temporal);
+    }
+
+    /**
+     * 日期格式化
+     *
+     * @param temporal 时间
+     * @param pattern  表达式
+     * @return 格式化后的时间
+     */
+    public static String format(TemporalAccessor temporal, String pattern) {
+        return DateTimeFormatter.ofPattern(pattern).format(temporal);
+    }
+
+    /**
+     * 将字符串转换为时间
+     *
+     * @param dateStr 时间字符串
+     * @param pattern 表达式
+     * @return 时间
+     */
+    public static TemporalAccessor parse(String dateStr, String pattern) {
+        DateTimeFormatter format = DateTimeFormatter.ofPattern(pattern);
+        return format.parse(dateStr);
+    }
+
+    /**
+     * 将字符串转换为时间
+     *
+     * @param dateStr   时间字符串
+     * @param formatter DateTimeFormatter
+     * @return 时间
+     */
+    public static TemporalAccessor parse(String dateStr, DateTimeFormatter formatter) {
+        return formatter.parse(dateStr);
+    }
+
+    /**
+     * 时间转 Instant
+     *
+     * @param dateTime 时间
+     * @return Instant
+     */
+    public static Instant toInstant(LocalDateTime dateTime) {
+        return dateTime.atZone(ZoneId.of("+8")).toInstant();
+    }
+
+    /**
+     * Instant 转 时间
+     *
+     * @param instant Instant
+     * @return Instant
+     */
+    public static LocalDateTime toDateTime(Instant instant) {
+        return LocalDateTime.ofInstant(instant, ZoneId.of("+8"));
+    }
+
+    /**
+     * 获取当前东八区时间
+     *
+     * @return LocalDateTime东八区对象
+     */
+    public static LocalDateTime generateLocalDateTime() {
+        return LocalDateTime.now(ZoneId.of("+8"));
+    }
+
+
+    /**
+     * 求两个时间差
+     *
+     * @param start    开始时间
+     * @param end      结束时间
+     * @param timeUnit 时间差单位 {@link TimeUnit}
+     * @return 指定单位时间差
+     */
+    public static long betweenTwoTime(Temporal start, Temporal end, TimeUnit timeUnit) {
+        Duration duration = Duration.between(start, end);
+        long result;
+        switch (timeUnit) {
+            case DAYS:
+                result = duration.toDays();
+                break;
+            case HOURS:
+                result = duration.toHours();
+                break;
+            case MINUTES:
+                result = duration.toMinutes();
+                break;
+            case SECONDS:
+                result = duration.getSeconds();
+                break;
+            case MILLISECONDS:
+                result = duration.toMillis();
+                break;
+            case NANOSECONDS:
+                result = duration.toNanos();
+                break;
+            default:
+                throw new IllegalStateException("Unexpected value: " + timeUnit);
+        }
+
+        return result;
+    }
+
+    /**
+     * 当前时间是否在时间指定范围内, 包含起始时间<br>
+     *
+     * @param time      被检查的时间
+     * @param beginTime 起始时间
+     * @param endTime   结束时间
+     * @return 是否在范围内
+     * @since 3.0.8
+     */
+    public static boolean isIn(LocalTime time, LocalTime beginTime, LocalTime endTime) {
+        if ((Objects.equals(beginTime, time) || beginTime.isBefore(time))
+                && (endTime.isAfter(time) || Objects.equals(endTime, time))) {
+            return true;
+        }
+        return false;
+    }
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/jackson/JsonUtil.java

+package com.dituhui.pea.dispatch.common.jackson;
+
+import com.dituhui.pea.dispatch.common.DateUtil;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.json.JsonReadFeature;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.*;
+import lombok.experimental.UtilityClass;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.TimeZone;
+
+/**
+ * json 工具类 基于Jackson
+ *
+ * @author liuxin
+ */
+@UtilityClass
+@Slf4j
+public class JsonUtil {
+
+    /**
+     * 序列化对象为 json string
+     *
+     * @param value java对象
+     * @param <T>   泛型标记
+     * @return json字符串， 转换失败返回空白
+     */
+    public static <T> String toJson(T value) {
+        try {
+            return value instanceof String ? (String) value : getInstance().writeValueAsString(value);
+        } catch (JsonProcessingException e) {
+            log.error("[JsonUtil][toJson] ------> {}", e.getMessage(), e);
+            return "";
+        }
+    }
+
+    /**
+     * 实体转格式化jsonString
+     *
+     * @param entity java对象
+     * @param <E>    泛型标记
+     * @return json string
+     */
+    public static <E> String objectToJsonPretty(E entity) {
+        try {
+            return entity instanceof String ? (String) entity
+                    : getInstance().writerWithDefaultPrettyPrinter()
+                            .writeValueAsString(entity);
+        } catch (Exception e) {
+            log.error("[JsonUtil][toJson]----> Parse Object to Json error，ex:{}", e.getMessage(), e);
+            return "";
+        }
+    }
+
+    /**
+     * 实体转格式化jsonString 去除空值
+     *
+     * @param entity java对象
+     * @param <E>    泛型标记
+     * @return json string
+     */
+    public static <E> String objectToJsonPrettyNoneNull(E entity) {
+        try {
+            return entity instanceof String ? (String) entity
+                    : getNonNullInstance().writerWithDefaultPrettyPrinter()
+                            .writeValueAsString(entity);
+        } catch (Exception e) {
+            log.error("[JsonUtil][toJson]----> Parse Object to Json error，ex:{}", e.getMessage(), e);
+            return "";
+        }
+    }
+
+    /**
+     * 将对象序列化成 json byte 数组
+     *
+     * @param object javaBean
+     * @return jsonString json字符串
+     */
+    public static byte[] toJsonAsBytes(Object object) {
+        try {
+            return getInstance().writeValueAsBytes(object);
+        } catch (JsonProcessingException e) {
+            log.error("[JsonUtil][toJsonAsBytes]----> Parse Object to Json as byte error，ex:{}", e.getMessage(), e);
+        }
+        return new byte[0];
+    }
+
+    /**
+     * 将json反序列化成对象
+     *
+     * @param content content
+     * @param clazz   class
+     * @param <T>     T 泛型标记
+     * @return Bean
+     */
+    public static <T> Optional<T> parse(String content, Class<T> clazz) {
+        try {
+            return Optional.of(getInstance().readValue(content, clazz));
+        } catch (Exception e) {
+            log.error("[JsonUtil][parse]----> Parse string to object  with type error，ex:{}", e.getMessage(), e);
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * 将json反序列化成对象
+     *
+     * @param content       content
+     * @param typeReference 泛型类型
+     * @param <T>           T 泛型标记
+     * @return Bean
+     */
+    public static <T> Optional<T> parse(String content, TypeReference<T> typeReference) {
+        try {
+            return Optional.of(getInstance().readValue(content, typeReference));
+        } catch (IOException e) {
+            log.error("[JsonUtil][parse]----> Parse string to object  with type reference error，ex:{}", e.getMessage(),
+                    e);
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * 将json字符串转成 JsonNode
+     *
+     * @param jsonString jsonString
+     * @return jsonString json字符串
+     */
+    public static Optional<JsonNode> readTree(String jsonString) {
+        try {
+            return Optional.of(getInstance().readTree(jsonString));
+        } catch (IOException e) {
+            log.error("[JsonUtil][readTree]----> Parse string to json node error，ex:{}", e.getMessage(), e);
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * 将json字符串转换为集合
+     *
+     * @param src             jsonString
+     * @param collectionClass 集合类型 List, Set, Map
+     * @param elementClasses  集合内元素类型
+     * @param <T>             泛型标记
+     * @return 集合
+     */
+    public static <T> Optional<T> parse(String src, Class<?> collectionClass, Class<?>... elementClasses) {
+        if (StringUtils.isBlank(src)) {
+            return Optional.empty();
+        }
+        JavaType javaType = getInstance().getTypeFactory().constructParametricType(collectionClass, elementClasses);
+        try {
+            return Optional.ofNullable(getInstance().readValue(src, javaType));
+        } catch (Exception e) {
+            log.error("【JsonUtil】---->Parse Json to collection error,ex:{}", e.getMessage());
+            return Optional.empty();
+        }
+    }
+
+    /**
+     * ObjectMapper 实例获取 （序列化后包含null值）
+     * @return ObjectMapper实例
+     */
+    public static ObjectMapper getInstance() {
+        return JacksonHolder.INSTANCE;
+    }
+
+    /**
+     *  ObjectMapper 实例获取 （序列化后不包含null值）
+     * @return ObjectMapper实例
+     */
+    public static ObjectMapper getNonNullInstance() {
+        final ObjectMapper instance = new JacksonObjectMapper();
+        instance.setSerializationInclusion(JsonInclude.Include.NON_NULL);
+        return instance;
+    }
+
+    /**
+     * 获取全局 JacksonObjectMapper
+     */
+    private static class JacksonHolder {
+        private static final ObjectMapper INSTANCE = new JacksonObjectMapper();
+    }
+
+    /**
+     * 定义 JacksonObjectMapper 序列化
+     */
+    public static class JacksonObjectMapper extends ObjectMapper {
+        private static final long serialVersionUID = 4288193147502386170L;
+
+        private static final Locale CHINA = Locale.CHINA;
+
+        /**
+         * 构造器初始化
+         */
+        public JacksonObjectMapper() {
+            super();
+            // 设置地点为中国
+            super.setLocale(CHINA);
+            // 去掉默认的时间戳格式
+            super.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
+            // 设置为中国上海时区
+            super.setTimeZone(TimeZone.getTimeZone("+8"));
+            // 序列化时，日期的统一格式
+            super.setDateFormat(new SimpleDateFormat(DateUtil.PATTERN_DATETIME, Locale.CHINA));
+            // 序列化处理
+            super.configure(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature(), true);
+            super.configure(JsonReadFeature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER.mappedFeature(), true);
+            super.findAndRegisterModules();
+            // 失败处理
+            super.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+            super.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+            // 单引号处理
+            super.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
+            // 反序列化时，属性不存在的兼容处理s
+            super.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
+            // 日期格式化
+            super.registerModule(new LJavaTimeModule());
+            super.findAndRegisterModules();
+        }
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/common/jackson/LJavaTimeModule.java

+package com.dituhui.pea.dispatch.common.jackson;
+
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.datatype.jsr310.PackageVersion;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+
+/**
+ * 定义java.util.time 序列化格式
+ */
+public class LJavaTimeModule extends SimpleModule {
+    /**
+     * 构造器定义时间序列化格式
+     */
+    public LJavaTimeModule() {
+        super(PackageVersion.VERSION);
+        this.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeUtil.DATETIME_FORMAT));
+        this.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeUtil.DATE_FORMAT));
+        this.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeUtil.TIME_FORMAT));
+        this.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeUtil.DATETIME_FORMAT));
+        this.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeUtil.DATE_FORMAT));
+        this.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeUtil.TIME_FORMAT));
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/CapacityEngineerCalendarDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.CapacityEngineerCalendarEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+public interface CapacityEngineerCalendarDao extends JpaRepository<CapacityEngineerCalendarEntity, Integer> {
+
+    @Query("select a from CapacityEngineerCalendarEntity a where a.engineerCode=:engineerCode and a.workday between :beginDate and :endDate")
+    List<CapacityEngineerCalendarEntity> findCalendarByEngineerCodeAndDateBetween(String engineerCode, String beginDate, String endDate);
+
+    CapacityEngineerCalendarEntity getByPlanId(String planId);
+
+    @Query("select count(*) from CapacityEngineerCalendarEntity a where a.type = :type and (a.startTime BETWEEN :startDate and  :endDate) and a.engineerCode in :engineers")
+    Integer queryEngineerPlanNum(List<String> engineers, LocalDateTime startDate, LocalDateTime endDate, String type);
+
+    @Modifying
+    @Query("delete from CapacityEngineerCalendarEntity a where a.engineerCode in :engineerCodes and a.type = :type and a.workday between :startDate and :endDate")
+    void deleteByTypeAndEngineerCodesAndBetweenDates(List<String> engineerCodes, String type, String startDate, String endDate);
+
+    List<CapacityEngineerCalendarEntity> findCalendarByWorkdayAndEngineerCode(String date, String engineerCode);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/CapacityEngineerStatDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.CapacityEngineerStatEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface CapacityEngineerStatDao extends JpaRepository<CapacityEngineerStatEntity, Integer> {
+
+    CapacityEngineerStatEntity getByWorkdayAndEngineerCode(String workday, String engineerCode);
+
+    List<CapacityEngineerStatEntity> getByWorkdayAndEngineerCodeIn(String workday, List<String> engineerCodes);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/EngineerBusinessDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.EngineerBusinessEntity;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author zhangx
+ */
+
+
+public interface EngineerBusinessDao extends CrudRepository<EngineerBusinessEntity, Long> {
+
+
+    @Transactional
+    @Modifying
+    @Query("UPDATE EngineerBusinessEntity tt SET tt.address = :address, tt.X= :x, tt.Y=:y  WHERE tt.engineerCode = :engineerCode")
+    void updateEngineerCenter(String address, String x, String y, String engineerCode);
+
+    EngineerBusinessEntity getByEngineerCode(String engineerCode);
+
+    List<EngineerBusinessEntity> findByEngineerCodeIn(List<String> engineerCodes);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/EngineerInfoRepository.java

 package com.dituhui.pea.dispatch.dao;
 
 import com.dituhui.pea.dispatch.entity.EngineerInfo;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.query.Param;
 
 import java.util.List;
 import java.util.Optional;
 
-public interface EngineerInfoRepository extends CrudRepository<EngineerInfo, Long> {
+public interface EngineerInfoRepository extends CrudRepository<EngineerInfo, Long>,
+        JpaRepository<EngineerInfo, Long>,
+        JpaSpecificationExecutor<EngineerInfo> {
+
+    List<EngineerInfo> findByGroupIdIn(List<String> groupIds);
 
     List<EngineerInfo> findByGroupId(String groupId);
 
+    EngineerInfo getByEngineerCode(String engineerCode);
+
     Optional<EngineerInfo> findByEngineerCode(String engineerCode);
-    
+
     List<EngineerInfo> findByEngineerCodeIn(List<String> engineerCodes);
-    
+
+    default List<EngineerInfo> findAllByEngineerCodeIn(List<String> engineerCodes, Specification<EngineerInfo> engineerInfoEntitySpecification) {
+        Specification<EngineerInfo> spec = Specification.where(engineerCodeIn(engineerCodes)).and(engineerInfoEntitySpecification);
+        return findAll(spec);
+    }
+
+    default Page<EngineerInfo> findAllByEngineerCodeIn(List<String> engineerCodes, Specification<EngineerInfo> engineerInfoEntitySpecification, Pageable pageable) {
+        Specification<EngineerInfo> spec = Specification.where(engineerCodeIn(engineerCodes)).and(engineerInfoEntitySpecification);
+        return findAll(spec, pageable);
+    }
+
+    static Specification<EngineerInfo> engineerCodeIn(List<String> engineerCodes) {
+        return (root, query, criteriaBuilder) -> root.get("engineerCode").in(engineerCodes);
+    }
+
+    @Query(value = "select t.* from engineer_info t\n" +
+            "join org_group g on g.group_id=t.group_id and g.`status`=1 and g.branch_id=?1",
+            nativeQuery = true)
+    List<EngineerInfo> getAllByBranchId(String branchId);
+
+    /**
+     * 查询工作队下的指定工程师信息
+     *
+     * @param engineerCode 工程师编号
+     * @param teamId       工作队ID
+     * @return 工作队下没有工程师则返回空
+     */
+    @Query(value = "SELECT  ei.* from org_team_engineer ote  left join  engineer_info ei  ON  ote.engineer_code = ei.engineer_code " +
+            "WHERE ote.team_id = :teamId AND ote.engineer_code = :engineerCode AND ote.`status` = 1", nativeQuery = true)
+    EngineerInfo selectEngineerByEngineerCodeAndTeamId(@Param("engineerCode") String engineerCode, @Param("teamId") String teamId);
 }
\ No newline at end of file

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/EngineerSliceUsedCapacityDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.CapacityEngineerSliceUsedEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface EngineerSliceUsedCapacityDao extends JpaRepository<CapacityEngineerSliceUsedEntity, Long> {
+
+    List<CapacityEngineerSliceUsedEntity> findByWorkdayAndEngineerCode(String workDay, String engineerCode);
+    List<CapacityEngineerSliceUsedEntity> deleteByWorkdayAndEngineerCode(String workDay, String engineerCode);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/MapBlockInfoDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.MapBlockInfoEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface MapBlockInfoDao extends JpaRepository<MapBlockInfoEntity, Integer>, JpaSpecificationExecutor<MapBlockInfoEntity> {
+
+    List<MapBlockInfoEntity> findByAreaIdsLikeAndLayerIdIn(String blockId, List<String> layerIds);
+
+    MapBlockInfoEntity findByAreaIds(String blockId);
+
+    List<MapBlockInfoEntity> findByGroupId(String groupId);
+
+    List<MapBlockInfoEntity> findByLayerId(String layerId);
+
+    MapBlockInfoEntity findByTeamIdAndLayerId(String teamId, String layerId);
+
+    List<MapBlockInfoEntity> findByAreaIdsIn(List<String> blockIds);
+
+    List<MapBlockInfoEntity> findByAreaIdsLike(String blockId);
+
+    @Query(value = "select mbi.*  from map_block_info mbi left join map_layer_customize_skill mlcs  on mlcs.layer_id = mbi.layer_id " +
+            "left join map_layer_customize mlc  on mlc.layer_id = mbi.layer_id left join skill_info si on si.skill_code  = mlcs.skill_code " +
+            "where si.brand = :brand and si.`type` = :productType and si.skill = :skill order by mlc.priority ", nativeQuery = true)
+    List<MapBlockInfoEntity> listTeamIdByBrandAndSkill(@Param("brand") String brand, @Param("productType") String productType,
+                                                       @Param("skill") String skill);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/OrgGroupRepository.java

@@ -14,4 +14,6 @@ public interface OrgGroupRepository extends CrudRepository<OrgGroup, Long> {
     Optional<OrgGroup> findByGroupId(String groupId);
 
     List<OrgGroup> findAllByBranchId(String branchId);
+
+    List<OrgGroup> findByClusterId(String levelValue);
 }

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/OrgTeamDao.java

 package com.dituhui.pea.dispatch.dao;
 
 import java.util.List;
+import java.util.Set;
 
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
@@ -24,4 +25,14 @@ public interface OrgTeamDao extends JpaRepository<OrgTeamEntity, Integer>, JpaSp
             "join org_cluster c on c.cluster_id=b.cluster_id and c.`status`=1",
             nativeQuery = true)
     List<OrgTeamEntity> findAllTeam();
+
+    /**
+     * 获取工程师所在的工作队
+     *
+     * @param engineerCode 工程师代码
+     * @return 工程师所在工作队信息
+     */
+    @Query(value = "SELECT ot.* FROM org_team_engineer ote LEFT JOIN org_team ot  ON ote.team_id = ot.team_id  WHERE  ote.engineer_code = :engineerCode " +
+            " AND ote.`status` = 1   AND ot.status = 1 ", nativeQuery = true)
+    Set<OrgTeamEntity> selectTeamByEngineerCode(String engineerCode);
 }

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/PubParamsDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.PubParamsEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface PubParamsDao extends JpaRepository<PubParamsEntity, Integer> {
+
+    List<PubParamsEntity> findByBiztype(String biztype);
+
+    List<PubParamsEntity> findByCatalogAndBiztype(String cagtalog, String biztype);
+
+    PubParamsEntity getByCatalogAndBiztypeAndPkey(String catalog, String biztype, String pkey);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/SkillInfoDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.SkillInfoEntity;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface SkillInfoDao extends JpaRepository<SkillInfoEntity, Long> {
+    List<SkillInfoEntity> findAll();
+
+    Page<SkillInfoEntity> findAll(Pageable pageable);
+
+    SkillInfoEntity getByBrandAndTypeAndSkill(String brand, String type, String skill);
+
+    List<SkillInfoEntity> getByBrandAndTypeAndSkillCode(String brand, String type, String skillCode);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dao/TimeSliceDao.java

+package com.dituhui.pea.dispatch.dao;
+
+import com.dituhui.pea.dispatch.entity.TimeSliceEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface TimeSliceDao extends JpaRepository<TimeSliceEntity, Long> {
+
+    List<TimeSliceEntity> findByType(String type);
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/CalendarBatAddDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+public class CalendarBatAddDTO {
+    @lombok.Data
+    public static class Request {
+        /**
+         * 结束时间；如果是全天只需要填写日期；否则填写日期+时间
+         */
+        @NotBlank
+        private String end;
+        /**
+         * 技术员code列表
+         */
+        @NotEmpty
+        private List<String> engineerCodes;
+        /**
+         * 是否全天
+         */
+        @NotNull
+        private Boolean isAllday;
+        /**
+         * 备注
+         */
+        private String remark;
+        /**
+         * 重复截止日期
+         */
+        // @NotBlank
+        private String repeatEndDate;
+        /**
+         * 重复类型
+         */
+        @NotBlank
+        private String repeatType;
+        /**
+         * 开始时间；如果是全天只需要填写日期；否则填写日期+时间
+         */
+        @NotBlank
+        private String start;
+        /**
+         * 日程类型
+         */
+        @NotBlank
+        private String type;
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/CalendarBatDelDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+public class CalendarBatDelDTO {
+
+    @lombok.Data
+    public static class Request {
+        /**
+         * 结束时间
+         */
+        @NotBlank
+        @JsonFormat(pattern = "yyyy-MM-dd")
+        private String endDate;
+        /**
+         * 技术员code列表
+         */
+        @NotEmpty
+        private List<String> engineerCodes;
+        /**
+         * 开始时间
+         */
+        @NotBlank
+        @JsonFormat(pattern = "yyyy-MM-dd")
+        private String startDate;
+        /**
+         * 日程类型
+         */
+        @NotBlank
+        private String type;
+    }
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/CalendarDeleteDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import javax.validation.constraints.NotBlank;
+
+public class CalendarDeleteDTO {
+
+    @lombok.Data
+    public static class Request {
+
+        @NotBlank
+        private String engineerCode;
+        @NotBlank
+        private String planId;
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/CalendarDetailDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.experimental.Accessors;
+
+import javax.validation.constraints.NotBlank;
+
+public class CalendarDetailDTO {
+
+    @lombok.Data
+    public static class Request {
+        @NotBlank(message = "工程师编号不能为空")
+        private String engineerCode;
+        @NotBlank(message = "所属计划配置编码不能为空")
+        private String planId;
+    }
+
+    @lombok.Data
+    @Accessors(chain = true)
+    public static class Result {
+        private String engineerCode;
+        private String engineerName;
+        private String operator;
+        private String phone;
+        private String planId;
+        private String remark;
+
+        private String type;
+        private String typeName;
+
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+        private String startTime;
+
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+        private String endTime;
+
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+        private String updateTime;
+    }
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/CalendarQueryNumDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+public class CalendarQueryNumDTO {
+
+    @lombok.Data
+    public static class Request {
+        @NotEmpty
+        private List<String> engineerCodes;
+        @NotBlank
+        private String type;
+        @NotBlank
+        @JsonFormat(pattern = "yyyy-MM-dd")
+        private String startDate;
+        @NotBlank
+        @JsonFormat(pattern = "yyyy-MM-dd")
+        private String endDate;
+    }
+
+    @lombok.Data
+    public static class Result {
+        private long planNum;
+    }
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/CalendarTypeDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+public class CalendarTypeDTO {
+
+    @Data
+    public static class Result {
+        private List<Type> types;
+    }
+
+    @Data
+    public static class Type {
+        private BarStyle barStyle;
+        private TagStyle tagStyle;
+        private String type;
+        private String typeName;
+    }
+
+    @Data
+    public static class BarStyle {
+        private String backgroundColor;
+        private String color;
+    }
+
+    @Data
+    public static class TagStyle {
+        private String backgroundColor;
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/CalendarUpdateDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import javax.validation.constraints.NotBlank;
+
+public class CalendarUpdateDTO {
+
+    @lombok.Data
+    public static class Request {
+        @NotBlank
+        private String startTime;
+        @NotBlank
+        private String endTime;
+        @NotBlank
+        private String engineerCode;
+        @NotBlank
+        private String planId;
+        private String remark;
+
+    }
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/EngineerCalendarDTO.java

+package com.dituhui.pea.dispatch.dto;
+
+import java.util.List;
+
+public class EngineerCalendarDTO {
+
+    @lombok.Data
+    public static class Request {
+        private String date;
+        /**
+         * 姓名，工号
+         */
+        private String key;
+        private String levelType;
+        private String levelValue;
+        private Integer size = 10;
+        private Integer page = 1;
+    }
+
+
+    @lombok.Data
+    public static class Result {
+        private long pageCurrent;
+        private long pages;
+        private long pageSize;
+        private long total;
+        private List<Engineer> engineers;
+    }
+
+
+    @lombok.Data
+    public static class Engineer {
+        private List<Calendar> calendar;
+        private String engineerCode;
+        private String name;
+    }
+
+    @lombok.Data
+    public static class Calendar {
+        private List<Content> content;
+        private String date;
+        private String week;
+    }
+
+    @lombok.Data
+    public static class Content {
+        private String title;
+        private String type;
+        private String value;
+        private String planId;
+    }
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/param/CapacityQueryDTO.java

+package com.dituhui.pea.dispatch.dto.param;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.validation.annotation.Validated;
+
+import javax.validation.Valid;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * 创单可用容量
+ */
+@Validated
+@Setter
+@Getter
+public class CapacityQueryDTO {
+
+    /**
+     * 查询参数
+     */
+    @Setter
+    @Getter
+    public static class Request {
+        /**
+         * 服务技能
+         */
+        @Valid
+        private List<Service> services;
+
+        /**
+         * 地址坐标信息
+         */
+        @Valid
+        @NotNull(message = "地址坐标信息不能为空")
+        private Location location;
+
+        /**
+         * 查询起始日期
+         */
+        @NotNull(message = " 查询起始日期不能为空， 格式：yyyy-MM-dd ")
+        @DateTimeFormat(pattern = "yyyy-MM-dd")
+        @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+        private Date beginDate;
+        /**
+         * 查询结束日期
+         */
+        @NotNull(message = " 查询结束日期不能为空， 格式：yyyy-MM-dd ")
+        @DateTimeFormat(pattern = "yyyy-MM-dd")
+        @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+        private Date endDate;
+
+    }
+
+
+    /**
+     * 返回值
+     */
+    @Setter
+    @Getter
+    public static class Result {
+        /**
+         * 符合条件的履约组织网点)Id
+         */
+        private String groupId;
+
+        /**
+         * 原始请求参数
+         */
+        private Request params;
+
+        /**
+         * 需要的服务时长,单位: 分钟
+         */
+        private int takeTime;
+
+        /**
+         * 查询容量返回结果
+         */
+        private List<Data> datas;
+    }
+
+    /**
+     * 改派到人查询结果
+     */
+    @Setter
+    @Getter
+    public static class PersonalResult {
+        /**
+         * 查询的工程师工号
+         */
+        private String engineerCode;
+
+        /**
+         * 查询工程师姓名
+         */
+        private String engineerName;
+
+        /**
+         * 查询容量返回结果
+         */
+        private List<Data> datas;
+    }
+
+    /**
+     * 查询容量返回结果
+     */
+    @Setter
+    @Getter
+    public static class Data {
+        /**
+         * 日期 yyyy-MM-dd
+         */
+        @DateTimeFormat(pattern = "yyyy-MM-dd")
+        @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+        private Date date;
+
+        /**
+         * 容量列表
+         */
+        private List<Segment> segments;
+    }
+
+
+    /**
+     * 容量
+     */
+    @Setter
+    @Getter
+    public static class Segment {
+        /**
+         * 最大可用时长, 单位: 分钟
+         */
+        private long maxDuration;
+
+        /**
+         * 容量名称 全天/上午/下午/晚上/时间段
+         */
+        private String name;
+
+        /**
+         * 起始时间 yyyy-MM-dd HH:mm:ss
+         */
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+        @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+        private Date beginTime;
+
+        /**
+         * 截止时间 yyyy-MM-dd HH:mm:ss
+         */
+        @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+        @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+        private Date endTime;
+
+        /**
+         * 容量状态 0不可约；1可约；
+         */
+        private int status;
+
+        /**
+         * 剩余容量
+         */
+        private long remain;
+
+        /**
+         * 区间总容量
+         */
+        private long totalCapacity;
+    }
+
+
+    /**
+     * 服务
+     */
+    @Setter
+    @Getter
+    public static class Service {
+        /**
+         * 品牌 （CODE）
+         */
+        @NotBlank(message = "品牌(code)不能为空")
+        private String brand;
+        /**
+         * 产品类型 (CODE)
+         */
+        @NotBlank(message = "产品类型(code)不能为空")
+        private String productType;
+
+        /**
+         * 需要的技能 (CODE)
+         */
+        @NotBlank(message = "技能(code)不能为空")
+        private String serviceType;
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/param/EngineerBaseInfo.java

+package com.dituhui.pea.dispatch.dto.param;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 工程师基础信息
+ */
+@Setter
+@Getter
+@EqualsAndHashCode(callSuper = false)
+public class EngineerBaseInfo extends EngineerCode {
+
+    /**
+     * 工程师名称
+     */
+    private String engineerName;
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/param/EngineerCalendar.java

+package com.dituhui.pea.dispatch.dto.param;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.util.Date;
+
+/**
+ * 工程师日历
+ */
+@Setter
+@Getter
+@EqualsAndHashCode
+public class EngineerCalendar {
+    /**
+     * 日期
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private Date date;
+    /**
+     * 事件类型
+     */
+    private String eventType;
+    /**
+     * 事件
+     */
+    private String event;
+    /**
+     * 事件名称
+     */
+    private String content;
+
+    /**
+     * 开始时间
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date beginTime;
+    /**
+     * 结束时间
+     */
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date endTime;
+    /**
+     * 备注
+     */
+    private String memo ;
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/param/EngineerCalendarResultDTO.java

+package com.dituhui.pea.dispatch.dto.param;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+/**
+ * 技术员日历返回参数
+ */
+@Setter
+@Getter
+@EqualsAndHashCode(callSuper = false)
+public class EngineerCalendarResultDTO extends EngineerBaseInfo {
+    /**
+     * 日历内容
+     */
+    private List<EngineerCalendar> calendar;
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/param/EngineerCode.java

+package com.dituhui.pea.dispatch.dto.param;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+
+/**
+ * 工程师编号
+ */
+@Setter
+@Getter
+@EqualsAndHashCode
+public class EngineerCode {
+    /**
+     * 工程师工号
+     */
+    @NotBlank(message = "工程师工号不能为空")
+    protected String engineerCode;
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/dto/param/Location.java

+package com.dituhui.pea.dispatch.dto.param;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotNull;
+
+/**
+ * 地址坐标信息
+ */
+@Setter
+@Getter
+public class Location {
+
+    /**
+     * 地址ID
+     */
+    private String addressId;
+
+    /**
+     * 地点名称，例如：xx小区
+     */
+    private String name;
+
+    /**
+     * 详细地址， xx路xx号等信息
+     */
+    private String address;
+
+    /**
+     * 地址纬度
+     */
+    @NotNull
+    private Double latitude;
+
+    /**
+     * 地址经度
+     */
+    @NotNull
+    private Double longitude;
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/CapacityEngineerCalendarEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "capacity_engineer_calendar")
+@Data
+public class CapacityEngineerCalendarEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(nullable = false)
+    private String workday;
+
+    @Column(name = "engineer_code", nullable = false, columnDefinition = "varchar(50) default '0'")
+    private String engineerCode;
+
+    @Column(name = "start_time", nullable = false)
+    private LocalDateTime startTime;
+
+    @Column(name = "end_time", nullable = false)
+    private LocalDateTime endTime;
+
+
+    @Column(name = "plan_id")
+    private String planId;
+
+    @Column(nullable = false)
+    private String type;
+
+    @Column(name = "reason")
+    private String reason;
+
+    @Column(nullable = false)
+    private String memo = "";
+
+    @Column(name = "operator_id")
+    private String operatorId;
+
+    @Column(name = "operator_name")
+    private String operatorName;
+
+    @Column(name = "create_time", nullable = false, updatable = false, columnDefinition = "timestamp default current_timestamp")
+    private LocalDateTime createTime = LocalDateTime.now();
+
+    @Column(name = "update_time", nullable = false, columnDefinition = "timestamp default current_timestamp on update current_timestamp")
+    private LocalDateTime updateTime = LocalDateTime.now();
+
+    // 其他字段和关联关系的定义
+    // ...
+}
+

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/CapacityEngineerSliceUsedEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+import com.dituhui.pea.dispatch.common.OccupyInfoDetail;
+import com.vladmihalcea.hibernate.type.json.JsonStringType;
+import lombok.Getter;
+import org.hibernate.annotations.GenericGenerator;
+import org.hibernate.annotations.Type;
+import org.hibernate.annotations.TypeDef;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Objects;
+
+@Getter
+@Entity
+@Table(name = "capacity_engineer_slice_used")
+@TypeDef(name = "json", typeClass = JsonStringType.class)
+public class CapacityEngineerSliceUsedEntity {
+    @Id
+    @Column(name = "id")
+    @GeneratedValue(generator = "uuid")
+    @GenericGenerator(name = "uuid", strategy = "uuid")
+    private String id;
+
+    @OneToOne(targetEntity = TimeSliceEntity.class,
+            cascade = {CascadeType.DETACH},
+            fetch = FetchType.EAGER)
+    @JoinColumn(name = "timme_slice", referencedColumnName = "id")
+    private TimeSliceEntity timmeSlice;
+    @Basic
+    @Column(name = "workday")
+    private String workday;
+    @Basic
+    @Column(name = "engineer_code")
+    private String engineerCode;
+    @Basic
+    @Column(name = "cap_total")
+    private Long capTotal;
+    @Basic
+    @Column(name = "cap_used")
+    private Long capUsed;
+    @Basic
+    @Column(name = "cap_used_travel")
+    private Long capUsedTravel;
+    @Basic
+    @Column(name = "cap_left")
+    private Long capLeft;
+    @Basic
+    @Column(name = "max_duration")
+    private Long maxDuration;
+
+    @Type(type = "json")
+    @Column(name = "duration_time", columnDefinition = "json")
+    private List<OccupyInfoDetail> durationTime;
+
+    @Basic
+    @Column(name = "max_duration_type")
+    private String maxDurationType;
+    @Basic
+    @Column(name = "memo")
+    private String memo;
+    @Basic
+    @Column(name = "create_time")
+    private LocalDateTime createTime;
+    @Basic
+    @Column(name = "update_time")
+    private LocalDateTime updateTime;
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public void setTimmeSlice(TimeSliceEntity timmeSlice) {
+        this.timmeSlice = timmeSlice;
+    }
+
+    public void setWorkday(String workday) {
+        this.workday = workday;
+    }
+
+    public void setEngineerCode(String engineerCode) {
+        this.engineerCode = engineerCode;
+    }
+
+    public void setCapTotal(Long capTotal) {
+        this.capTotal = capTotal;
+    }
+
+    public void setCapUsed(Long capUsed) {
+        this.capUsed = capUsed;
+    }
+
+    public void setCapUsedTravel(Long capUsedTravel) {
+        this.capUsedTravel = capUsedTravel;
+    }
+
+    public void setCapLeft(Long capLeft) {
+        this.capLeft = capLeft;
+    }
+
+
+    public void setMaxDuration(Long maxDuration) {
+        this.maxDuration = maxDuration;
+    }
+
+    public void setDurationTime(List<OccupyInfoDetail> durationTime) {
+        this.durationTime = durationTime;
+    }
+
+    public void setMaxDurationType(String maxDurationType) {
+        this.maxDurationType = maxDurationType;
+    }
+
+    public void setMemo(String memo) {
+        this.memo = memo;
+    }
+
+    public void setCreateTime(LocalDateTime createTime) {
+        this.createTime = createTime;
+    }
+
+    public void setUpdateTime(LocalDateTime updateTime) {
+        this.updateTime = updateTime;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        CapacityEngineerSliceUsedEntity that = (CapacityEngineerSliceUsedEntity) o;
+        return Objects.equals(id, that.id) && Objects.equals(timmeSlice, that.timmeSlice) && Objects.equals(workday, that.workday) && Objects.equals(engineerCode, that.engineerCode) && Objects.equals(capTotal, that.capTotal) && Objects.equals(capUsed, that.capUsed) && Objects.equals(capUsedTravel, that.capUsedTravel) && Objects.equals(capLeft, that.capLeft) && Objects.equals(maxDuration, that.maxDuration) && Objects.equals(durationTime, that.durationTime) && Objects.equals(maxDurationType, that.maxDurationType) && Objects.equals(memo, that.memo) && Objects.equals(createTime, that.createTime) && Objects.equals(updateTime, that.updateTime);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, timmeSlice, workday, engineerCode, capTotal, capUsed, capUsedTravel, capLeft, maxDuration, durationTime, maxDurationType, memo, createTime, updateTime);
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/CapacityEngineerStatEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+
+@Data
+@Entity
+@Table(name="capacity_engineer_stat")
+public class CapacityEngineerStatEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    /**
+     * 日期
+     */
+    private String workday;
+
+    /**
+     * 技术员id
+     */
+    private String engineerCode;
+
+    /**
+     * 总容量（分钟）
+     */
+    private Integer capTotal;
+
+    /**
+     * 已占容量
+     */
+    private Integer capUsed;
+
+    /**
+     * 已占容量-路途
+     */
+    private Integer capUsedTravel;
+
+    /**
+     * 剩余可约容量
+     */
+    private Integer capLeft;
+
+    /**
+     * 已约单量
+     */
+    private Integer orderCount;
+
+    /**
+     * 最大连续时长
+     */
+    private Integer maxDuration;
+
+    /**
+     * 备注
+     */
+    private String memo;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createTime = LocalDateTime.now();
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updateTime = LocalDateTime.now();
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/EngineerBusinessEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Data;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.time.LocalDateTime;
+
+/**
+ * @author zhangx
+ */
+
+@Data
+@Entity
+@Table(name = "engineer_business")
+public class EngineerBusinessEntity implements Serializable {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "engineer_code", nullable = false, length = 50)
+    private String engineerCode;
+
+    @Column(name = "work_on", nullable = false, length = 5, columnDefinition = "varchar(5) default '08:00'")
+    private String workOn;
+
+    @Column(name = "work_off", nullable = false, length = 5, columnDefinition = "varchar(5) default '18:00'")
+    private String workOff;
+
+    @Column(name = "max_num", nullable = false)
+    private int maxNum;
+
+    @Column(name = "max_minute", nullable = false)
+    private int maxMinute;
+
+    @Column(name = "max_distance", nullable = false)
+    private int maxDistance;
+
+    @Column(name = "address", nullable = false, length = 50)
+    private String address;
+
+    @Column(name = "x", nullable = false, length = 20)
+    private String X;
+
+    @Column(name = "y", nullable = false, length = 20)
+    private String Y;
+
+    @Column(name = "vehicle", nullable = false, length = 10, columnDefinition = "varchar(10) default '1'")
+    private String vehicle = "1";
+
+    @Column(name = "vehicle_no", nullable = false, length = 10, columnDefinition = "varchar(10) default ''")
+    private String vehicleNo;
+
+    @Column(name = "priority", nullable = false, columnDefinition = "tinyint(4) default '1'")
+    private int priority;
+
+    /**
+     * 常规出发地，1配件仓，2家庭住址，3工作地址 默认工作地址
+     */
+    @Column(name = "departure", nullable = false, columnDefinition = "tinyint(4) default '3'")
+    private int departure = 3;
+
+    @Column(name = "dispatch_strategy", nullable = false, length = 32, columnDefinition = "varchar(32) default 'CENTER'")
+    private String dispatchStrategy;
+
+    @Column(name = "memo", nullable = false, length = 100, columnDefinition = "varchar(100) default ''")
+    private String memo;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @Column(name = "create_time", nullable = false, updatable = false, columnDefinition = "timestamp default current_timestamp")
+    private LocalDateTime createTime = LocalDateTime.now();
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @Column(name = "update_time", nullable = false, columnDefinition = "timestamp default current_timestamp on update current_timestamp")
+    private LocalDateTime updateTime = LocalDateTime.now();
+
+
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/MapBlockInfoEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+
+@Data
+@Entity
+@Table(name = "map_block_info")
+public class MapBlockInfoEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(name = "saas_area_ids", length = 1024)
+    private String areaIds;
+
+    @Column(name = "area_name", length = 50, nullable = false)
+    private String areaName;
+
+    @Column(name = "branch_id", length = 50, nullable = false)
+    private String branchId;
+
+    @Column(name = "group_id", length = 50, nullable = false)
+    private String groupId;
+    
+    @Column(name = "team_id", length = 50, nullable = false)
+    private String teamId;
+
+    @Column(name = "city_code", nullable = true)
+    private String cityCode;
+    
+    @Column(name = "area_count")
+    private Long areaCount;
+
+    @Column(name = "area_data", nullable = true, columnDefinition = "json")
+    private String areaData;
+
+    @Column(nullable = true)
+    private Integer type;
+
+    @Column(name = "layer_id", length = 50, nullable = false)
+    private String layerId;
+
+    @Column(name = "layer_name", length = 50, nullable = false)
+    private String layerName;
+    
+    @Column(name = "saas_layercode", length = 50)
+    private String saasLayercode;
+    
+    @Column(name = "saas_layer_id", length = 50)
+    private String saasLayerId;
+    
+    @Column(name = "saas_url", length = 512)
+    private String saasUrl;
+
+    @Column(nullable = false)
+    private Boolean status;
+
+    @Column(length = 100, nullable = false)
+    private String memo;
+
+    @Column(name = "create_time", nullable = false, columnDefinition = "datetime DEFAULT CURRENT_TIMESTAMP")
+    private LocalDateTime createTime;
+
+    @Column(name = "update_time", nullable = true, columnDefinition = "datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
+    private LocalDateTime updateTime;
+
+    // Getters and Setters
+    // ...
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/PubParamsEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Data
+@Table(name="pub_params")
+public class PubParamsEntity {
+    /**
+     * id
+     */
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    /**
+     * 限定系统
+     */
+    private String catalog;
+
+    /**
+     * 参数组/业务代码
+     */
+    private String biztype;
+
+    /**
+     * 参数名
+     */
+    private String pkey;
+
+    /**
+     * 标题
+     */
+    private String plabel;
+
+    /**
+     * 参数值
+     */
+    private String pvalue;
+
+    /**
+     * 参数解释说明
+     */
+    private String description;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createTime = LocalDateTime.now();
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updateTime = LocalDateTime.now();
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/SkillInfoEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+import lombok.Data;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+
+@Data
+@Entity
+@Table(name = "skill_info")
+public class SkillInfoEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Integer id;
+
+    @Column(name = "skill_code", length = 32, nullable = false)
+    private String skillCode;
+
+    @Column(length = 20, nullable = false)
+    private String brand;
+
+    @Column(length = 20, nullable = false)
+    private String type;
+
+    @Column(length = 20, nullable = false)
+    private String skill;
+
+    @Column(name = "take_time", nullable = false)
+    private Integer takeTime;
+
+    @Column(name = "take_engineer", nullable = false)
+    private Integer takeEngineer;
+
+    @Column(name = "low_electrician_cert", nullable = false)
+    private Boolean lowElectricianCert;
+
+    @Column(name = "gas_cert", nullable = false)
+    private Boolean gasCert;
+
+    @Column(nullable = false)
+    private Integer priority;
+
+    @Column(name = "skill_group_code", length = 50)
+    private String skillGroupCode;
+
+    @Column(name = "layer_id", length = 32)
+    private String layerId;
+
+    @Column(name = "type_category", length = 50)
+    private String typeCategory;
+
+    @Column(name = "skill_category", length = 50)
+    private String skillCategory;
+
+    @Column(length = 100, nullable = false)
+    private String memo;
+
+    @Column(name = "create_time", nullable = false, columnDefinition = "datetime DEFAULT CURRENT_TIMESTAMP")
+    private LocalDateTime createTime = LocalDateTime.now();
+
+    @Column(name = "update_time", nullable = false, columnDefinition = "datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
+    private LocalDateTime updateTime = LocalDateTime.now();
+
+    // Getters and Setters
+    // ...
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/entity/TimeSliceEntity.java

+package com.dituhui.pea.dispatch.entity;
+
+import lombok.Getter;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+import java.util.Objects;
+
+@Getter
+@Entity
+@Table(name = "time_slice")
+public class TimeSliceEntity {
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Id
+    @Column(name = "id")
+    private Long id;
+    @Basic
+    @Column(name = "type")
+    private String type;
+    @Basic
+    @Column(name = "name")
+    private String name;
+    @Basic
+    @Column(name = "start")
+    private String start;
+    @Basic
+    @Column(name = "end")
+    private String end;
+    @Basic
+    @Column(name = "create_time")
+    private LocalDateTime createTime;
+    @Basic
+    @Column(name = "update_time")
+    private LocalDateTime updateTime;
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setStart(String start) {
+        this.start = start;
+    }
+
+    public void setEnd(String end) {
+        this.end = end;
+    }
+
+    public void setCreateTime(LocalDateTime createTime) {
+        this.createTime = createTime;
+    }
+
+    public void setUpdateTime(LocalDateTime updateTime) {
+        this.updateTime = updateTime;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        TimeSliceEntity that = (TimeSliceEntity) o;
+        return id == that.id && Objects.equals(type, that.type) && Objects.equals(name, that.name) && Objects.equals(start, that.start) && Objects.equals(end, that.end) && Objects.equals(createTime, that.createTime) && Objects.equals(updateTime, that.updateTime);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, type, name, start, end, createTime, updateTime);
+    }
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/MyQuartzJobFactory.java → project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/config/MyQuartzJobFactory.java

-package com.dituhui.pea.dispatch.quartz;
+package com.dituhui.pea.dispatch.quartz.config;
 
 import org.quartz.Job;
 import org.quartz.spi.TriggerFiredBundle;

project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/QuartzConfig.java → project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/config/QuartzConfig.java

-package com.dituhui.pea.dispatch.quartz;
+package com.dituhui.pea.dispatch.quartz.config;
 
 import org.quartz.spi.JobFactory;
 import org.springframework.boot.autoconfigure.quartz.QuartzProperties;

project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/AutoDispatchJob.java → project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/dispatch/AutoDispatchJob.java

-package com.dituhui.pea.dispatch.quartz;
+package com.dituhui.pea.dispatch.quartz.dispatch;
 
 import com.dituhui.pea.dispatch.service.SchedulerService;
 import lombok.extern.slf4j.Slf4j;
@@ -13,12 +13,14 @@ import javax.annotation.Resource;
 
 /**
  * 自动派工任务
+ * DisallowConcurrentExecution：禁止并发执行多个相同定义的JobDetai
  *
  * @author RenPing
  * @date 2023/11/02
  */
 @Component
 @Slf4j
+@DisallowConcurrentExecution
 public class AutoDispatchJob extends QuartzJobBean {
 
     public static final String TEAM_JOB_PREFIX="BOXI_TEAM_";

project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/QuartzTaskListener.java → project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/dispatch/QuartzTaskListener.java

-package com.dituhui.pea.dispatch.quartz;
+package com.dituhui.pea.dispatch.quartz.dispatch;
 
 import cn.hutool.core.collection.CollectionUtil;
 import com.dituhui.pea.dispatch.dao.OrgTeamDao;
 import com.dituhui.pea.dispatch.entity.OrgTeamEntity;
+import com.dituhui.pea.dispatch.quartz.dispatch.AutoDispatchJob;
 import lombok.extern.slf4j.Slf4j;
 import org.quartz.*;
 import org.springframework.beans.factory.annotation.Value;

project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/engineerCapacity/InitEngineerCapacityJob.java

+package com.dituhui.pea.dispatch.quartz.engineerCapacity;
+
+import com.dituhui.pea.dispatch.common.DateUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.quartz.DisallowConcurrentExecution;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.quartz.JobKey;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+/**
+ * 工程师容量初始化
+ *
+ * @author RenPing
+ * @date 2023/11/02
+ */
+@Component
+@Slf4j
+@DisallowConcurrentExecution
+public class InitEngineerCapacityJob extends QuartzJobBean {
+
+    public static final String INIT_ENGINEER_JOB_PREFIX = "BOXI_INIT_ENGINEER_CAPACITY_";
+
+    @Value("${scheduler.init-engineer-capacity.day-offset-begin}")
+    private int dayOffsetBegin;
+
+    @Value("${scheduler.init-engineer-capacity.day-offset-end}")
+    private int dayOffsetEnd;
+    @Autowired
+    private InitEngineerCapacityScheduler initEngineerCapacityScheduler;
+
+    @Override
+    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+        try {
+            JobKey jobKey = jobExecutionContext.getJobDetail().getKey();
+            String name = jobKey.getName();
+            String branchId = name.substring(INIT_ENGINEER_JOB_PREFIX.length());
+            long start = System.currentTimeMillis();
+            log.info(">>> 开始初始化：分部（branchId：{}）所有工程师的容量将根据日历表的记录进行计算设置", branchId);
+            String bdate = DateUtils.formatDate(LocalDate.now().plusDays(dayOffsetBegin));
+            String edate = DateUtils.formatDate(LocalDate.now().plusDays(dayOffsetEnd));
+            initEngineerCapacityScheduler.initOneEngineerByDays(bdate, edate, branchId);
+            long end = System.currentTimeMillis();
+            log.info(">>> 初始化结束：分部（branchId：{}）所有工程师的容量，耗时：{}", branchId, end - start);
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        }
+    }
+}
\ No newline at end of file

project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/engineerCapacity/InitEngineerCapacityListener.java

+package com.dituhui.pea.dispatch.quartz.engineerCapacity;
+
+import cn.hutool.core.collection.CollectionUtil;
+import com.dituhui.pea.dispatch.dao.OrgBranchDao;
+import com.dituhui.pea.dispatch.entity.OrgBranchEntity;
+import lombok.extern.slf4j.Slf4j;
+import org.quartz.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.context.event.ApplicationStartedEvent;
+import org.springframework.context.ApplicationListener;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * 手动触发定时任务
+ *
+ * @author RenPing
+ * @date 2023/11/01
+ */
+@Component
+@Slf4j
+public class InitEngineerCapacityListener implements ApplicationListener<ApplicationStartedEvent> {
+
+    @Resource
+    private Scheduler scheduler;
+    @Autowired
+    private OrgBranchDao orgBranchDao;
+
+    @Value("${scheduler.init-engineer-capacity.cron-expr}")
+    private String cronExpr;
+
+    @Override
+    public void onApplicationEvent(ApplicationStartedEvent applicationStartedEvent) {
+        List<String> branchIds = orgBranchDao.findAll().stream().map(OrgBranchEntity::getBranchId).collect(Collectors.toList());
+
+        branchIds.forEach(branchId -> {
+            String jobName = InitEngineerCapacityJob.INIT_ENGINEER_JOB_PREFIX + branchId;
+            JobDetail jobDetail = JobBuilder.newJob(InitEngineerCapacityJob.class)
+                    .withIdentity(jobName, jobName)
+                    .storeDurably()
+                    .build();
+            Trigger trigger = TriggerBuilder.newTrigger()
+                    .forJob(jobDetail)
+                    .withIdentity(jobName, jobName)
+                    .startNow()
+                    .withSchedule(CronScheduleBuilder.cronSchedule(cronExpr))
+                    .build();
+
+            try {
+                scheduler.scheduleJob(jobDetail, CollectionUtil.newHashSet(trigger), true);
+            } catch (SchedulerException e) {
+                //log.error(e.getMessage(), e);
+            }
+        });
+
+    }
+}
\ No newline at end of file

project-order/src/main/java/com/dituhui/pea/order/scheduler/InitEngineerCapacityScheduler.java → project-dispatch/src/main/java/com/dituhui/pea/dispatch/quartz/engineerCapacity/InitEngineerCapacityScheduler.java

-package com.dituhui.pea.order.scheduler;
+package com.dituhui.pea.dispatch.quartz.engineerCapacity;
 
 import cn.hutool.core.collection.CollectionUtil;
-import com.dituhui.pea.order.common.DateUtils;
-import com.dituhui.pea.order.common.OccupyInfoDetail;
-import com.dituhui.pea.order.common.jackson.DateTimeUtil;
-import com.dituhui.pea.order.common.jackson.DateUtil;
-import com.dituhui.pea.order.dao.CapacityEngineerCalendarDao;
-import com.dituhui.pea.order.dao.CapacityEngineerStatDao;
-import com.dituhui.pea.order.dao.EngineerBusinessDao;
-import com.dituhui.pea.order.dao.EngineerInfoDao;
-import com.dituhui.pea.order.dao.TimeSliceDao;
-import com.dituhui.pea.order.entity.CapacityEngineerCalendarEntity;
-import com.dituhui.pea.order.entity.CapacityEngineerSliceUsedEntity;
-import com.dituhui.pea.order.entity.CapacityEngineerStatEntity;
-import com.dituhui.pea.order.entity.EngineerBusinessEntity;
-import com.dituhui.pea.order.entity.EngineerInfoEntity;
-import com.dituhui.pea.order.entity.TimeSliceEntity;
-import com.dituhui.pea.order.service.EngineerCalendarService;
-import com.dituhui.pea.order.service.EngineerSliceUsedCapacityService;
+import com.dituhui.pea.dispatch.common.DateUtil;
+import com.dituhui.pea.dispatch.common.DateUtils;
+import com.dituhui.pea.dispatch.common.OccupyInfoDetail;
+import com.dituhui.pea.dispatch.common.jackson.DateTimeUtil;
+import com.dituhui.pea.dispatch.dao.*;
+import com.dituhui.pea.dispatch.entity.*;
+import com.dituhui.pea.dispatch.service.EngineerCalendarService;
+import com.dituhui.pea.dispatch.service.EngineerSliceUsedCapacityService;
 import lombok.Data;
 import lombok.experimental.Accessors;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
 
 import java.time.Duration;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
@@ -59,7 +44,7 @@ public class InitEngineerCapacityScheduler {
     @Autowired
     private CapacityEngineerStatDao capacityEngineerStatDao;
     @Autowired
-    private EngineerInfoDao engineerInfoDao;
+    private EngineerInfoRepository engineerInfoDao;
     @Autowired
     private TimeSliceDao timeSliceDao;
     @Autowired
@@ -227,14 +212,15 @@ public class InitEngineerCapacityScheduler {
         log.info("====== 处理完毕 ======");
     }
 
-    public void initOneEngineerByDays(String bdate, String edate, String engineerCode) {
-        log.info("==== initAllEngineerByDays, bdate[{}] edate[{}]", bdate, edate);
+    public void initOneEngineerByDays(String bdate, String edate, String branchId) {
         LocalDate currentDate = DateUtils.localDateFromStr(bdate);
         LocalDate endDate = DateUtils.localDateFromStr(edate);
-        List<String> allEngineerCodes = engineerInfoDao.findAll().stream().map(EngineerInfoEntity::getEngineerCode).collect(Collectors.toList());
-        while (!currentDate.isAfter(endDate)) {
-            initOneEngineer(DateUtils.formatDate(currentDate), engineerCode);
-            currentDate = currentDate.plusDays(1);
+        List<String> allEngineerCodes = engineerInfoDao.getAllByBranchId(branchId).stream().map(EngineerInfo::getEngineerCode).collect(Collectors.toList());
+        for(String engineerCode: allEngineerCodes){
+            while (!currentDate.isAfter(endDate)) {
+                initOneEngineer(DateUtils.formatDate(currentDate), engineerCode);
+                currentDate = currentDate.plusDays(1);
+            }
         }
     }
 
@@ -242,7 +228,7 @@ public class InitEngineerCapacityScheduler {
         log.info("==== initAllEngineerByDays, bdate[{}] edate[{}]", bdate, edate);
         LocalDate currentDate = DateUtils.localDateFromStr(bdate);
         LocalDate endDate = DateUtils.localDateFromStr(edate);
-        List<String> allEngineerCodes = engineerInfoDao.findAll().stream().map(EngineerInfoEntity::getEngineerCode).collect(Collectors.toList());
+        List<String> allEngineerCodes = engineerInfoDao.findAll().stream().map(EngineerInfo::getEngineerCode).collect(Collectors.toList());
         while (!currentDate.isAfter(endDate)) {
             for (String engineerCode : allEngineerCodes) {
                 initOneEngineer(DateUtils.formatDate(currentDate), engineerCode);
@@ -251,7 +237,7 @@ public class InitEngineerCapacityScheduler {
         }
     }
 
-    @Scheduled(cron = "${scheduler.init-engineer-capacity.cron-expr}")
+    //@Scheduled(cron = "${scheduler.init-engineer-capacity.cron-expr}")
     public void run() {
         log.info("开始初始化，所有工程师的容量将根据日历表的记录进行计算设置");
         String bdate = DateUtils.formatDate(LocalDate.now().plusDays(dayOffsetBegin));

project-dispatch/src/main/java/com/dituhui/pea/dispatch/service/EngineerCalendarService.java

+package com.dituhui.pea.dispatch.service;
+
+import com.dituhui.pea.common.Result;
+import com.dituhui.pea.dispatch.common.OccupyInfoDetail;
+import com.dituhui.pea.dispatch.dto.*;
+import com.dituhui.pea.dispatch.dto.param.EngineerCalendarResultDTO;
+
+import java.time.LocalDate;
+import java.util.List;
+
+public interface EngineerCalendarService {
+
+    Result<?> getEngineersCalendar(EngineerCalendarDTO.Request engineerCalendarReq);
+
+    Result<?> getCalendarTypeList();
+
+    Result<?> getPlanDetail(CalendarDetailDTO.Request reqDTO);
+
+    Result<?> updatePlan(String userId, CalendarUpdateDTO.Request reqDTO);
+
+    Result<?> deletePlan(String userId, CalendarDeleteDTO.Request reqDTO);
+
+    Result<?> batchAddPlan(String userId, CalendarBatAddDTO.Request reqDTO);
+
+    Result<?> queryEngineerPlanNum(CalendarQueryNumDTO.Request reqDTO);
+
+    Result<?> batchDeletePlan(String userId, CalendarBatDelDTO.Request reqDTO);
+
+    /**
+     * 查询工程师日期范围内的日历事件安排, 返回的内容包括：（多条）开始时间，结束时间，事件代码，事件名称，事件说明
+     *
+     * @param engineerCode 工程师编码
+     * @param startDate    开始日期
+     * @param endDate      结束日期
+     * @return 日期范围内的日历， 包含开始时间，结束时间，事件代码，事件名称，事件说明
+     */
+    EngineerCalendarResultDTO queryEngineerCalendar(String engineerCode, LocalDate startDate, LocalDate endDate);
+
+    /**
+     * 获取工程师在指定日期的“非工作”时间安排 包含工作队休息时间和日程表事件记录时间， 其中日程表内事件未与工作队时间判定交集， 实际计算非工作时间时需求并集
+     *
+     * @param engineerCode 工程师编号
+     * @param targetDate   目标日期
+     * @return 没有交集的事件日程时间段即已占用的时间段
+     */
+    List<OccupyInfoDetail> getEngineerWorkDayCalendar(String engineerCode, LocalDate targetDate);
+
+    /**
+     * 判定工程师指定日期是否在工作队的工作日期
+     *
+     * @param teamId       工作队
+     * @param engineerCode 工程师编号
+     * @param targetDate   目标日期
+     * @return 工作队内日期工作时间信息
+     */
+    boolean engineerTeamDateWorkTime(String teamId, String engineerCode, LocalDate targetDate);
+
+    /**
+     * 获取工程师的工作时间窗
+     *
+     * @param engineerCode 工程师编号
+     * @param teamId 工程师所属工作队 （解决一个工程师属多个多工作对情况）
+     * @param targetDate   目标日期
+     * @return 时间窗格式
+     * @apiNote 时间窗格式：[[起始时间段1， 结束时间段1]，[起始时间段2， 结束时间段2]] <br/> 时间格式： 从0点开始的分钟数， 如8：00AM 为480
+     */
+    int[][] timeWindows(String engineerCode, String teamId, LocalDate targetDate);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/service/EngineerSliceUsedCapacityService.java

+package com.dituhui.pea.dispatch.service;
+
+import com.dituhui.pea.dispatch.entity.CapacityEngineerSliceUsedEntity;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface EngineerSliceUsedCapacityService {
+
+    List<CapacityEngineerSliceUsedEntity> findByWorkdayAndEngineerCode(String workDay, String engineerCode);
+    List<CapacityEngineerSliceUsedEntity> deleteByWorkdayAndEngineerCode(String workDay, String engineerCode);
+
+    List<CapacityEngineerSliceUsedEntity> saveAll(Collection<CapacityEngineerSliceUsedEntity> collection);
+}

project-dispatch/src/main/java/com/dituhui/pea/dispatch/service/impl/EngineerSliceUsedCapacityServiceImpl.java

+package com.dituhui.pea.dispatch.service.impl;
+
+import com.dituhui.pea.dispatch.dao.EngineerSliceUsedCapacityDao;
+import com.dituhui.pea.dispatch.entity.CapacityEngineerSliceUsedEntity;
+import com.dituhui.pea.dispatch.service.EngineerSliceUsedCapacityService;
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import javax.transaction.Transactional;
+import java.util.Collection;
+import java.util.List;
+
+@Service
+@AllArgsConstructor
+public class EngineerSliceUsedCapacityServiceImpl implements EngineerSliceUsedCapacityService {
+    private final EngineerSliceUsedCapacityDao engineerSliceUsedCapacityDao;
+
+
+    @Override
+    @Transactional
+    public List<CapacityEngineerSliceUsedEntity> findByWorkdayAndEngineerCode(String workDay, String engineerCode) {
+        return engineerSliceUsedCapacityDao.findByWorkdayAndEngineerCode(workDay, engineerCode);
+    }
+
+    @Override
+    @Transactional
+    public List<CapacityEngineerSliceUsedEntity> deleteByWorkdayAndEngineerCode(String workDay, String engineerCode) {
+        return engineerSliceUsedCapacityDao.deleteByWorkdayAndEngineerCode(workDay, engineerCode);
+    }
+
+    @Override
+    @Transactional
+    public List<CapacityEngineerSliceUsedEntity> saveAll(Collection<CapacityEngineerSliceUsedEntity> collection) {
+        return engineerSliceUsedCapacityDao.saveAll(collection);
+    }
+}

project-dispatch/src/main/resources/application-dev.yaml

@@ -3,10 +3,31 @@ server:
 
 dispatch:
   cron:
-    expr: 0 19 8-20 * * ?
+    expr: 0 10 8-22 * * ?
     next-day-limit: 2
 #    expr: 0 */10 8-18 * * ?
 
+scheduler:
+  init-engineer-capacity:
+    # 每天22点1次
+    #cron-expr: 0 0 22 * * ?
+    cron-expr: 0 29 * * * ?
+    day-offset-begin: 0
+    day-offset-end: 14
+    rewrite-force: true
+
+  calc-engineer-capacity:
+    # 8-20点，每30分钟1次
+    cron-expr: 0 */30 1-23 * * ?
+    day-offset-begin: 0
+    day-offset-end: 14
+
+  calc-org-capacity:
+    # 8-20点，每小时1次
+    cron-expr: 0 0 1-23 * * ?
+    day-offset-begin: 0
+    day-offset-end: 14
+
 spring:
   application:
     name: project-dispatch

project-dispatch/src/main/resources/application.yaml

@@ -6,6 +6,26 @@ dispatch:
     expr: 0 */30 8-18 * * ?
     next-day-limit: 2
 
+scheduler:
+  init-engineer-capacity:
+    # 每天22点1次
+    cron-expr: 0 0 22 * * ?
+    day-offset-begin: 1
+    day-offset-end: 20
+    rewrite-force: true
+
+  calc-engineer-capacity:
+    # 8-20点，每30分钟1次
+    cron-expr: 0 */30 1-23 * * ?
+    day-offset-begin: 0
+    day-offset-end: 20
+
+  calc-org-capacity:
+    # 8-20点，每小时1次
+    cron-expr: 0 0 1-23 * * ?
+    day-offset-begin: 0
+    day-offset-end: 20
+
 spring:
   application:
     name: project-dispatch

project-order/src/main/java/com/dituhui/pea/order/common/CapacityUtils.java

@@ -93,21 +93,22 @@ public class CapacityUtils {
                                             List<OccupyInfoDetail> configs) {
 
         //工作日历使用时间片
-        List<OccupyInfo> calendar = Optional.ofNullable(configs).orElse(Collections.emptyList())
+        List<OccupyInfoDetail> calendar = Optional.ofNullable(configs).orElse(Collections.emptyList())
                 .stream()
                 .filter(t -> DateUtil.checkTimesHasOverlap(t.getBeginTime(), t.getEndTime(), startTime, endTime))
-                .map(e -> DateUtil.timesOverlap(e.getBeginTime(), e.getEndTime(), startTime, endTime))
+                .map(e -> DateUtil.intersection(e.getBeginTime(), e.getEndTime(), startTime, endTime))
                 .collect(Collectors.toList());
         // 工单已使用的时间片
-        List<OccupyInfo> order = Optional.ofNullable(orders).orElse(Collections.emptyList())
+        List<OccupyInfoDetail> order = Optional.ofNullable(orders).orElse(Collections.emptyList())
                 .stream()
                 .filter(t -> DateUtil.checkTimesHasOverlap(t.getPlanStartTime(), t.getPlanEndTime(), startTime, endTime))
-                .map(e -> DateUtil.timesOverlap(e.getPlanStartTime(), e.getPlanEndTime(), startTime, endTime))
+                .map(e -> DateUtil.intersection(e.getPlanStartTime(), e.getPlanEndTime(), startTime, endTime))
                 .collect(Collectors.toList());
+        List<OccupyInfoDetail> resultList = Stream.of(calendar, order).flatMap(Collection::stream).collect(Collectors.toList());
 
+        resultList = calculateUnion(resultList);
         //存放所有的已用时间段信息
-        return Stream.of(calendar, order).flatMap(Collection::stream)
-                .sorted(Comparator.comparing(OccupyInfo::getBeginTime)).collect(Collectors.toList());
+        return resultList.stream().sorted(Comparator.comparing(OccupyInfo::getBeginTime)).collect(Collectors.toList());
 
     }
 
@@ -124,8 +125,8 @@ public class CapacityUtils {
         LocalDateTime preLast = startTime;
         for (OccupyInfo o : occupyInfos) {
             if (o.getBeginTime().isAfter(preLast)) {
-                long duraionMiu = Duration.between(startTime, o.getBeginTime()).abs().toMinutes();
-                leisureTime.add(new OccupyInfoDetail(startTime, o.getBeginTime(), duraionMiu));
+                long duraionMiu = Duration.between(preLast, o.getBeginTime()).abs().toMinutes();
+                leisureTime.add(new OccupyInfoDetail(preLast, o.getBeginTime(), duraionMiu));
             }
             preLast = o.getEndTime();
         }

project-order/src/main/java/com/dituhui/pea/order/common/jackson/DateUtil.java

@@ -2,6 +2,7 @@ package com.dituhui.pea.order.common.jackson;
 
 import com.dituhui.pea.order.common.DateSplit;
 import com.dituhui.pea.order.common.OccupyInfo;
+import com.dituhui.pea.order.common.OccupyInfoDetail;
 import lombok.experimental.UtilityClass;
 import org.springframework.util.Assert;
 
@@ -490,14 +491,14 @@ public class DateUtil {
 
 
     // 计算两个时间片的交集
-    public OccupyInfo intersection(LocalDateTime dynaStartTime, LocalDateTime dynaEndTime,
+    public OccupyInfoDetail intersection(LocalDateTime dynaStartTime, LocalDateTime dynaEndTime,
                                    LocalDateTime fixedStartTime, LocalDateTime fixedEndTime) {
         // 如果两个时间片没有交集，返回null
         if (!checkTimesHasOverlap(dynaStartTime, dynaEndTime, fixedStartTime, fixedEndTime)) {
             return null;
         }
         // 否则，返回一个新的时间片，其开始时间是两个时间片中较晚的开始时间，其结束时间是两个时间片中较早的结束时间
-        return new OccupyInfo(dynaStartTime.isAfter(fixedStartTime) ? dynaStartTime : fixedStartTime,
+        return new OccupyInfoDetail(dynaStartTime.isAfter(fixedStartTime) ? dynaStartTime : fixedStartTime,
                 dynaEndTime.isBefore(fixedEndTime) ? dynaEndTime : fixedEndTime);
     }
 

project-order/src/main/java/com/dituhui/pea/order/scheduler/CalcEngineerCapacityScheduler.java

@@ -6,14 +6,11 @@ import com.dituhui.pea.order.common.OccupyInfo;
 import com.dituhui.pea.order.common.OccupyInfoDetail;
 import com.dituhui.pea.order.common.jackson.DateTimeUtil;
 import com.dituhui.pea.order.common.jackson.DateUtil;
-import com.dituhui.pea.order.dao.CapacityEngineerCalendarDao;
 import com.dituhui.pea.order.dao.CapacityEngineerStatDao;
 import com.dituhui.pea.order.dao.EngineerBusinessDao;
 import com.dituhui.pea.order.dao.EngineerInfoDao;
 import com.dituhui.pea.order.dao.EngineerSliceUsedCapacityDao;
 import com.dituhui.pea.order.dao.OrderInfoDao;
-import com.dituhui.pea.order.dao.TimeSliceDao;
-import com.dituhui.pea.order.entity.CapacityEngineerCalendarEntity;
 import com.dituhui.pea.order.entity.CapacityEngineerSliceUsedEntity;
 import com.dituhui.pea.order.entity.CapacityEngineerStatEntity;
 import com.dituhui.pea.order.entity.EngineerBusinessEntity;
@@ -32,9 +29,7 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.ZoneId;
-import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -54,14 +49,10 @@ public class CalcEngineerCapacityScheduler {
     @Autowired
     private OrderInfoDao orderInfoDao;
     @Autowired
-    private CapacityEngineerCalendarDao capacityEngineerCalendarDao;
-    @Autowired
     private EngineerBusinessDao engineerBusinessDao;
     @Autowired
     private EngineerInfoDao engineerInfoDao;
     @Autowired
-    private TimeSliceDao timeSliceDao;
-    @Autowired
     private EngineerSliceUsedCapacityDao engineerSliceUsedCapacityDao;
     @Autowired
     private EngineerCalendarService engineerCalendarService;
@@ -86,7 +77,7 @@ public class CalcEngineerCapacityScheduler {
         }
     }
 
-    private void calcOneEngineer(String date, String engineerCode) {
+    public void calcOneEngineer(String date, String engineerCode) {
         CapacityEngineerStatEntity statEntity = capacityEngineerStatDao.getByWorkdayAndEngineerCode(date, engineerCode);
         if (statEntity == null) {
             log.error("错误：日期[{}]技术员[{}]容量尚未初始化，忽略退出！", date, engineerCode);
@@ -105,25 +96,29 @@ public class CalcEngineerCapacityScheduler {
                 .stream()
                 .filter(e -> !ss.contains(e.getOrderStatus()))
                 .collect(Collectors.toList());
+
         initOneEngineerTimeSlot(date, engineerCode, configs, orders);
 
+        caculateEngineerOneDay(date, businessEntity, orders, configs, statEntity);
+        capacityEngineerStatDao.save(statEntity);
+    }
 
-        int used = orders.stream().map(e -> {
-            if (ss.contains(e.getOrderStatus())) {
-                return 0;
-            } else {
-                return e.getTakeTime();
-            }
-        }).mapToInt(Integer::intValue).sum();
-        long cnt = orders.size();
-        long max = getMaxRemainBlock(date, engineerCode, orders, businessEntity);
-        log.info("正在处理: 日期[{}]技术员[{}]容量相关信息 ==> used:{}, orderCnt:{}, maxDuration:{}", date, engineerCode, used, cnt, max);
-        statEntity.setOrderCount((int) cnt);
-        statEntity.setCapUsed(used);
-        statEntity.setCapLeft(statEntity.getCapTotal() - used);
-        statEntity.setMaxDuration((int) max);
+    private static void caculateEngineerOneDay(String date, EngineerBusinessEntity businessEntity, List<OrderInfoEntity> orders,
+                                               List<OccupyInfoDetail> configs, CapacityEngineerStatEntity statEntity) {
+        final LocalDateTime startTime = DateUtils.localDateTimeFromStr(String.format("%s %s:00", date, businessEntity.getWorkOn()));
+        final LocalDateTime endTime = DateUtils.localDateTimeFromStr(String.format("%s %s:00", date, businessEntity.getWorkOff()));
+        List<OccupyInfo> occupyInfo = CapacityUtils.caculate(startTime, endTime, orders, configs);
+        //已用容量
+        long totalUseTime = occupyInfo.stream().mapToLong(t -> Duration.between(t.getEndTime(), t.getBeginTime()).abs().toMinutes()).sum();
+        //最大连续时长
+        List<OccupyInfoDetail> durationTime = CapacityUtils.getMaxRemainBlock(startTime, endTime, occupyInfo);
+        long maxRemainBlock = durationTime.stream().mapToLong(OccupyInfoDetail::getDuration).max().orElse(0L);
+
+        statEntity.setOrderCount(orders.size());
+        statEntity.setCapUsed((int) totalUseTime);
+        statEntity.setCapLeft(statEntity.getCapTotal() - (int) totalUseTime);
+        statEntity.setMaxDuration((int) maxRemainBlock);
         statEntity.setUpdateTime(LocalDateTime.now());
-        capacityEngineerStatDao.save(statEntity);
     }
 
     //添加工程师日历参数
@@ -145,7 +140,7 @@ public class CalcEngineerCapacityScheduler {
             long totalUseTime = occupyInfo.stream().mapToLong(t -> Duration.between(t.getEndTime(), t.getBeginTime()).abs().toMinutes()).sum();
             //最大连续时长
             List<OccupyInfoDetail> durationTime = CapacityUtils.getMaxRemainBlock(startTime, endTime, occupyInfo);
-            long maxRemainBlock = durationTime.stream().mapToLong(OccupyInfoDetail::getDuration).max().orElse(Duration.between(startTime, endTime).abs().toMinutes());
+            long maxRemainBlock = durationTime.stream().mapToLong(OccupyInfoDetail::getDuration).max().orElse(0L);
             //剩余连续时间段
             sliceCap.setDurationTime(durationTime);
             sliceCap.setCapLeft(sliceCap.getCapTotal() - totalUseTime);
@@ -158,45 +153,4 @@ public class CalcEngineerCapacityScheduler {
         engineerSliceUsedCapacityDao.saveAll(engineerTimeSlice);
     }
 
-
-    private long getMaxRemainBlock(String date, String engineerCode, List<OrderInfoEntity> orders, EngineerBusinessEntity businessEntity) {
-        // 根据capacity_engineer_calendar和order_info，来确定当天剩下的最大连续时间区块；
-        LocalDateTime startTime = DateUtils.localDateTimeFromStr(String.format("%s %s:00", date, businessEntity.getWorkOn()));
-        LocalDateTime endTime = DateUtils.localDateTimeFromStr(String.format("%s %s:00", date, businessEntity.getWorkOff()));
-
-        List<OccupyInfo> occupyInfos = new ArrayList<>();
-        List<CapacityEngineerCalendarEntity> configs = capacityEngineerCalendarDao.findCalendarByWorkdayAndEngineerCode(date, engineerCode);
-        if (!configs.isEmpty()) {
-            occupyInfos.addAll(
-                    configs.stream().map(e -> new OccupyInfo().setBeginTime(e.getStartTime()).setEndTime(e.getEndTime())).collect(Collectors.toList())
-            );
-        }
-        if (!orders.isEmpty()) {
-            occupyInfos.addAll(
-                    orders.stream().map(e -> new OccupyInfo().setBeginTime(e.getPlanStartTime()).setEndTime(e.getPlanEndTime())).collect(Collectors.toList())
-            );
-        }
-        if (occupyInfos.isEmpty()) {
-            return Duration.between(startTime, endTime).toMinutes();
-        }
-        occupyInfos.sort(Comparator.comparing(OccupyInfo::getBeginTime));
-        // 从 occupyInfos的配置间隙中，获取最大的闲时段，理论上，上面的配置段之间，是不会交叉的，如果交叉，那是存在问题的！
-        List<Long> idlePeriods = new ArrayList<>();
-        LocalDateTime preLast = startTime;
-        for (OccupyInfo o : occupyInfos) {
-            if (o.getBeginTime().isAfter(preLast)) {
-                idlePeriods.add(Duration.between(startTime, o.getBeginTime()).toMinutes());
-            }
-            preLast = o.getEndTime();
-        }
-        if (preLast.isBefore(endTime)) {
-            idlePeriods.add(Duration.between(preLast, endTime).toMinutes());
-        }
-        if (idlePeriods.isEmpty()) {
-            return Duration.between(startTime, endTime).toMinutes();
-        } else {
-            return Collections.max(idlePeriods);
-        }
-    }
-
 }

project-order/src/main/resources/application-dev.yaml

@@ -75,7 +75,7 @@ scheduler:
   init-engineer-capacity:
     # 每天22点1次
     #cron-expr: 0 0 22 * * ?
-    cron-expr: 0 32 * * * ?
+    cron-expr: 0 40 * * * ?
     day-offset-begin: 0
     day-offset-end: 14
     rewrite-force: true

project-order/src/test/java/com/dituhui/pea/order/scheduler/CalcEngineerCapacitySchedulerTest.java

+package com.dituhui.pea.order.scheduler;
+
+import com.dituhui.pea.order.OrderServiceApplication;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest(classes = OrderServiceApplication.class)
+class CalcEngineerCapacitySchedulerTest {
+    @Autowired
+    private CalcEngineerCapacityScheduler calcEngineerCapacityScheduler;
+
+    @Test
+    void calcOneEngineer() {
+//        calcEngineerCapacityScheduler.calcOneEngineer("2023-11-09", "6200044665");
+    }
+}
\ No newline at end of file

project-order/src/test/resources/application.yaml

+server:
+  port: 8013
+
+spring:
+  application:
+    name: project-order
+  jackson:
+    default-property-inclusion: NON_NULL
+    time-zone: GMT+8
+    date-format: yyyy-MM-dd HH:mm:ss
+  cloud:
+    nacos:
+      discovery:
+        server-addr: 192.168.10.92:8848
+        group: project
+        username: nacos
+        password: nacos
+      config:
+        server-addr: 192.168.10.92:8848
+        group: project
+        file-extension: yaml
+        import-check:
+          # no config file
+          enabled: false
+        username: nacos
+        password: nacos
+  config:
+    import:
+      - nacos:redis-config.yaml?group=project&refreshEnabled=true
+      - nacos:bean-kafka-config.yaml?group=project&refreshEnabled=true
+  #config:
+  #  import:
+  #   - optional:nacos:project-order.yaml
+  #   - optional:nacos:datasource-config.yaml
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://127.0.0.1:32306/saas_aftersale_test?serverTimezone=Asia/Shanghai
+    username: boxi
+    password: boxi_dev_0725
+    type: com.alibaba.druid.pool.DruidDataSource
+
+seata:
+  application-id: ${spring.application.name}
+  tx-service-group: ${spring.application.name}-group
+  service:
+    vgroup-mapping:
+      project-order-group: default
+    grouplist:
+      default: 127.0.0.1:8091
+
+mybatis-plus:
+  global-config:
+    db-config:
+      id-type: auto
+  configuration:
+    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
+
+sentry:
+  dsn: http://85293a9310fc4a8187422a7a257fc1ba@sentry.zjhuixinyun.com/8
+
+  # Set traces_sample_rate to 1.0 to capture 100%
+  # of transactions for performance monitoring.
+  # We recommend adjusting this value in production.
+  tracesSampleRate: 1.0
+  exception-resolver-order: -2147483647
+
+SaaS:
+  url: https://pea-test.bshg.com.cn
+  ak: 64e1cde3f9144bfb850b7d37c51af559
+  userAccount: sMvf3yZWA69lKcvlgKcOHQ==
+  userPassword: qjOHxpQPXLnJP+Jq1CZGBQ==
+  encryptionPassWord: 64e1cde3f9144bfb
+bean:
+  server: https://bean-test.bshg.com.cn
+  app-key: eDZEhTCxAcM9paRfwPjAM7RGkfmbf15S_PEA
+  secret-key: 9kB3ESrYhh8A08nta7CjnYn2Jw1wAEXH_PEA
+
+scheduler:
+  init-engineer-capacity:
+    # 每天22点1次
+    cron-expr: 0 0 22 * * ?
+    day-offset-begin: 1
+    day-offset-end: 20
+    rewrite-force: true
+
+  calc-engineer-capacity:
+    # 8-20点，每30分钟1次
+    cron-expr: 0 */30 1-23 * * ?
+    day-offset-begin: 0
+    day-offset-end: 20
+
+  calc-org-capacity:
+    # 8-20点，每小时1次
+    cron-expr: 0 0 1-23 * * ?
+    day-offset-begin: 0
+    day-offset-end: 20
+logging:
+  level:
+    root: info
+    org.hibernate.type.descriptor.sql.BasicBinder: trace
\ No newline at end of file