增加与ai大模型对话

doc/灵活用工-mysql.sql

@@ -44,7 +44,7 @@ CREATE TABLE `fe_user` (
 DROP TABLE IF EXISTS `fe_enterprise`;
 CREATE TABLE `fe_enterprise` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '表主键，BIGSERIAL 自增。企业入驻或管理员创建企业时生成。示例：2001。非空；被草稿、订单、会话等多表外键引用。',
-  `enterprise_code` VARCHAR(32)     NOT NULL COMMENT '企业业务编码，系统内唯一标识，便于对外 API 与日志引用。企业创建时由编号生成器写入。示例：ent_001。非空；唯一索引 uk_fe_enterprise_code（del_flag=0）。',
+  `enterprise_code` VARCHAR(32)     NULL COMMENT '企业业务编码，档案创建后写入，平台内唯一。创建中可为空；唯一索引 uk_fe_enterprise_code（del_flag=0）。',
   `name` VARCHAR(200)    NOT NULL COMMENT '企业全称，工商注册名称。企业入驻表单或 OCR 识别营业执照时写入。示例：上海某某物流有限公司。非空；用于合同抬头与结算展示。',
   `credit_code` VARCHAR(32) COMMENT '统一社会信用代码，企业实名认证核心字段。企业提交认证材料时写入，审核通过后不变更。示例：91310000MA1K3XXXXX。可空；认证前可为空；非敏感但需校验格式。',
   `legal_person` VARCHAR(64) COMMENT '法定代表人姓名。认证材料解析或人工填写时写入。示例：王某某。可空；用于合同与开票信息核对。',
@@ -62,7 +62,7 @@ CREATE TABLE `fe_enterprise` (
   `del_flag` tinyint        NOT NULL DEFAULT 0 COMMENT '逻辑删除标记。企业注销或管理员删除时置 1。枚举：0=正常；1=已删除。非空，默认 0；软删后释放 enterprise_code 唯一索引。',
   PRIMARY KEY (`id`),
   UNIQUE KEY `uk_fe_enterprise_code` (`enterprise_code`, `del_flag`),
-  KEY `idx_fe_enterprise_credit` (`credit_code`)
+  UNIQUE KEY `uk_fe_enterprise_credit_code` (`credit_code`, `del_flag`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='企业主体表，灵活用工业务归属主体，承载企业认证信息与扩展画像。与 fe_enterprise_user（多管理员）、fe_employment_draft、fe_employment_order 等为一对多关系。注册地址 registered_address 供 AI 草稿默认推断工作地点。';
 
 DROP TABLE IF EXISTS `fe_enterprise_user`;
@@ -459,7 +459,8 @@ CREATE TABLE `fe_worker` (
   `update_time` datetime     NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '档案信息或核验状态变更时更新。非空。',
   `del_flag` tinyint        NOT NULL DEFAULT 0 COMMENT '逻辑删除标记。枚举：0=正常；1=已删除。非空，默认 0。',
   PRIMARY KEY (`id`),
-  KEY `idx_fe_worker_user` (`user_id`),
+  UNIQUE KEY `uk_fe_worker_worker_no` (`worker_no`, `del_flag`),
+  UNIQUE KEY `uk_fe_worker_user_id` (`user_id`, `del_flag`),
   KEY `idx_fe_worker_mobile` (`mobile_mask`),
   CONSTRAINT `fk_fe_worker_user_id` FOREIGN KEY (`user_id`) REFERENCES `fe_user` (`id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='临时工自然人档案主表，跨登记批次复用，避免重复录入身份证与银行卡。身份证、银行卡、手机号均加密存储（*_enc），列表仅展示脱敏值（*_mask）；可关联 fe_user 实现微信绑定。';

doc/灵活用工.sql

@@ -66,7 +66,7 @@ CREATE INDEX idx_fe_user_type ON fe_user (user_type, status);
 -- 企业主体
 CREATE TABLE fe_enterprise (
     id                  BIGSERIAL       PRIMARY KEY,
-    enterprise_code     VARCHAR(32)     NOT NULL,                   -- 业务编码 ent_001
+    enterprise_code     VARCHAR(32),                                   -- 业务编码，创建后写入
     name                VARCHAR(200)    NOT NULL,
     credit_code         VARCHAR(32),                                 -- 统一社会信用代码
     legal_person        VARCHAR(64),
@@ -82,8 +82,8 @@ CREATE TABLE fe_enterprise (
     update_time         TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
     del_flag            SMALLINT        NOT NULL DEFAULT 0
 );
-CREATE UNIQUE INDEX uk_fe_enterprise_code ON fe_enterprise (enterprise_code) WHERE del_flag = 0;
-CREATE INDEX idx_fe_enterprise_credit ON fe_enterprise (credit_code);
+CREATE UNIQUE INDEX uk_fe_enterprise_code ON fe_enterprise (enterprise_code, del_flag);
+CREATE UNIQUE INDEX uk_fe_enterprise_credit_code ON fe_enterprise (credit_code, del_flag);
 
 
 -- 企业-用户绑定（一个企业可有多个管理员）
@@ -478,7 +478,8 @@ CREATE TABLE fe_worker (
     update_time         TIMESTAMPTZ     NOT NULL DEFAULT NOW(),
     del_flag            SMALLINT        NOT NULL DEFAULT 0
 );
-CREATE INDEX idx_fe_worker_user ON fe_worker (user_id);
+CREATE UNIQUE INDEX uk_fe_worker_worker_no ON fe_worker (worker_no, del_flag);
+CREATE UNIQUE INDEX uk_fe_worker_user_id ON fe_worker (user_id, del_flag);
 CREATE INDEX idx_fe_worker_mobile ON fe_worker (mobile_mask);
 
 

huimv-employment/fe-dao/src/main/java/com/huimv/employment/dao/mapper/FeUserMapper.java

@@ -3,6 +3,8 @@ package com.huimv.employment.dao.mapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.huimv.employment.dao.entity.FeUser;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
 
 /**
  * fe_user 表 Mapper。
@@ -10,4 +12,10 @@ import org.apache.ibatis.annotations.Mapper;
  */
 @Mapper
 public interface FeUserMapper extends BaseMapper<FeUser> {
+
+    /**
+     * 按主键加行锁，用于登记等「同一用户仅允许一次」的并发场景。
+     */
+    @Select("SELECT * FROM fe_user WHERE id = #{userId} AND del_flag = 0 FOR UPDATE")
+    FeUser selectByIdForUpdate(@Param("userId") Long userId);
 }

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/enterprise/EnterpriseService.java

@@ -15,6 +15,9 @@ import com.huimv.employment.dao.mapper.FeUserMapper;
 import com.huimv.employment.service.config.SecurityProperties;
 import com.huimv.employment.service.enterprise.dto.EnterpriseRegisterRequest;
 import com.huimv.employment.service.enterprise.dto.EnterpriseRegisterResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -26,6 +29,8 @@ import java.time.LocalDateTime;
 @Service
 public class EnterpriseService {
 
+    private static final Logger log = LoggerFactory.getLogger(EnterpriseService.class);
+
     private static final String USER_TYPE_ENTERPRISE = "enterprise";
     private static final String AUTH_STATUS_PENDING = "pending";
     private static final String ROLE_OWNER = "owner";
@@ -66,7 +71,7 @@ public class EnterpriseService {
 
     @Transactional(rollbackFor = Exception.class)
     public EnterpriseRegisterResponse register(Long userId, EnterpriseRegisterRequest request) {
-        requireEnterpriseUser(userId);
+        lockEnterpriseUserForUpdate(userId);
         if (findBindingByUserId(userId) != null) {
             throw new BizException(ErrorCode.ENTERPRISE_ALREADY_REGISTERED);
         }
@@ -90,14 +95,21 @@ public class EnterpriseService {
         enterprise.setContactMobileEnc(contactMobileEnc);
         enterprise.setContactMobileMask(contactMobileMask);
         enterprise.setAuthStatus(AUTH_STATUS_PENDING);
-        enterprise.setEnterpriseCode("ENT_TMP_" + System.currentTimeMillis());
         enterprise.setCreateTime(now);
         enterprise.setUpdateTime(now);
         enterprise.setDelFlag(0);
-        feEnterpriseMapper.insert(enterprise);
+        try {
+            feEnterpriseMapper.insert(enterprise);
+        } catch (DuplicateKeyException ex) {
+            throw handleEnterpriseDuplicate(ex, "insert");
+        }
 
         enterprise.setEnterpriseCode(generateEnterpriseCode(enterprise.getId()));
-        feEnterpriseMapper.updateById(enterprise);
+        try {
+            feEnterpriseMapper.updateById(enterprise);
+        } catch (DuplicateKeyException ex) {
+            throw handleEnterpriseDuplicate(ex, "assign enterpriseCode");
+        }
 
         FeEnterpriseUser binding = new FeEnterpriseUser();
         binding.setEnterpriseId(enterprise.getId());
@@ -108,11 +120,45 @@ public class EnterpriseService {
         binding.setCreateTime(now);
         binding.setUpdateTime(now);
         binding.setDelFlag(0);
-        feEnterpriseUserMapper.insert(binding);
+        try {
+            feEnterpriseUserMapper.insert(binding);
+        } catch (DuplicateKeyException ex) {
+            throw handleEnterpriseDuplicate(ex, "bind user");
+        }
 
         return toRegisterResponse(enterprise);
     }
 
+    /**
+     * 事务内锁定 fe_user 行，串行化同一用户的并发登记请求。
+     */
+    private FeUser lockEnterpriseUserForUpdate(Long userId) {
+        FeUser user = feUserMapper.selectByIdForUpdate(userId);
+        if (user == null) {
+            throw new BizException(ErrorCode.UNAUTHORIZED);
+        }
+        if (!USER_TYPE_ENTERPRISE.equals(user.getUserType())) {
+            throw new BizException(ErrorCode.ENTERPRISE_ONLY);
+        }
+        return user;
+    }
+
+    private BizException handleEnterpriseDuplicate(DuplicateKeyException ex, String phase) {
+        String message = ex.getMessage();
+        if (message != null && (message.contains("uk_fe_enterprise_credit_code") || message.contains("credit_code"))) {
+            return new BizException(ErrorCode.BAD_REQUEST, "该统一社会信用代码已被登记");
+        }
+        if (message != null && (message.contains("uk_fe_enterprise_code") || message.contains("enterprise_code"))) {
+            log.error("Duplicate enterprise_code during {}, should not happen", phase, ex);
+            return new BizException(ErrorCode.INTERNAL_ERROR);
+        }
+        if (message != null && message.contains("uk_fe_enterprise_user")) {
+            return new BizException(ErrorCode.ENTERPRISE_ALREADY_REGISTERED);
+        }
+        log.warn("Unexpected duplicate key during enterprise register {}: {}", phase, message);
+        return new BizException(ErrorCode.ENTERPRISE_ALREADY_REGISTERED);
+    }
+
     private FeEnterpriseUser findBindingByUserId(Long userId) {
         return feEnterpriseUserMapper.selectOne(new LambdaQueryWrapper<FeEnterpriseUser>()
                 .eq(FeEnterpriseUser::getUserId, userId)

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/worker/WorkerService.java

@@ -16,6 +16,9 @@ import com.huimv.employment.dao.mapper.FeWorkerMapper;
 import com.huimv.employment.service.config.SecurityProperties;
 import com.huimv.employment.service.worker.dto.WorkerRegisterRequest;
 import com.huimv.employment.service.worker.dto.WorkerRegisterResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.StringUtils;
@@ -28,6 +31,8 @@ import java.time.LocalDateTime;
 @Service
 public class WorkerService {
 
+    private static final Logger log = LoggerFactory.getLogger(WorkerService.class);
+
     private static final String USER_TYPE_WORKER = "worker";
     private static final String VERIFY_STATUS_PENDING = "pending";
     private static final String CONSENT_VERSION = "v1.0";
@@ -69,7 +74,7 @@ public class WorkerService {
                                            WorkerRegisterRequest request,
                                            String clientIp,
                                            String userAgent) {
-        FeUser user = requireWorkerUser(userId);
+        FeUser user = lockWorkerUserForUpdate(userId);
         if (findWorkerByUserId(userId) != null) {
             throw new BizException(ErrorCode.WORKER_ALREADY_REGISTERED);
         }
@@ -99,10 +104,18 @@ public class WorkerService {
         worker.setCreateTime(now);
         worker.setUpdateTime(now);
         worker.setDelFlag(0);
-        feWorkerMapper.insert(worker);
+        try {
+            feWorkerMapper.insert(worker);
+        } catch (DuplicateKeyException ex) {
+            throw handleWorkerDuplicate(ex, "insert");
+        }
 
         worker.setWorkerNo(generateWorkerNo(worker.getId()));
-        feWorkerMapper.updateById(worker);
+        try {
+            feWorkerMapper.updateById(worker);
+        } catch (DuplicateKeyException ex) {
+            throw handleWorkerDuplicate(ex, "assign workerNo");
+        }
 
         saveConsent(worker.getId(), WorkerConsentType.LABOR_CONTRACT, "《电子劳动合同》",
                 request.getAgreedLaborContract(), now, clientIp, userAgent);
@@ -112,6 +125,33 @@ public class WorkerService {
         return toRegisterResponse(worker);
     }
 
+    /**
+     * 事务内锁定 fe_user 行，串行化同一用户的并发登记请求。
+     */
+    private FeUser lockWorkerUserForUpdate(Long userId) {
+        FeUser user = feUserMapper.selectByIdForUpdate(userId);
+        if (user == null) {
+            throw new BizException(ErrorCode.UNAUTHORIZED);
+        }
+        if (!USER_TYPE_WORKER.equals(user.getUserType())) {
+            throw new BizException(ErrorCode.WORKER_ONLY);
+        }
+        return user;
+    }
+
+    private BizException handleWorkerDuplicate(DuplicateKeyException ex, String phase) {
+        String message = ex.getMessage();
+        if (message != null && (message.contains("uk_fe_worker_user_id") || message.contains("user_id"))) {
+            return new BizException(ErrorCode.WORKER_ALREADY_REGISTERED);
+        }
+        if (message != null && (message.contains("uk_fe_worker_worker_no") || message.contains("worker_no"))) {
+            log.error("Duplicate worker_no during {}, should not happen", phase, ex);
+            return new BizException(ErrorCode.INTERNAL_ERROR);
+        }
+        log.warn("Unexpected duplicate key during worker register {}: {}", phase, message);
+        return new BizException(ErrorCode.WORKER_ALREADY_REGISTERED);
+    }
+
     private void ensureIdCardNotUsed(String idCardNoEnc, Long currentUserId) {
         FeWorker existing = feWorkerMapper.selectOne(new LambdaQueryWrapper<FeWorker>()
                 .eq(FeWorker::getIdCardNoEnc, idCardNoEnc)