增加与ai大模型对话

huimv-employment/fe-api/src/main/java/com/huimv/employment/controller/mp/ContractController.java

@@ -62,7 +62,8 @@ public class ContractController {
 
     @PostMapping("/{id}/confirm-sign")
     @Operation(summary = "确认签署完成",
-            description = "临时工确认签署（Mock 闭环）。sign_status→signed，登记 contract_signing→completed。已签署幂等返回。",
+            description = "临时工确认签署（Mock 闭环）。sign_status→signed，登记 contract_signing→completed。"
+                    + "订单不自动开工，须企业调用 POST /orders/{orderId}/start-work。已签署幂等返回。",
             parameters = {
                     @Parameter(name = "id", in = ParameterIn.PATH, required = true, description = "fe_contract.id")
             })

huimv-employment/fe-api/src/main/java/com/huimv/employment/controller/mp/EmploymentOrderController.java

@@ -0,0 +1,76 @@
+package com.huimv.employment.controller.mp;
+
+import com.huimv.employment.common.exception.BizException;
+import com.huimv.employment.common.exception.ErrorCode;
+import com.huimv.employment.common.web.R;
+import com.huimv.employment.security.LoginUser;
+import com.huimv.employment.security.LoginUserHolder;
+import com.huimv.employment.service.order.EmploymentOrderService;
+import com.huimv.employment.service.order.dto.OrderStartWorkRequest;
+import com.huimv.employment.service.order.dto.OrderStartWorkResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 企业端用工订单：开工确认等。
+ */
+@RestController
+@RequestMapping("/api/v1/mp/orders")
+@Tag(name = "用工订单", description = "企业确认开工等")
+@SecurityRequirement(name = "Authorization")
+public class EmploymentOrderController {
+
+    private static final String USER_TYPE_ENTERPRISE = "enterprise";
+
+    private final EmploymentOrderService employmentOrderService;
+
+    public EmploymentOrderController(EmploymentOrderService employmentOrderService) {
+        this.employmentOrderService = employmentOrderService;
+    }
+
+    @GetMapping("/{orderId}/start-work-status")
+    @Operation(summary = "查询开工就绪状态",
+            description = "返回已签/计划人数、是否齐签、是否缺编、是否可确认开工。待审人数仅提示，不阻挡。",
+            parameters = {
+                    @Parameter(name = "orderId", in = ParameterIn.PATH, required = true,
+                            description = "fe_employment_order.id")
+            })
+    public R<OrderStartWorkResponse> startWorkStatus(@PathVariable("orderId") Long orderId) {
+        requireEnterprise();
+        return R.ok(employmentOrderService.getStartWorkStatus(LoginUserHolder.require().getUserId(), orderId));
+    }
+
+    @PostMapping("/{orderId}/start-work")
+    @Operation(summary = "确认开工",
+            description = "企业确认开工。须已过审工人全部签完；已签人数 &lt; 计划人数时须 allow_understaffed=true。"
+                    + "成功后订单 contract_signing→work_started。",
+            parameters = {
+                    @Parameter(name = "orderId", in = ParameterIn.PATH, required = true,
+                            description = "fe_employment_order.id")
+            })
+    public R<OrderStartWorkResponse> startWork(@PathVariable("orderId") Long orderId,
+                                               @RequestBody(required = false) OrderStartWorkRequest request) {
+        requireEnterprise();
+        if (request == null) {
+            request = new OrderStartWorkRequest();
+        }
+        return R.ok(employmentOrderService.startWork(LoginUserHolder.require().getUserId(), orderId, request));
+    }
+
+    private static LoginUser requireEnterprise() {
+        LoginUser loginUser = LoginUserHolder.require();
+        if (!USER_TYPE_ENTERPRISE.equals(loginUser.getUserType())) {
+            throw new BizException(ErrorCode.ENTERPRISE_ONLY);
+        }
+        return loginUser;
+    }
+}

huimv-employment/fe-api/src/main/resources/application.yml

@@ -5,7 +5,7 @@ spring:
     active: dev
 
 server:
-  port: 8080
+  port: 8081
 
 logging:
   file:

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/contract/ContractService.java

@@ -237,7 +237,8 @@ public class ContractService {
 
     /**
      * 临时工确认签署完成（Mock 电子签闭环；真实电子签可改为回调驱动）。
-     * <p>将合同置为 {@code signed}，登记 {@code contract_signing → completed}。</p>
+     * <p>将合同置为 {@code signed}，登记 {@code contract_signing → completed}。
+     * 订单不自动开工，须企业调用确认开工接口。</p>
      */
     @Transactional(rollbackFor = Exception.class)
     public ContractItemResponse confirmSign(Long userId, Long contractId) {
@@ -263,8 +264,8 @@ public class ContractService {
         feContractMapper.updateById(update);
 
         markRegistrationCompleted(contract.getRegistrationId(), now);
-        log.info("合同签署完成 contractId={} workerId={} registrationId={}",
-                contract.getId(), worker.getId(), contract.getRegistrationId());
+        log.info("合同签署完成 contractId={} workerId={} registrationId={} orderId={}",
+                contract.getId(), worker.getId(), contract.getRegistrationId(), contract.getOrderId());
         return getMyContract(userId, contractId);
     }
 

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/order/EmploymentOrderService.java

@@ -3,39 +3,61 @@ package com.huimv.employment.service.order;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.huimv.employment.common.exception.BizException;
 import com.huimv.employment.common.exception.ErrorCode;
+import com.huimv.employment.dao.entity.FeContract;
 import com.huimv.employment.dao.entity.FeEmploymentDraft;
 import com.huimv.employment.dao.entity.FeEmploymentOrder;
 import com.huimv.employment.dao.entity.FeEnterprise;
+import com.huimv.employment.dao.entity.FeWorkerRegistration;
 import com.huimv.employment.dao.mapper.FeEmploymentDraftMapper;
 import com.huimv.employment.dao.mapper.FeEmploymentOrderMapper;
+import com.huimv.employment.dao.mapper.FeWorkerRegistrationMapper;
+import com.huimv.employment.service.contract.ContractService;
 import com.huimv.employment.service.conversation.ConversationService;
 import com.huimv.employment.service.enterprise.EnterpriseService;
 import com.huimv.employment.service.order.dto.EmploymentOrderItemResponse;
+import com.huimv.employment.service.order.dto.OrderStartWorkRequest;
+import com.huimv.employment.service.order.dto.OrderStartWorkResponse;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
 
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 /**
- * 企业端用工订单查询。
+ * 企业端用工订单查询与开工确认。
  */
 @Service
 public class EmploymentOrderService {
 
+    private static final String STEP_CONTRACT_SIGNING = "contract_signing";
+    private static final String STEP_WORK_STARTED = "work_started";
+    private static final String REG_CONTRACT_SIGNING = "contract_signing";
+    private static final String REG_COMPLETED = "completed";
+    private static final String REG_UNDER_REVIEW = "under_review";
+    private static final String SIGN_SIGNED = "signed";
+
     private final FeEmploymentOrderMapper feEmploymentOrderMapper;
     private final FeEmploymentDraftMapper feEmploymentDraftMapper;
+    private final FeWorkerRegistrationMapper feWorkerRegistrationMapper;
     private final ConversationService conversationService;
     private final EnterpriseService enterpriseService;
+    private final ContractService contractService;
 
     public EmploymentOrderService(FeEmploymentOrderMapper feEmploymentOrderMapper,
                                   FeEmploymentDraftMapper feEmploymentDraftMapper,
+                                  FeWorkerRegistrationMapper feWorkerRegistrationMapper,
                                   ConversationService conversationService,
-                                  EnterpriseService enterpriseService) {
+                                  EnterpriseService enterpriseService,
+                                  ContractService contractService) {
         this.feEmploymentOrderMapper = feEmploymentOrderMapper;
         this.feEmploymentDraftMapper = feEmploymentDraftMapper;
+        this.feWorkerRegistrationMapper = feWorkerRegistrationMapper;
         this.conversationService = conversationService;
         this.enterpriseService = enterpriseService;
+        this.contractService = contractService;
     }
 
     /**
@@ -85,6 +107,174 @@ public class EmploymentOrderService {
         return result;
     }
 
+    /**
+     * 查询开工就绪状态（人数提示、是否齐签、是否可开工）。
+     */
+    public OrderStartWorkResponse getStartWorkStatus(Long userId, Long orderId) {
+        FeEmploymentOrder order = requireOwnedOrder(userId, orderId);
+        return buildStartWorkStatus(order, false);
+    }
+
+    /**
+     * 企业确认开工：要求已过审工人全部签完；缺编须 {@code allow_understaffed=true}。
+     * <p>订单 {@code contract_signing → work_started}。</p>
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public OrderStartWorkResponse startWork(Long userId, Long orderId, OrderStartWorkRequest request) {
+        FeEmploymentOrder order = requireOwnedOrder(userId, orderId);
+        OrderStartWorkResponse status = buildStartWorkStatus(order, true);
+        if (STEP_WORK_STARTED.equals(order.getCurrentStepCode())
+                || isStepAfter(order.getCurrentStepCode(), STEP_WORK_STARTED)) {
+            status.setMessage("订单已进入开工阶段");
+            return status;
+        }
+        if (!STEP_CONTRACT_SIGNING.equals(order.getCurrentStepCode())) {
+            throw new BizException(ErrorCode.BAD_REQUEST,
+                    "当前步骤不可开工：" + (order.getCurrentStepCode() == null ? "未知" : order.getCurrentStepCode()));
+        }
+        if (status.getApprovedCount() == null || status.getApprovedCount() <= 0) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "尚无已过审工人，无法开工");
+        }
+        if (!Boolean.TRUE.equals(status.getAllApprovedSigned())) {
+            throw new BizException(ErrorCode.BAD_REQUEST,
+                    "尚有已过审工人未完成签署（已签 " + status.getSignedCount()
+                            + "/" + status.getApprovedCount() + "）");
+        }
+        boolean allowUnderstaffed = request != null && request.isAllowUnderstaffed();
+        if (Boolean.TRUE.equals(status.getUnderstaffed()) && !allowUnderstaffed) {
+            throw new BizException(ErrorCode.BAD_REQUEST,
+                    "已签署 " + status.getSignedCount() + " 人，计划 "
+                            + status.getPlannedCount() + " 人，未招满。"
+                            + "确认缺编开工请传 allow_understaffed=true");
+        }
+
+        LocalDateTime now = LocalDateTime.now();
+        FeEmploymentOrder update = new FeEmploymentOrder();
+        update.setId(order.getId());
+        update.setCurrentStepCode(STEP_WORK_STARTED);
+        update.setUpdateTime(now);
+        feEmploymentOrderMapper.updateById(update);
+        order.setCurrentStepCode(STEP_WORK_STARTED);
+
+        OrderStartWorkResponse result = buildStartWorkStatus(order, true);
+        result.setMessage(Boolean.TRUE.equals(status.getUnderstaffed())
+                ? "已确认缺编开工"
+                : "已确认开工");
+        return result;
+    }
+
+    private FeEmploymentOrder requireOwnedOrder(Long userId, Long orderId) {
+        enterpriseService.requireEnterpriseUser(userId);
+        FeEnterprise enterprise = enterpriseService.findEnterpriseByUserId(userId);
+        if (enterprise == null) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "请先完成企业登记");
+        }
+        if (orderId == null) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "订单 ID 无效");
+        }
+        FeEmploymentOrder order = feEmploymentOrderMapper.selectById(orderId);
+        if (order == null) {
+            throw new BizException(ErrorCode.NOT_FOUND, "用工订单不存在");
+        }
+        if (order.getEnterpriseId() == null || !order.getEnterpriseId().equals(enterprise.getId())) {
+            throw new BizException(ErrorCode.FORBIDDEN, "无权操作该订单");
+        }
+        return order;
+    }
+
+    private OrderStartWorkResponse buildStartWorkStatus(FeEmploymentOrder order, boolean forStartAction) {
+        Long orderId = order.getId();
+        int planned = order.getWorkerCount() != null && order.getWorkerCount() > 0
+                ? order.getWorkerCount() : 0;
+
+        List<FeWorkerRegistration> regs = feWorkerRegistrationMapper.selectList(
+                new LambdaQueryWrapper<FeWorkerRegistration>()
+                        .eq(FeWorkerRegistration::getOrderId, orderId));
+        if (regs == null) {
+            regs = Collections.emptyList();
+        }
+
+        int approved = 0;
+        int signed = 0;
+        int pendingSign = 0;
+        int underReview = 0;
+        for (FeWorkerRegistration reg : regs) {
+            String st = reg.getRegStatus();
+            if (REG_UNDER_REVIEW.equals(st)) {
+                underReview++;
+                continue;
+            }
+            if (!REG_CONTRACT_SIGNING.equals(st) && !REG_COMPLETED.equals(st)) {
+                continue;
+            }
+            approved++;
+            FeContract contract = contractService.findActiveByRegistrationId(reg.getId());
+            if (contract != null && SIGN_SIGNED.equals(contract.getSignStatus())) {
+                signed++;
+            } else {
+                pendingSign++;
+            }
+        }
+
+        boolean allApprovedSigned = approved > 0 && pendingSign == 0;
+        boolean understaffed = planned > 0 && signed < planned;
+        boolean atSigning = STEP_CONTRACT_SIGNING.equals(order.getCurrentStepCode());
+        boolean canStart = atSigning && allApprovedSigned;
+
+        OrderStartWorkResponse response = new OrderStartWorkResponse();
+        response.setOrderId(orderId);
+        response.setOrderNo(order.getOrderNo());
+        response.setCurrentStepCode(order.getCurrentStepCode());
+        response.setPlannedCount(planned);
+        response.setApprovedCount(approved);
+        response.setSignedCount(signed);
+        response.setPendingSignCount(pendingSign);
+        response.setUnderReviewCount(underReview);
+        response.setAllApprovedSigned(allApprovedSigned);
+        response.setUnderstaffed(understaffed);
+        response.setCanStartWork(canStart);
+
+        if (STEP_WORK_STARTED.equals(order.getCurrentStepCode())
+                || isStepAfter(order.getCurrentStepCode(), STEP_WORK_STARTED)) {
+            response.setMessage("订单已进入开工阶段");
+        } else if (!atSigning) {
+            response.setMessage("订单尚未进入签约阶段");
+        } else if (approved == 0) {
+            response.setMessage("尚无已过审工人");
+        } else if (!allApprovedSigned) {
+            response.setMessage("已签 " + signed + "/" + approved + "，待签 " + pendingSign + " 人");
+        } else if (understaffed) {
+            response.setMessage("已齐签，但未招满（已签 " + signed + "/" + planned
+                    + "）。缺编开工须传 allow_understaffed=true"
+                    + (underReview > 0 ? "；另有 " + underReview + " 人待审" : ""));
+        } else {
+            response.setMessage(forStartAction ? "可确认开工" : "已齐签且人数达标，可确认开工"
+                    + (underReview > 0 ? "（另有 " + underReview + " 人待审，不阻挡开工）" : ""));
+        }
+        return response;
+    }
+
+    private static boolean isStepAfter(String current, String target) {
+        if (!StringUtils.hasText(current) || !StringUtils.hasText(target)) {
+            return false;
+        }
+        String[] steps = {
+                "draft_created", "plan_confirmed", "registration", "enterprise_audit",
+                "contract_signing", "work_started", "settlement_pending", "settlement_paid", "completed"
+        };
+        int curIdx = -1;
+        int targetIdx = -1;
+        for (int i = 0; i < steps.length; i++) {
+            if (steps[i].equals(current)) {
+                curIdx = i;
+            }
+            if (steps[i].equals(target)) {
+                targetIdx = i;
+            }
+        }
+        return curIdx >= 0 && targetIdx >= 0 && curIdx > targetIdx;
+    }
+
     private static EmploymentOrderItemResponse toItem(FeEmploymentOrder order) {
         EmploymentOrderItemResponse item = new EmploymentOrderItemResponse();
         item.setDraftId(order.getDraftId());

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/order/dto/OrderStartWorkRequest.java

@@ -0,0 +1,26 @@
+package com.huimv.employment.service.order.dto;
+
+import com.fasterxml.jackson.annotation.JsonAlias;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "企业确认开工请求")
+public class OrderStartWorkRequest {
+
+    @JsonProperty("allow_understaffed")
+    @JsonAlias({"allowUnderstaffed"})
+    @Schema(description = "已签人数少于计划人数时，是否仍确认缺编开工；默认 false")
+    private Boolean allowUnderstaffed;
+
+    public Boolean getAllowUnderstaffed() {
+        return allowUnderstaffed;
+    }
+
+    public void setAllowUnderstaffed(Boolean allowUnderstaffed) {
+        this.allowUnderstaffed = allowUnderstaffed;
+    }
+
+    public boolean isAllowUnderstaffed() {
+        return Boolean.TRUE.equals(allowUnderstaffed);
+    }
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/order/dto/OrderStartWorkResponse.java

@@ -0,0 +1,146 @@
+package com.huimv.employment.service.order.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "订单签约/开工就绪状态")
+public class OrderStartWorkResponse {
+
+    @JsonProperty("order_id")
+    private Long orderId;
+
+    @JsonProperty("order_no")
+    private String orderNo;
+
+    @JsonProperty("current_step_code")
+    private String currentStepCode;
+
+    @Schema(description = "计划人数")
+    @JsonProperty("planned_count")
+    private Integer plannedCount;
+
+    @Schema(description = "已过审人数（待签+已签）")
+    @JsonProperty("approved_count")
+    private Integer approvedCount;
+
+    @Schema(description = "已签署完成人数")
+    @JsonProperty("signed_count")
+    private Integer signedCount;
+
+    @Schema(description = "已过审但仍待签人数")
+    @JsonProperty("pending_sign_count")
+    private Integer pendingSignCount;
+
+    @Schema(description = "待企业审核人数（提示用，不挡开工）")
+    @JsonProperty("under_review_count")
+    private Integer underReviewCount;
+
+    @Schema(description = "已过审工人是否全部签完")
+    @JsonProperty("all_approved_signed")
+    private Boolean allApprovedSigned;
+
+    @Schema(description = "已签人数是否少于计划人数")
+    private Boolean understaffed;
+
+    @Schema(description = "是否可确认开工（齐签且步骤为 contract_signing）")
+    @JsonProperty("can_start_work")
+    private Boolean canStartWork;
+
+    private String message;
+
+    public Long getOrderId() {
+        return orderId;
+    }
+
+    public void setOrderId(Long orderId) {
+        this.orderId = orderId;
+    }
+
+    public String getOrderNo() {
+        return orderNo;
+    }
+
+    public void setOrderNo(String orderNo) {
+        this.orderNo = orderNo;
+    }
+
+    public String getCurrentStepCode() {
+        return currentStepCode;
+    }
+
+    public void setCurrentStepCode(String currentStepCode) {
+        this.currentStepCode = currentStepCode;
+    }
+
+    public Integer getPlannedCount() {
+        return plannedCount;
+    }
+
+    public void setPlannedCount(Integer plannedCount) {
+        this.plannedCount = plannedCount;
+    }
+
+    public Integer getApprovedCount() {
+        return approvedCount;
+    }
+
+    public void setApprovedCount(Integer approvedCount) {
+        this.approvedCount = approvedCount;
+    }
+
+    public Integer getSignedCount() {
+        return signedCount;
+    }
+
+    public void setSignedCount(Integer signedCount) {
+        this.signedCount = signedCount;
+    }
+
+    public Integer getPendingSignCount() {
+        return pendingSignCount;
+    }
+
+    public void setPendingSignCount(Integer pendingSignCount) {
+        this.pendingSignCount = pendingSignCount;
+    }
+
+    public Integer getUnderReviewCount() {
+        return underReviewCount;
+    }
+
+    public void setUnderReviewCount(Integer underReviewCount) {
+        this.underReviewCount = underReviewCount;
+    }
+
+    public Boolean getAllApprovedSigned() {
+        return allApprovedSigned;
+    }
+
+    public void setAllApprovedSigned(Boolean allApprovedSigned) {
+        this.allApprovedSigned = allApprovedSigned;
+    }
+
+    public Boolean getUnderstaffed() {
+        return understaffed;
+    }
+
+    public void setUnderstaffed(Boolean understaffed) {
+        this.understaffed = understaffed;
+    }
+
+    public Boolean getCanStartWork() {
+        return canStartWork;
+    }
+
+    public void setCanStartWork(Boolean canStartWork) {
+        this.canStartWork = canStartWork;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+}