增加与ai大模型对话

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

@@ -6,14 +6,18 @@ import com.huimv.employment.common.web.R;
 import com.huimv.employment.security.LoginUser;
 import com.huimv.employment.security.LoginUserHolder;
 import com.huimv.employment.service.draft.DraftService;
+import com.huimv.employment.service.draft.dto.DraftConfirmRequest;
+import com.huimv.employment.service.draft.dto.DraftConfirmResponse;
 import com.huimv.employment.service.draft.dto.DraftDetailResponse;
 import com.huimv.employment.service.draft.dto.DraftUpdateRequest;
+import com.huimv.employment.service.draft.dto.McpDraftCalculateResponse;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.validation.annotation.Validated;
 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.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -22,13 +26,13 @@ import org.springframework.web.bind.annotation.RestController;
 /**
  * 用工草稿接口（小程序 JWT 鉴权）。
  * <p>
- * AI 生成草稿后，企业主通过 {@code GET /drafts/{id}} 查看、{@code PUT /drafts/{id}} 编辑补充字段。
- * 草稿创建由 AI 内网接口负责，本模块仅提供读写。
+ * AI 生成草稿后，企业主通过 {@code GET /drafts/{id}} 查看、{@code PUT /drafts/{id}} 编辑；
+ * missingFields 为空后可 {@code GET .../cost-comparison} 测算，再 {@code POST .../confirm} 确认此方案。
  * </p>
  */
 @RestController
 @RequestMapping("/api/v1/mp/drafts")
-@Tag(name = "用工草稿", description = "草稿查看与编辑，需 JWT 鉴权")
+@Tag(name = "用工草稿", description = "草稿查看、编辑、成本测算与方案确认，需 JWT 鉴权")
 @SecurityRequirement(name = "Authorization")
 public class DraftController {
 
@@ -57,6 +61,25 @@ public class DraftController {
         return R.ok(draftService.update(loginUser.getUserId(), draftId, request));
     }
 
+    @GetMapping("/{id}/cost-comparison")
+    @Operation(summary = "成本测算（方案对比）",
+            description = "要求草稿 pending 且 missingFields 为空。返回 SCHEME_A / SCHEME_B 等多套合规方案，供「确认此方案」前展示。")
+    public R<McpDraftCalculateResponse> costComparison(@PathVariable("id") Long draftId) {
+        LoginUser loginUser = requireEnterprise();
+        return R.ok(draftService.calculateCostComparison(loginUser.getUserId(), draftId));
+    }
+
+    @PostMapping("/{id}/confirm")
+    @Operation(summary = "确认此方案",
+            description = "草稿 pending 且 missingFields 为空后调用。传入 selected_scheme_code（如 SCHEME_A）："
+                    + "1）生成正式订单；2）将草稿 status 更新为 confirmed（含 confirmed_at/confirmed_by）；"
+                    + "若尚未测算会自动先测算。")
+    public R<DraftConfirmResponse> confirm(@PathVariable("id") Long draftId,
+                                           @Validated @RequestBody DraftConfirmRequest request) {
+        LoginUser loginUser = requireEnterprise();
+        return R.ok(draftService.confirmScheme(loginUser.getUserId(), draftId, request));
+    }
+
     private static LoginUser requireEnterprise() {
         LoginUser loginUser = LoginUserHolder.require();
         if (!USER_TYPE_ENTERPRISE.equals(loginUser.getUserType())) {

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/draft/DraftService.java

@@ -1,18 +1,26 @@
 package com.huimv.employment.service.draft;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.huimv.employment.common.exception.BizException;
 import com.huimv.employment.common.exception.ErrorCode;
+import com.huimv.employment.dao.entity.FeDraftCostSnapshot;
 import com.huimv.employment.dao.entity.FeDraftField;
 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.mapper.FeDraftCostSnapshotMapper;
 import com.huimv.employment.dao.mapper.FeDraftFieldMapper;
 import com.huimv.employment.dao.mapper.FeEmploymentDraftMapper;
+import com.huimv.employment.dao.mapper.FeEmploymentOrderMapper;
+import com.huimv.employment.service.draft.dto.DraftConfirmRequest;
+import com.huimv.employment.service.draft.dto.DraftConfirmResponse;
 import com.huimv.employment.service.draft.dto.DraftDetailResponse;
 import com.huimv.employment.service.draft.dto.DraftFieldResponse;
 import com.huimv.employment.service.draft.dto.DraftUpdateRequest;
+import com.huimv.employment.service.draft.dto.McpDraftCalculateResponse;
 import com.huimv.employment.service.enterprise.EnterpriseService;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
@@ -28,6 +36,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.UUID;
 import java.util.stream.Collectors;
 
 /**
@@ -37,6 +46,10 @@ import java.util.stream.Collectors;
 public class DraftService {
 
     private static final String STATUS_PENDING = "pending";
+    private static final String STATUS_CONFIRMED = "confirmed";
+    private static final String ORDER_STATUS_CONFIRMED = "confirmed";
+    private static final String STEP_PLAN_CONFIRMED = "plan_confirmed";
+    private static final String CONFIRM_SUCCESS = "success";
     private static final String SOURCE_USER_INPUT = "user_input";
     private static final String WORK_LOCATION_SOURCE_USER = "user_input";
 
@@ -44,6 +57,8 @@ public class DraftService {
             new HashSet<>(Arrays.asList("daily", "piece", "monthly")));
     private static final Set<String> ALLOWED_INSURANCE_LEVELS = Collections.unmodifiableSet(
             new HashSet<>(Arrays.asList("basic", "standard", "premium")));
+    private static final Set<String> ALLOWED_SCHEME_CODES = Collections.unmodifiableSet(
+            new HashSet<>(Arrays.asList(DraftCostCalculationEngine.SCHEME_A, DraftCostCalculationEngine.SCHEME_B)));
 
     private static final Map<String, String> FIELD_LABELS;
 
@@ -62,16 +77,25 @@ public class DraftService {
 
     private final FeEmploymentDraftMapper feEmploymentDraftMapper;
     private final FeDraftFieldMapper feDraftFieldMapper;
+    private final FeDraftCostSnapshotMapper feDraftCostSnapshotMapper;
+    private final FeEmploymentOrderMapper feEmploymentOrderMapper;
     private final EnterpriseService enterpriseService;
+    private final DraftCostCalculationEngine draftCostCalculationEngine;
     private final ObjectMapper objectMapper;
 
     public DraftService(FeEmploymentDraftMapper feEmploymentDraftMapper,
                         FeDraftFieldMapper feDraftFieldMapper,
+                        FeDraftCostSnapshotMapper feDraftCostSnapshotMapper,
+                        FeEmploymentOrderMapper feEmploymentOrderMapper,
                         EnterpriseService enterpriseService,
+                        DraftCostCalculationEngine draftCostCalculationEngine,
                         ObjectMapper objectMapper) {
         this.feEmploymentDraftMapper = feEmploymentDraftMapper;
         this.feDraftFieldMapper = feDraftFieldMapper;
+        this.feDraftCostSnapshotMapper = feDraftCostSnapshotMapper;
+        this.feEmploymentOrderMapper = feEmploymentOrderMapper;
         this.enterpriseService = enterpriseService;
+        this.draftCostCalculationEngine = draftCostCalculationEngine;
         this.objectMapper = objectMapper;
     }
 
@@ -98,6 +122,175 @@ public class DraftService {
         return toDetail(feEmploymentDraftMapper.selectById(draftId), listFields(draftId));
     }
 
+    /**
+     * 草稿就绪（pending 且 missingFields 为空）后测算成本方案，供微信端展示「确认此方案」。
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public McpDraftCalculateResponse calculateCostComparison(Long userId, Long draftId) {
+        FeEmploymentDraft draft = requireOwnedReady(userId, draftId);
+        List<DraftCostCalculationEngine.CalculatedScheme> schemes = draftCostCalculationEngine.calculate(draft);
+        persistCostSnapshots(draft, schemes);
+        updateDraftEstimates(draft, schemes, LocalDateTime.now());
+        return draftCostCalculationEngine.toApiResponse(schemes);
+    }
+
+    /**
+     * 微信端确认此方案：选定 SCHEME_A/SCHEME_B，转正式订单。
+     * <p>若尚未测算，将自动先测算再确认。</p>
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public DraftConfirmResponse confirmScheme(Long userId, Long draftId, DraftConfirmRequest request) {
+        if (request == null || !StringUtils.hasText(request.getSelectedSchemeCode())) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "selected_scheme_code 不能为空");
+        }
+        FeEmploymentDraft draft = requireOwnedReady(userId, draftId);
+        String schemeCode = request.getSelectedSchemeCode().trim().toUpperCase();
+        if (!ALLOWED_SCHEME_CODES.contains(schemeCode)) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "不支持的方案编码：" + request.getSelectedSchemeCode());
+        }
+
+        FeDraftCostSnapshot snapshot = findLatestSnapshot(draft.getId(), schemeCode);
+        if (snapshot == null) {
+            List<DraftCostCalculationEngine.CalculatedScheme> schemes = draftCostCalculationEngine.calculate(draft);
+            persistCostSnapshots(draft, schemes);
+            updateDraftEstimates(draft, schemes, LocalDateTime.now());
+            snapshot = findLatestSnapshot(draft.getId(), schemeCode);
+        }
+        if (snapshot == null) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "方案测算失败，请稍后重试");
+        }
+
+        LocalDateTime now = LocalDateTime.now();
+        // 1) 转正式订单
+        FeEmploymentOrder order = buildOrderFromDraft(draft, snapshot, userId, now);
+        order.setOrderNo("tmp_" + UUID.randomUUID().toString().replace("-", "").substring(0, 20));
+        try {
+            feEmploymentOrderMapper.insert(order);
+        } catch (DuplicateKeyException ex) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "订单编号冲突，请重试");
+        }
+        order.setOrderNo(generateOrderNo(order.getId()));
+        feEmploymentOrderMapper.updateById(order);
+
+        // 2) 同步将草稿状态更新为 confirmed（与订单同一事务）
+        int updated = feEmploymentDraftMapper.update(null, new LambdaUpdateWrapper<FeEmploymentDraft>()
+                .eq(FeEmploymentDraft::getId, draft.getId())
+                .eq(FeEmploymentDraft::getStatus, STATUS_PENDING)
+                .set(FeEmploymentDraft::getStatus, STATUS_CONFIRMED)
+                .set(FeEmploymentDraft::getConfirmedAt, now)
+                .set(FeEmploymentDraft::getConfirmedBy, userId)
+                .set(FeEmploymentDraft::getSelectedPlanId, snapshot.getId())
+                .set(FeEmploymentDraft::getEstimatedTotal, snapshot.getEmployerTotalOutflow())
+                .set(FeEmploymentDraft::getEstimatedPerCapita, snapshot.getEmployerAvgCostPerWorker())
+                .set(FeEmploymentDraft::getUpdateTime, now));
+        if (updated != 1) {
+            throw new BizException(ErrorCode.DRAFT_NOT_EDITABLE);
+        }
+
+        DraftConfirmResponse response = new DraftConfirmResponse();
+        response.setStatus(CONFIRM_SUCCESS);
+        response.setDraftStatus(STATUS_CONFIRMED);
+        response.setOrderId(order.getOrderNo());
+        response.setDraftId(draft.getId());
+        response.setSelectedSchemeCode(schemeCode);
+        return response;
+    }
+
+    private FeEmploymentDraft requireOwnedReady(Long userId, Long draftId) {
+        FeEmploymentDraft draft = requireOwned(userId, draftId);
+        assertEditable(draft);
+        List<String> missing = parseStringList(draft.getMissingFields());
+        if (!missing.isEmpty()) {
+            throw new BizException(ErrorCode.BAD_REQUEST,
+                    "草稿信息不完整，请先补全字段：" + String.join(", ", missing));
+        }
+        return draft;
+    }
+
+    private void persistCostSnapshots(FeEmploymentDraft draft,
+                                      List<DraftCostCalculationEngine.CalculatedScheme> schemes) {
+        feDraftCostSnapshotMapper.delete(new LambdaQueryWrapper<FeDraftCostSnapshot>()
+                .eq(FeDraftCostSnapshot::getDraftId, draft.getId()));
+        LocalDateTime now = LocalDateTime.now();
+        for (DraftCostCalculationEngine.CalculatedScheme scheme : schemes) {
+            FeDraftCostSnapshot snapshot = new FeDraftCostSnapshot();
+            snapshot.setDraftId(draft.getId());
+            snapshot.setPlanCode(scheme.getCode());
+            snapshot.setPlanName(scheme.getTitle());
+            snapshot.setEmployerTotalOutflow(scheme.getEmployerTotalOutflow());
+            snapshot.setEmployerAvgCostPerWorker(scheme.getEmployerAvgCostPerWorker());
+            snapshot.setWorkerTakeHomePerWorker(scheme.getWorkerTakeHomePerWorker());
+            snapshot.setIsRecommended(scheme.isRecommended());
+            snapshot.setComplianceTags(writeJsonArray(scheme.getTags()));
+            snapshot.setCalcVersion(draftCostCalculationEngine.calcVersion());
+            snapshot.setCreateTime(now);
+            feDraftCostSnapshotMapper.insert(snapshot);
+        }
+    }
+
+    private void updateDraftEstimates(FeEmploymentDraft draft,
+                                      List<DraftCostCalculationEngine.CalculatedScheme> schemes,
+                                      LocalDateTime now) {
+        DraftCostCalculationEngine.CalculatedScheme recommended = schemes.stream()
+                .filter(DraftCostCalculationEngine.CalculatedScheme::isRecommended)
+                .findFirst()
+                .orElse(schemes.get(0));
+        FeEmploymentDraft update = new FeEmploymentDraft();
+        update.setId(draft.getId());
+        update.setEstimatedTotal(recommended.getEmployerTotalOutflow());
+        update.setEstimatedPerCapita(recommended.getEmployerAvgCostPerWorker());
+        update.setUpdateTime(now);
+        feEmploymentDraftMapper.updateById(update);
+    }
+
+    private FeDraftCostSnapshot findLatestSnapshot(Long draftId, String schemeCode) {
+        return feDraftCostSnapshotMapper.selectOne(new LambdaQueryWrapper<FeDraftCostSnapshot>()
+                .eq(FeDraftCostSnapshot::getDraftId, draftId)
+                .eq(FeDraftCostSnapshot::getPlanCode, schemeCode)
+                .orderByDesc(FeDraftCostSnapshot::getCreateTime)
+                .last("LIMIT 1"));
+    }
+
+    private FeEmploymentOrder buildOrderFromDraft(FeEmploymentDraft draft,
+                                                  FeDraftCostSnapshot snapshot,
+                                                  Long userId,
+                                                  LocalDateTime now) {
+        FeEmploymentOrder order = new FeEmploymentOrder();
+        order.setEnterpriseId(draft.getEnterpriseId());
+        order.setUserId(draft.getUserId() != null ? draft.getUserId() : userId);
+        order.setDraftId(draft.getId());
+        order.setSelectedPlanId(snapshot.getId());
+        order.setTitle(StringUtils.hasText(draft.getTitle()) ? draft.getTitle() : "用工订单");
+        order.setWorkerCount(draft.getWorkerCount());
+        order.setWorkDays(draft.getWorkDays());
+        order.setWorkType(draft.getWorkType());
+        order.setWorkLocation(draft.getWorkLocation());
+        order.setWorkStartDate(draft.getWorkStartDate());
+        order.setWorkEndDate(draft.getWorkEndDate());
+        order.setOrderStatus(ORDER_STATUS_CONFIRMED);
+        order.setCurrentStepCode(STEP_PLAN_CONFIRMED);
+        order.setRegisteredCount(0);
+        order.setPendingCount(draft.getWorkerCount());
+        order.setAbnormalCount(0);
+        order.setTotalOutflow(snapshot.getEmployerTotalOutflow());
+        order.setCreateTime(now);
+        order.setUpdateTime(now);
+        order.setDelFlag(0);
+        return order;
+    }
+
+    private static String generateOrderNo(Long orderId) {
+        return String.format("ord_%d", orderId);
+    }
+
+    private String writeJsonArray(List<String> values) {
+        try {
+            return objectMapper.writeValueAsString(values);
+        } catch (Exception ex) {
+            return "[]";
+        }
+    }
+
     private FeEmploymentDraft requireOwned(Long userId, Long draftId) {
         FeEnterprise enterprise = enterpriseService.findEnterpriseByUserId(userId);
         if (enterprise == null) {