feat: Add functionality for companies to query their registered jobs without accessing admin details

- Added review status fields to the public_job_fair_company table to manage company registration states (pending, approved, rejected).
- Enhanced PublicJobFairServiceImpl to handle company registration, review, and job management for companies.
- Updated PublicJobFairMapper.xml with new SQL queries for managing company relations and reviews.
- Created migration script to add review fields and set default values for existing records.
- Introduced new permissions for company users to manage job postings and registration status.
- Added utility methods for ensuring proper role checks and company retrieval.

docs/app-company-job-fair-signup-api.md

@@ -4,7 +4,7 @@
 
 **接口地址：** `POST /app/fair/company/signUp`
 
-**接口说明：** 企业用户报名公共招聘会（PublicJobFair），同时填写参会岗位信息
+**接口说明：** 企业用户报名公共招聘会（PublicJobFair），同时填写参会岗位信息。报名记录会进入 `0-待审核`，管理员审核通过后企业才可以继续维护报名岗位。
 
 **请求头：**
 ```
@@ -134,7 +134,7 @@ curl -X POST http://localhost:9091/app/fair/company/signUp \
 1. 校验当前用户是否为企业用户（is_company_user=0）
 2. 通过用户的 idCard（企业信用代码）查询企业信息
 3. 检查企业是否已报名该招聘会（查询 public_job_fair_company 表）
-4. 创建企业-招聘会关联记录（public_job_fair_company 表）
+4. 创建企业-招聘会关联记录（public_job_fair_company 表），审核状态设为 `0-待审核`
 5. 批量插入岗位信息（job 表）
 6. 创建岗位-招聘会关联记录（public_job_fair_job 表）
 

docs/cms-public-job-fair-api.md

@@ -308,7 +308,7 @@
 
 ### 6. 添加企业到招聘会
 - **URL**: `POST /cms/publicJobFair/company`
-- **权限**: `cms:publicJobFair:edit`
+- **权限**: `cms:publicJobFair:company:add`
 - **请求体**:
 ```json
 {
@@ -333,13 +333,14 @@
 
 ### 8. 移除招聘会企业
 - **URL**: `DELETE /cms/publicJobFair/company/{id}`
+- **权限**: `cms:publicJobFair:company:remove`
 - **说明**: `id` 为关联表主键
 
 ---
 
 ### 9. 添加岗位到招聘会
 - **URL**: `POST /cms/publicJobFair/job`
-- **权限**: `cms:publicJobFair:edit`
+- **权限**: `cms:publicJobFair:job:add`
 - **说明**: CMS 后台将已有岗位关联到招聘会；该接口不是企业端报名接口。
 - **请求体**:
 ```json
@@ -354,7 +355,7 @@
 
 ### 10. 批量添加岗位
 - **URL**: `POST /cms/publicJobFair/job/batch`
-- **权限**: `cms:publicJobFair:edit`
+- **权限**: `cms:publicJobFair:job:add`
 - **说明**: CMS 后台批量将已有岗位关联到招聘会；该接口不是企业端报名接口。
 - **请求体**:
 ```json
@@ -368,7 +369,7 @@
 
 ### 11. 移除招聘会岗位
 - **URL**: `DELETE /cms/publicJobFair/job/{id}`
-- **权限**: `cms:publicJobFair:edit`
+- **权限**: `cms:publicJobFair:job:remove`
 
 ---
 
@@ -403,6 +404,65 @@
 
 ## 企业端报名并添加岗位
 
+CMS 企业角色现在支持分阶段报名：
+
+1. 企业在招聘会列表看到【报名】按钮和报名审核状态；
+2. 报名后状态为 `0-待审核`，企业可以查看招聘会详情，但不能维护报名岗位；
+3. 管理员审核通过后状态为 `1-通过`，企业列表显示【编辑报名岗位】，可以新增、修改、删除本企业岗位；
+4. 驳回状态为 `2-驳回`，列表显示审核意见，并允许企业重新报名。
+
+列表接口在企业角色下会补充以下字段：
+
+| 字段 | 说明 |
+|------|------|
+| `isSignUp` | 是否已有报名记录，`0` 否，`1` 是 |
+| `enterpriseId` | 当前企业 ID |
+| `enterpriseReviewStatus` | `0` 待审核、`1` 通过、`2` 驳回 |
+| `enterpriseReviewComments` | 管理员审核意见 |
+| `canSignUp` | 是否显示报名按钮 |
+| `canEditJobs` | 审核通过后是否显示编辑报名岗位 |
+
+### CMS 企业报名
+
+- **URL**: `POST /cms/publicJobFair/{jobFairId}/company/signup`
+- **权限**: `cms:publicJobFair:signup`
+- **说明**: 只允许企业角色调用，创建或重新提交企业报名记录，状态为 `0` 待审核。
+
+### CMS 企业新增报名岗位
+
+- **URL**: `POST /cms/publicJobFair/{jobFairId}/company/jobs`
+- **权限**: `cms:publicJobFair:job:add`
+- **请求体**: `Job` 对象，服务端强制使用当前企业 ID。
+- **限制**: 当前企业报名审核通过后才允许新增。
+
+### CMS 企业修改报名岗位
+
+- **URL**: `PUT /cms/publicJobFair/{jobFairId}/company/jobs/{jobId}`
+- **权限**: `cms:publicJobFair:job:edit`
+- **限制**: 只能修改当前企业自己的岗位，且企业报名审核必须通过。
+
+### CMS 企业删除报名岗位
+
+- **URL**: `DELETE /cms/publicJobFair/{jobFairId}/company/jobs/{jobId}`
+- **权限**: `cms:publicJobFair:job:remove`
+- **限制**: 只能删除当前企业自己的报名岗位，且企业报名审核必须通过；同时移除招聘会岗位关联并逻辑删除岗位。
+
+### 管理员审核参会企业
+
+- **URL**: `PUT /cms/publicJobFair/{jobFairId}/companies/{relationId}/review`
+- **权限**: `cms:publicJobFair:review`
+- **请求体**:
+
+```json
+{
+  "reviewStatus": "1",
+  "reviewRemark": ""
+}
+```
+
+`reviewStatus` 取值：`0` 待审核、`1` 通过、`2` 驳回。驳回时 `reviewRemark` 必填。
+管理员详情接口 `GET /cms/publicJobFair/{jobFairId}` 返回企业项的 `canReview`、`canAddJob`、`canRemoveCompany`；只有 `reviewStatus=1` 时，`canAddJob` 和 `canRemoveCompany` 为 `true`。服务端也会再次校验该状态。
+
 企业用户报名公共招聘会并填写参会岗位，使用以下企业端接口，不调用 CMS 的岗位关联接口：
 
 - **URL**: `POST /app/fair/company/signUp`

ruoyi-bussiness/src/main/java/com/ruoyi/cms/controller/cms/CmsPublicJobFairController.java

@@ -15,6 +15,7 @@ import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * 公共招聘会管理Controller（CMS后台）
@@ -61,6 +62,17 @@ public class CmsPublicJobFairController extends BaseController {
         return success(publicJobFairService.selectById(jobFairId));
     }
 
+    /**
+     * 企业报名线上招聘会，报名记录进入待审核状态。
+     */
+    @ApiOperation("企业报名招聘会")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:signup')")
+    @Log(title = "企业报名招聘会", businessType = BusinessType.INSERT)
+    @PostMapping("/{jobFairId}/company/signup")
+    public AjaxResult signup(@ApiParam("招聘会ID") @PathVariable String jobFairId) {
+        return publicJobFairService.signupCurrentCompany(jobFairId);
+    }
+
     /**
      * 新增招聘会
      */
@@ -98,7 +110,7 @@ public class CmsPublicJobFairController extends BaseController {
      * 添加企业到招聘会
      */
     @ApiOperation("添加企业到招聘会")
-    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:edit')")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:company:add')")
     @Log(title = "招聘会添加企业", businessType = BusinessType.INSERT)
     @PostMapping("/company")
     public AjaxResult addCompany(@RequestBody PublicJobFairCompany company) {
@@ -109,7 +121,7 @@ public class CmsPublicJobFairController extends BaseController {
      * 批量添加企业到招聘会
      */
     @ApiOperation("批量添加企业到招聘会")
-    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:edit')")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:company:add')")
     @Log(title = "招聘会批量添加企业", businessType = BusinessType.INSERT)
     @PostMapping("/company/batch")
     public AjaxResult addCompanyBatch(@RequestBody List<PublicJobFairCompany> companies) {
@@ -120,18 +132,35 @@ public class CmsPublicJobFairController extends BaseController {
      * 移除招聘会企业
      */
     @ApiOperation("移除招聘会企业")
-    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:edit')")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:company:remove')")
     @Log(title = "移除招聘会企业", businessType = BusinessType.DELETE)
     @DeleteMapping("/company/{id}")
     public AjaxResult removeCompany(@ApiParam("关联ID") @PathVariable String id) {
         return toAjax(publicJobFairService.removeCompany(id));
     }
 
+    /**
+     * 管理员审核企业报名。
+     */
+    @ApiOperation("审核招聘会参会企业")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:review')")
+    @Log(title = "审核招聘会参会企业", businessType = BusinessType.UPDATE)
+    @PutMapping("/{jobFairId}/companies/{relationId}/review")
+    public AjaxResult reviewCompany(@ApiParam("招聘会ID") @PathVariable String jobFairId,
+                                    @ApiParam("企业报名关联ID") @PathVariable String relationId,
+                                    @RequestBody Map<String, Object> request) {
+        String reviewStatus = request == null || request.get("reviewStatus") == null
+                ? null : String.valueOf(request.get("reviewStatus"));
+        String reviewRemark = request == null || request.get("reviewRemark") == null
+                ? null : String.valueOf(request.get("reviewRemark"));
+        return publicJobFairService.reviewCompany(jobFairId, relationId, reviewStatus, reviewRemark);
+    }
+
     /**
      * 添加岗位到招聘会
      */
     @ApiOperation("添加岗位到招聘会")
-    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:edit')")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:job:add')")
     @Log(title = "招聘会添加岗位", businessType = BusinessType.INSERT)
     @PostMapping("/job")
     public AjaxResult addJob(@RequestBody PublicJobFairJob job) {
@@ -142,7 +171,7 @@ public class CmsPublicJobFairController extends BaseController {
      * 批量添加岗位到招聘会
      */
     @ApiOperation("批量添加岗位到招聘会")
-    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:edit')")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:job:add')")
     @Log(title = "招聘会批量添加岗位", businessType = BusinessType.INSERT)
     @PostMapping("/job/batch")
     public AjaxResult addJobBatch(@RequestBody List<PublicJobFairJob> jobs) {
@@ -153,13 +182,60 @@ public class CmsPublicJobFairController extends BaseController {
      * 移除招聘会岗位
      */
     @ApiOperation("移除招聘会岗位")
-    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:edit')")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:job:remove')")
     @Log(title = "移除招聘会岗位", businessType = BusinessType.DELETE)
     @DeleteMapping("/job/{id}")
     public AjaxResult removeJob(@ApiParam("关联ID") @PathVariable String id) {
         return toAjax(publicJobFairService.removeJob(id));
     }
 
+    /**
+     * 企业新增已审核通过招聘会的报名岗位。
+     */
+    @ApiOperation("企业新增报名岗位")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:job:add')")
+    @Log(title = "企业新增报名岗位", businessType = BusinessType.INSERT)
+    @PostMapping("/{jobFairId}/company/jobs")
+    public AjaxResult addCurrentCompanyJob(@ApiParam("招聘会ID") @PathVariable String jobFairId,
+                                           @RequestBody com.ruoyi.cms.domain.Job job) {
+        return publicJobFairService.addCurrentCompanyJob(jobFairId, job);
+    }
+
+    /**
+     * 企业修改自己的报名岗位。
+     */
+    @ApiOperation("企业修改报名岗位")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:job:edit')")
+    @Log(title = "企业修改报名岗位", businessType = BusinessType.UPDATE)
+    @PutMapping("/{jobFairId}/company/jobs/{jobId}")
+    public AjaxResult updateCurrentCompanyJob(@ApiParam("招聘会ID") @PathVariable String jobFairId,
+                                              @ApiParam("岗位ID") @PathVariable Long jobId,
+                                              @RequestBody com.ruoyi.cms.domain.Job job) {
+        return publicJobFairService.updateCurrentCompanyJob(jobFairId, jobId, job);
+    }
+
+    /**
+     * 企业删除自己的报名岗位。
+     */
+    @ApiOperation("企业删除报名岗位")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:job:remove')")
+    @Log(title = "企业删除报名岗位", businessType = BusinessType.DELETE)
+    @DeleteMapping("/{jobFairId}/company/jobs/{jobId}")
+    public AjaxResult removeCurrentCompanyJob(@ApiParam("招聘会ID") @PathVariable String jobFairId,
+                                              @ApiParam("岗位ID") @PathVariable Long jobId) {
+        return publicJobFairService.removeCurrentCompanyJob(jobFairId, jobId);
+    }
+
+    /**
+     * 企业查询自己已报名的岗位，不进入管理员招聘会详情页。
+     */
+    @ApiOperation("查询企业报名岗位")
+    @PreAuthorize("@ss.hasPermi('cms:publicJobFair:job:edit')")
+    @GetMapping("/{jobFairId}/company/jobs")
+    public AjaxResult getCurrentCompanyJobs(@ApiParam("招聘会ID") @PathVariable String jobFairId) {
+        return success(publicJobFairService.getCurrentCompanyJobs(jobFairId));
+    }
+
     /**
      * 查询招聘会报名列表
      */

ruoyi-bussiness/src/main/java/com/ruoyi/cms/domain/Job.java

@@ -221,6 +221,10 @@ public class Job extends BaseEntity
     @ApiModelProperty("户外招聘会岗位审核时间")
     private String fairReviewTime;
 
+    @TableField(exist = false)
+    @ApiModelProperty("公共招聘会岗位关联ID")
+    private String fairRelationId;
+
     //简历是否被查看
     @TableField(exist = false)
     private String isView;

ruoyi-bussiness/src/main/java/com/ruoyi/cms/domain/rc/PublicJobFair.java

@@ -94,6 +94,12 @@ public class PublicJobFair implements Serializable {
     @ApiModelProperty("是否报名")
     private String isSignUp;
 
+    @ApiModelProperty("当前企业是否可以报名")
+    private Boolean canSignUp;
+
+    @ApiModelProperty("当前企业是否可以维护报名岗位")
+    private Boolean canEditJobs;
+
     @ApiModelProperty("企业数量")
     private String enterpriseNum;
 

ruoyi-bussiness/src/main/java/com/ruoyi/cms/domain/rc/PublicJobFairCompany.java

@@ -42,4 +42,17 @@ public class PublicJobFairCompany implements Serializable {
 
     @ApiModelProperty("删除标志")
     private String delFlag;
+
+    @ApiModelProperty("审核状态 0待审核 1通过 2驳回")
+    private String reviewStatus;
+
+    @ApiModelProperty("审核人")
+    private String reviewBy;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty("审核时间")
+    private Date reviewTime;
+
+    @ApiModelProperty("审核意见")
+    private String reviewRemark;
 }

ruoyi-bussiness/src/main/java/com/ruoyi/cms/domain/rc/PublicJobFairCompanyVO.java

@@ -35,6 +35,30 @@ public class PublicJobFairCompanyVO implements Serializable {
     @ApiModelProperty("企业类型")
     private String companyType;
 
+    @ApiModelProperty("审核状态 0待审核 1通过 2驳回")
+    private String reviewStatus;
+
+    @ApiModelProperty("审核人")
+    private String reviewBy;
+
+    @ApiModelProperty("审核时间")
+    private java.util.Date reviewTime;
+
+    @ApiModelProperty("审核意见")
+    private String reviewRemark;
+
+    @ApiModelProperty("是否可以审核")
+    private Boolean canReview;
+
+    @ApiModelProperty("是否可以添加岗位")
+    private Boolean canAddJob;
+
+    @ApiModelProperty("是否可以移除企业")
+    private Boolean canRemoveCompany;
+
+    @ApiModelProperty("当前企业是否可以编辑岗位")
+    private Boolean canEditJobs;
+
     @ApiModelProperty("在招职位列表")
     private List<Job> jobInfoList;
 }

ruoyi-bussiness/src/main/java/com/ruoyi/cms/mapper/rc/PublicJobFairMapper.java

@@ -27,6 +27,28 @@ public interface PublicJobFairMapper extends BaseMapper<PublicJobFair> {
      */
     List<PublicJobFairCompanyVO> selectCompanyListByJobFairId(@Param("jobFairId") String jobFairId);
 
+    /**
+     * 查询指定企业在招聘会中的关联记录。
+     */
+    PublicJobFairCompany selectCompanyRelation(@Param("jobFairId") String jobFairId,
+                                               @Param("companyId") Long companyId);
+
+    /**
+     * 批量查询指定企业的招聘会报名状态。
+     */
+    List<PublicJobFairCompany> selectCompanyRelations(@Param("jobFairIds") List<String> jobFairIds,
+                                                      @Param("companyId") Long companyId);
+
+    /**
+     * 查询招聘会企业关联记录。
+     */
+    PublicJobFairCompany selectCompanyRelationById(@Param("id") String id);
+
+    /**
+     * 审核招聘会企业报名。
+     */
+    int updateCompanyReview(PublicJobFairCompany relation);
+
     /**
      * 查询招聘会关联的岗位列表
      */
@@ -94,6 +116,12 @@ public interface PublicJobFairMapper extends BaseMapper<PublicJobFair> {
      */
     int deleteJobFairCompanyById(@Param("id") String id);
 
+    /**
+     * 删除招聘会中指定企业的全部岗位关联。
+     */
+    int deleteJobFairJobsByCompany(@Param("jobFairId") String jobFairId,
+                                   @Param("companyId") Long companyId);
+
     /**
      * 添加岗位到招聘会
      */
@@ -109,6 +137,17 @@ public interface PublicJobFairMapper extends BaseMapper<PublicJobFair> {
      */
     int deleteJobFairJobById(@Param("id") String id);
 
+    /**
+     * 查询招聘会岗位关联。
+     */
+    PublicJobFairJob selectJobRelation(@Param("jobFairId") String jobFairId,
+                                       @Param("jobId") Long jobId);
+
+    /**
+     * 根据关联主键查询招聘会岗位关联。
+     */
+    PublicJobFairJob selectJobRelationById(@Param("id") String id);
+
     /**
      * 查询招聘会报名列表（包含用户信息）
      */

ruoyi-bussiness/src/main/java/com/ruoyi/cms/service/rc/IPublicJobFairService.java

@@ -1,6 +1,8 @@
 package com.ruoyi.cms.service.rc;
 
 import com.ruoyi.cms.domain.rc.*;
+import com.ruoyi.cms.domain.Job;
+import com.ruoyi.common.core.domain.AjaxResult;
 
 import java.util.List;
 
@@ -76,6 +78,16 @@ public interface IPublicJobFairService {
      */
     int addCompanyBatch(List<PublicJobFairCompany> companies);
 
+    /**
+     * 当前企业报名招聘会，进入待审核状态。
+     */
+    AjaxResult signupCurrentCompany(String jobFairId);
+
+    /**
+     * 审核企业报名。
+     */
+    AjaxResult reviewCompany(String jobFairId, String relationId, String reviewStatus, String reviewRemark);
+
     /**
      * 移除招聘会企业
      */
@@ -96,6 +108,26 @@ public interface IPublicJobFairService {
      */
     int removeJob(String id);
 
+    /**
+     * 当前企业新增报名岗位。
+     */
+    AjaxResult addCurrentCompanyJob(String jobFairId, Job job);
+
+    /**
+     * 当前企业修改报名岗位。
+     */
+    AjaxResult updateCurrentCompanyJob(String jobFairId, Long jobId, Job job);
+
+    /**
+     * 当前企业删除报名岗位。
+     */
+    AjaxResult removeCurrentCompanyJob(String jobFairId, Long jobId);
+
+    /**
+     * 查询当前企业已报名的岗位，不返回招聘会管理员详情。
+     */
+    List<Job> getCurrentCompanyJobs(String jobFairId);
+
     /**
      * 查询招聘会报名列表
      */

ruoyi-bussiness/src/main/java/com/ruoyi/cms/service/rc/impl/JobFairSignUpServiceImpl.java

@@ -91,6 +91,9 @@ public class JobFairSignUpServiceImpl extends ServiceImpl<JobFairSignUpMapper, J
     @Transactional(rollbackFor = Exception.class)
     public AjaxResult companySignUp(CompanyJobFairSignUpVO signUpVO) {
         // 1. 校验参数
+        if (signUpVO == null) {
+            return AjaxResult.error("报名参数不能为空");
+        }
         if (StringUtils.isBlank(signUpVO.getJobFairId())) {
             return AjaxResult.error("招聘会ID不能为空");
         }
@@ -121,19 +124,31 @@ public class JobFairSignUpServiceImpl extends ServiceImpl<JobFairSignUpMapper, J
         Long companyId = company.getCompanyId();
 
         // 4. 检查企业是否已报名该招聘会
-        List<com.ruoyi.cms.domain.rc.PublicJobFairCompanyVO> existCompanies = publicJobFairMapper.selectCompanyListByJobFairId(jobFairId);
+        PublicJobFairCompany existingRelation = publicJobFairMapper.selectCompanyRelation(jobFairId, companyId);
-        boolean alreadySignUp = existCompanies.stream().anyMatch(c -> companyId.equals(c.getCompanyId()));
+        if (existingRelation != null && !"2".equals(existingRelation.getReviewStatus())) {
-        if (alreadySignUp) {
             return AjaxResult.error("您的企业已报名该招聘会，请勿重复报名");
         }
 
         // 5. 创建企业-招聘会关联 (public_job_fair_company)
-        PublicJobFairCompany fairCompany = new PublicJobFairCompany();
+        Date now = new Date();
-        fairCompany.setId(IdUtil.simpleUUID());
+        PublicJobFairCompany fairCompany = existingRelation;
-        fairCompany.setJobFairId(jobFairId);
+        if (fairCompany == null) {
-        fairCompany.setCompanyId(companyId);
+            fairCompany = new PublicJobFairCompany();
-        fairCompany.setCreateTime(new Date());
+            fairCompany.setId(IdUtil.simpleUUID());
-        publicJobFairMapper.insertJobFairCompany(fairCompany);
+            fairCompany.setJobFairId(jobFairId);
+            fairCompany.setCompanyId(companyId);
+            fairCompany.setCreateTime(now);
+            fairCompany.setReviewStatus("0");
+            publicJobFairMapper.insertJobFairCompany(fairCompany);
+        } else {
+            // 被驳回后重新报名，恢复为待审核并清空旧审核意见。
+            fairCompany.setReviewStatus("0");
+            fairCompany.setReviewBy(null);
+            fairCompany.setReviewTime(null);
+            fairCompany.setReviewRemark(null);
+            fairCompany.setUpdateTime(now);
+            publicJobFairMapper.updateCompanyReview(fairCompany);
+        }
 
         // 6. 批量插入岗位到job表，并创建岗位-招聘会关联
         List<Job> jobList = signUpVO.getJobList();
@@ -155,7 +170,7 @@ public class JobFairSignUpServiceImpl extends ServiceImpl<JobFairSignUpMapper, J
             fairJob.setJobFairId(jobFairId);
             fairJob.setJobId(job.getJobId());
             fairJob.setCompanyId(companyId);
-            fairJob.setCreateTime(new Date());
+            fairJob.setCreateTime(now);
             fairJobList.add(fairJob);
         }
 

ruoyi-bussiness/src/main/java/com/ruoyi/cms/service/rc/impl/PublicJobFairServiceImpl.java

@@ -2,12 +2,23 @@ package com.ruoyi.cms.service.rc.impl;
 
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.ruoyi.cms.domain.Job;
 import com.ruoyi.cms.domain.rc.*;
+import com.ruoyi.cms.mapper.CompanyMapper;
 import com.ruoyi.cms.mapper.rc.PublicJobFairMapper;
+import com.ruoyi.cms.service.ICompanyService;
+import com.ruoyi.cms.service.IJobService;
 import com.ruoyi.cms.service.rc.IPublicJobFairService;
+import com.ruoyi.cms.util.RoleUtils;
+import com.ruoyi.common.core.domain.AjaxResult;
+import com.ruoyi.common.core.domain.entity.Company;
+import com.ruoyi.common.core.domain.entity.SysUser;
+import com.ruoyi.common.core.domain.model.LoginUser;
+import com.ruoyi.common.exception.ServiceException;
 import com.ruoyi.common.utils.SecurityUtils;
 import com.ruoyi.common.utils.SiteSecurityUtils;
+import com.ruoyi.common.utils.StringUtils;
 import com.ruoyi.common.utils.uuid.IdUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -15,8 +26,12 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -29,10 +44,20 @@ public class PublicJobFairServiceImpl implements IPublicJobFairService {
     @Autowired
     private PublicJobFairMapper publicJobFairMapper;
 
+    @Autowired
+    private CompanyMapper companyMapper;
+
+    @Autowired
+    private ICompanyService companyService;
+
+    @Autowired
+    private IJobService jobService;
+
     @Override
     public PublicJobFairResponse getJobFairPage(PublicJobFairQuery query) {
         PageHelper.startPage(query.getPageNum(), query.getPageSize());
         List<PublicJobFair> list = publicJobFairMapper.selectPublicJobFairList(query);
+        fillCompanyApplyState(list);
         PageInfo<PublicJobFair> pageInfo = new PageInfo<>(list);
 
         PublicJobFairResponse response = new PublicJobFairResponse();
@@ -94,13 +119,37 @@ public class PublicJobFairServiceImpl implements IPublicJobFairService {
     public List<PublicJobFairCompanyVO> getEnterprisesWithJobs(String jobFairId) {
         List<PublicJobFairCompanyVO> companyList = publicJobFairMapper.selectCompanyListByJobFairId(jobFairId);
 
-        if (companyList != null && !companyList.isEmpty()) {
+        if (companyList == null || companyList.isEmpty()) {
-            for (PublicJobFairCompanyVO company : companyList) {
+            return Collections.emptyList();
-                List<Job> jobList = publicJobFairMapper.selectJobListByJobFairIdAndCompanyId(jobFairId, company.getCompanyId());
-                company.setJobInfoList(jobList);
-            }
         }
-        return companyList;
+
+        boolean enterpriseRole = RoleUtils.isCompanyAdmin();
+        boolean cmsAdmin = SecurityUtils.isLogin() && !enterpriseRole;
+        Company currentCompany = enterpriseRole ? getCurrentCompanyOrNull() : null;
+        if (enterpriseRole && currentCompany == null) {
+            return Collections.emptyList();
+        }
+
+        List<PublicJobFairCompanyVO> visibleCompanies = companyList.stream()
+                .filter(company -> !enterpriseRole
+                        || currentCompany.getCompanyId().equals(company.getCompanyId()))
+                .collect(Collectors.toList());
+        for (PublicJobFairCompanyVO company : visibleCompanies) {
+            String reviewStatus = effectiveReviewStatus(company.getReviewStatus());
+            company.setReviewStatus(reviewStatus);
+            // 管理员审核，并且审核通过后才允许添加岗位/移除企业。
+            company.setCanReview(cmsAdmin && !"1".equals(reviewStatus));
+            company.setCanAddJob(cmsAdmin && "1".equals(reviewStatus));
+            company.setCanRemoveCompany(cmsAdmin && "1".equals(reviewStatus));
+            // 企业角色只维护自己的岗位，且报名审核必须通过。
+            company.setCanEditJobs(enterpriseRole && "1".equals(reviewStatus)
+                    && currentCompany != null
+                    && currentCompany.getCompanyId().equals(company.getCompanyId()));
+            List<Job> jobList = publicJobFairMapper.selectJobListByJobFairIdAndCompanyId(
+                    jobFairId, company.getCompanyId());
+            company.setJobInfoList(jobList);
+        }
+        return visibleCompanies;
     }
 
     @Override
@@ -122,7 +171,9 @@ public class PublicJobFairServiceImpl implements IPublicJobFairService {
 
     @Override
     public List<PublicJobFair> selectList(PublicJobFairQuery query) {
-        return publicJobFairMapper.selectPublicJobFairList(query);
+        List<PublicJobFair> list = publicJobFairMapper.selectPublicJobFairList(query);
+        fillCompanyApplyState(list);
+        return list;
     }
 
     @Override
@@ -162,34 +213,148 @@ public class PublicJobFairServiceImpl implements IPublicJobFairService {
     @Override
     @Transactional
     public int addCompany(PublicJobFairCompany company) {
+        if (company == null || StringUtils.isBlank(company.getJobFairId()) || company.getCompanyId() == null) {
+            throw new ServiceException("招聘会和企业不能为空");
+        }
+        ensureAdminOperation();
+        ensureJobFairExists(company.getJobFairId());
+        if (publicJobFairMapper.selectCompanyRelation(company.getJobFairId(), company.getCompanyId()) != null) {
+            throw new ServiceException("该企业已参加当前招聘会");
+        }
         company.setId(IdUtils.fastSimpleUUID());
         company.setCreateTime(new Date());
         company.setCreateBy(SecurityUtils.getUsername());
+        // 管理员直接添加的企业视为已审核通过。
+        company.setReviewStatus("1");
         return publicJobFairMapper.insertJobFairCompany(company);
     }
 
     @Override
     @Transactional
     public int addCompanyBatch(List<PublicJobFairCompany> companies) {
+        ensureAdminOperation();
+        if (companies == null || companies.isEmpty()) {
+            return 0;
+        }
         String username = SecurityUtils.getUsername();
         Date now = new Date();
         for (PublicJobFairCompany company : companies) {
+            if (company == null || StringUtils.isBlank(company.getJobFairId()) || company.getCompanyId() == null) {
+                throw new ServiceException("招聘会和企业不能为空");
+            }
+            ensureJobFairExists(company.getJobFairId());
+            if (publicJobFairMapper.selectCompanyRelation(company.getJobFairId(), company.getCompanyId()) != null) {
+                throw new ServiceException("企业已参加当前招聘会，不能重复添加");
+            }
             company.setId(IdUtils.fastSimpleUUID());
             company.setCreateTime(now);
             company.setCreateBy(username);
+            company.setReviewStatus("1");
         }
         return publicJobFairMapper.insertJobFairCompanyBatch(companies);
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AjaxResult signupCurrentCompany(String jobFairId) {
+        if (!RoleUtils.isCompanyAdmin()) {
+            return AjaxResult.error("仅企业用户可以报名招聘会");
+        }
+        if (StringUtils.isBlank(jobFairId)) {
+            return AjaxResult.error("招聘会ID不能为空");
+        }
+        ensureJobFairExists(jobFairId);
+        Company company = getCurrentCompanyOrThrow();
+        PublicJobFairCompany relation = publicJobFairMapper.selectCompanyRelation(
+                jobFairId, company.getCompanyId());
+        Date now = new Date();
+        if (relation != null && !"2".equals(effectiveReviewStatus(relation.getReviewStatus()))) {
+            return AjaxResult.error("您的企业已报名该招聘会，请勿重复报名");
+        }
+        if (relation == null) {
+            relation = new PublicJobFairCompany();
+            relation.setId(IdUtils.fastSimpleUUID());
+            relation.setJobFairId(jobFairId);
+            relation.setCompanyId(company.getCompanyId());
+            relation.setCreateBy(SecurityUtils.getUsername());
+            relation.setCreateTime(now);
+            relation.setReviewStatus("0");
+            publicJobFairMapper.insertJobFairCompany(relation);
+        } else {
+            // 被驳回后允许重新报名，并清空上一次审核结论。
+            relation.setReviewStatus("0");
+            relation.setReviewBy(null);
+            relation.setReviewTime(null);
+            relation.setReviewRemark(null);
+            relation.setUpdateBy(SecurityUtils.getUsername());
+            relation.setUpdateTime(now);
+            publicJobFairMapper.updateCompanyReview(relation);
+        }
+        return AjaxResult.success("报名成功，等待管理员审核", relation);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AjaxResult reviewCompany(String jobFairId, String relationId,
+                                    String reviewStatus, String reviewRemark) {
+        ensureAdminOperation();
+        if (StringUtils.isBlank(jobFairId) || StringUtils.isBlank(relationId)) {
+            return AjaxResult.error("招聘会和报名记录不能为空");
+        }
+        if (!isValidReviewStatus(reviewStatus)) {
+            return AjaxResult.error("审核状态不正确");
+        }
+        if ("2".equals(reviewStatus) && StringUtils.isBlank(reviewRemark)) {
+            return AjaxResult.error("驳回时请填写原因");
+        }
+        PublicJobFairCompany relation = publicJobFairMapper.selectCompanyRelationById(relationId);
+        if (relation == null || !jobFairId.equals(relation.getJobFairId())) {
+            return AjaxResult.error("参会企业报名记录不存在");
+        }
+        relation.setReviewStatus(reviewStatus);
+        relation.setReviewBy(SecurityUtils.getUsername());
+        relation.setReviewTime(new Date());
+        relation.setReviewRemark(StringUtils.isBlank(reviewRemark) ? null : reviewRemark.trim());
+        relation.setUpdateBy(SecurityUtils.getUsername());
+        relation.setUpdateTime(new Date());
+        int updated = publicJobFairMapper.updateCompanyReview(relation);
+        return updated > 0 ? AjaxResult.success("审核完成", relation) : AjaxResult.error("审核失败");
+    }
+
     @Override
     @Transactional
     public int removeCompany(String id) {
+        ensureAdminOperation();
+        PublicJobFairCompany relation = publicJobFairMapper.selectCompanyRelationById(id);
+        if (relation == null) {
+            throw new ServiceException("参会企业不存在");
+        }
+        ensureApproved(relation);
+        publicJobFairMapper.deleteJobFairJobsByCompany(relation.getJobFairId(), relation.getCompanyId());
         return publicJobFairMapper.deleteJobFairCompanyById(id);
     }
 
     @Override
     @Transactional
     public int addJob(PublicJobFairJob job) {
+        ensureAdminOperation();
+        if (job == null || StringUtils.isBlank(job.getJobFairId()) || job.getJobId() == null) {
+            throw new ServiceException("招聘会和岗位不能为空");
+        }
+        Job existingJob = jobService.selectJobByJobId(job.getJobId());
+        if (existingJob == null) {
+            throw new ServiceException("岗位不存在");
+        }
+        if (job.getCompanyId() == null) {
+            job.setCompanyId(existingJob.getCompanyId());
+        }
+        if (!job.getCompanyId().equals(existingJob.getCompanyId())) {
+            throw new ServiceException("岗位不属于所选企业");
+        }
+        ensureApproved(job.getJobFairId(), job.getCompanyId());
+        if (publicJobFairMapper.selectJobRelation(job.getJobFairId(), job.getJobId()) != null) {
+            throw new ServiceException("该岗位已添加到当前招聘会");
+        }
         job.setId(IdUtils.fastSimpleUUID());
         job.setCreateTime(new Date());
         job.setCreateBy(SecurityUtils.getUsername());
@@ -199,9 +364,30 @@ public class PublicJobFairServiceImpl implements IPublicJobFairService {
     @Override
     @Transactional
     public int addJobBatch(List<PublicJobFairJob> jobs) {
+        ensureAdminOperation();
+        if (jobs == null || jobs.isEmpty()) {
+            return 0;
+        }
         String username = SecurityUtils.getUsername();
         Date now = new Date();
         for (PublicJobFairJob job : jobs) {
+            if (job == null || StringUtils.isBlank(job.getJobFairId()) || job.getJobId() == null) {
+                throw new ServiceException("招聘会和岗位不能为空");
+            }
+            Job existingJob = jobService.selectJobByJobId(job.getJobId());
+            if (existingJob == null) {
+                throw new ServiceException("岗位不存在");
+            }
+            if (job.getCompanyId() == null) {
+                job.setCompanyId(existingJob.getCompanyId());
+            }
+            if (!job.getCompanyId().equals(existingJob.getCompanyId())) {
+                throw new ServiceException("岗位不属于所选企业");
+            }
+            ensureApproved(job.getJobFairId(), job.getCompanyId());
+            if (publicJobFairMapper.selectJobRelation(job.getJobFairId(), job.getJobId()) != null) {
+                throw new ServiceException("岗位已添加到当前招聘会，不能重复添加");
+            }
             job.setId(IdUtils.fastSimpleUUID());
             job.setCreateTime(now);
             job.setCreateBy(username);
@@ -212,9 +398,244 @@ public class PublicJobFairServiceImpl implements IPublicJobFairService {
     @Override
     @Transactional
     public int removeJob(String id) {
+        ensureAdminOperation();
+        PublicJobFairJob relation = publicJobFairMapper.selectJobRelationById(id);
+        if (relation == null) {
+            throw new ServiceException("招聘会岗位不存在");
+        }
+        ensureApproved(relation.getJobFairId(), relation.getCompanyId());
         return publicJobFairMapper.deleteJobFairJobById(id);
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AjaxResult addCurrentCompanyJob(String jobFairId, Job job) {
+        ensureCompanyOperation();
+        if (StringUtils.isBlank(jobFairId) || job == null) {
+            return AjaxResult.error("招聘会和岗位不能为空");
+        }
+        Company company = getCurrentCompanyOrThrow();
+        ensureApproved(jobFairId, company.getCompanyId());
+        job.setJobId(null);
+        job.setCompanyId(company.getCompanyId());
+        job.setCompanyName(company.getName());
+        if (job.getIsPublish() == null) {
+            job.setIsPublish(1);
+        }
+        int inserted = jobService.insertJob(job);
+        if (inserted <= 0 || job.getJobId() == null) {
+            return AjaxResult.error("岗位新增失败");
+        }
+        PublicJobFairJob relation = new PublicJobFairJob();
+        relation.setId(IdUtils.fastSimpleUUID());
+        relation.setJobFairId(jobFairId);
+        relation.setJobId(job.getJobId());
+        relation.setCompanyId(company.getCompanyId());
+        relation.setCreateBy(SecurityUtils.getUsername());
+        relation.setCreateTime(new Date());
+        publicJobFairMapper.insertJobFairJob(relation);
+        return AjaxResult.success(job);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AjaxResult updateCurrentCompanyJob(String jobFairId, Long jobId, Job job) {
+        ensureCompanyOperation();
+        if (StringUtils.isBlank(jobFairId) || jobId == null || job == null) {
+            return AjaxResult.error("招聘会、岗位和岗位内容不能为空");
+        }
+        Company company = getCurrentCompanyOrThrow();
+        PublicJobFairJob relation = ensureCurrentCompanyJob(jobFairId, jobId, company.getCompanyId());
+        ensureApproved(relation);
+        job.setJobId(jobId);
+        job.setCompanyId(company.getCompanyId());
+        job.setCompanyName(company.getName());
+        // 企业编辑报名岗位时不改变岗位发布状态。
+        job.setIsPublish(null);
+        return jobService.updateJob(job) > 0
+                ? AjaxResult.success(job)
+                : AjaxResult.error("岗位修改失败");
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AjaxResult removeCurrentCompanyJob(String jobFairId, Long jobId) {
+        ensureCompanyOperation();
+        if (StringUtils.isBlank(jobFairId) || jobId == null) {
+            return AjaxResult.error("招聘会和岗位不能为空");
+        }
+        Company company = getCurrentCompanyOrThrow();
+        PublicJobFairJob relation = ensureCurrentCompanyJob(jobFairId, jobId, company.getCompanyId());
+        ensureApproved(relation);
+        int relationDeleted = publicJobFairMapper.deleteJobFairJobById(relation.getId());
+        int jobDeleted = jobService.deleteJobByJobIds(new Long[]{jobId});
+        return relationDeleted > 0 && jobDeleted > 0
+                ? AjaxResult.success("岗位已移除")
+                : AjaxResult.error("岗位移除失败");
+    }
+
+    @Override
+    public List<Job> getCurrentCompanyJobs(String jobFairId) {
+        ensureCompanyOperation();
+        if (StringUtils.isBlank(jobFairId)) {
+            throw new ServiceException("招聘会ID不能为空");
+        }
+        Company company = getCurrentCompanyOrThrow();
+        ensureApproved(jobFairId, company.getCompanyId());
+        return publicJobFairMapper.selectJobListByJobFairIdAndCompanyId(jobFairId, company.getCompanyId());
+    }
+
+    /**
+     * 为企业端列表补充报名状态和按钮状态。
+     */
+    private void fillCompanyApplyState(List<PublicJobFair> list) {
+        if (list == null || list.isEmpty() || !RoleUtils.isCompanyAdmin()) {
+            return;
+        }
+        Company company = getCurrentCompanyOrNull();
+        if (company == null) {
+            for (PublicJobFair fair : list) {
+                fair.setIsSignUp("0");
+                fair.setCanSignUp(false);
+                fair.setCanEditJobs(false);
+            }
+            return;
+        }
+
+        List<String> jobFairIds = list.stream()
+                .map(PublicJobFair::getJobFairId)
+                .filter(StringUtils::isNotBlank)
+                .collect(Collectors.toList());
+        Map<String, PublicJobFairCompany> relationMap = new HashMap<>();
+        if (!jobFairIds.isEmpty()) {
+            publicJobFairMapper.selectCompanyRelations(jobFairIds, company.getCompanyId())
+                    .forEach(relation -> relationMap.putIfAbsent(relation.getJobFairId(), relation));
+        }
+        for (PublicJobFair fair : list) {
+            PublicJobFairCompany relation = relationMap.get(fair.getJobFairId());
+            String reviewStatus = relation == null ? null : effectiveReviewStatus(relation.getReviewStatus());
+            fair.setIsSignUp(relation == null ? "0" : "1");
+            fair.setEnterpriseId(String.valueOf(company.getCompanyId()));
+            fair.setEnterpriseReviewStatus(reviewStatus);
+            fair.setEnterpriseReviewComments(relation == null ? null : relation.getReviewRemark());
+            fair.setCanSignUp(relation == null || "2".equals(reviewStatus));
+            fair.setCanEditJobs("1".equals(reviewStatus));
+        }
+    }
+
+    private String effectiveReviewStatus(String reviewStatus) {
+        return StringUtils.isBlank(reviewStatus) ? "1" : reviewStatus;
+    }
+
+    private boolean isValidReviewStatus(String reviewStatus) {
+        return "0".equals(reviewStatus) || "1".equals(reviewStatus) || "2".equals(reviewStatus);
+    }
+
+    private void ensureCompanyOperation() {
+        if (!RoleUtils.isCompanyAdmin()) {
+            throw new ServiceException("仅企业用户可以维护报名岗位");
+        }
+    }
+
+    private void ensureAdminOperation() {
+        if (RoleUtils.isCompanyAdmin()) {
+            throw new ServiceException("企业用户不能执行管理员操作");
+        }
+    }
+
+    private void ensureJobFairExists(String jobFairId) {
+        if (StringUtils.isBlank(jobFairId)
+                || publicJobFairMapper.selectPublicJobFairById(jobFairId) == null) {
+            throw new ServiceException("招聘会不存在");
+        }
+    }
+
+    private void ensureApproved(String jobFairId, Long companyId) {
+        if (companyId == null) {
+            throw new ServiceException("企业不能为空");
+        }
+        PublicJobFairCompany relation = publicJobFairMapper.selectCompanyRelation(jobFairId, companyId);
+        if (relation == null) {
+            throw new ServiceException("该企业未报名当前招聘会");
+        }
+        ensureApproved(relation);
+    }
+
+    private void ensureApproved(PublicJobFairCompany relation) {
+        if (relation == null || !"1".equals(effectiveReviewStatus(relation.getReviewStatus()))) {
+            throw new ServiceException("报名审核通过后才能操作");
+        }
+    }
+
+    private PublicJobFairJob ensureCurrentCompanyJob(String jobFairId, Long jobId, Long companyId) {
+        PublicJobFairJob relation = publicJobFairMapper.selectJobRelation(jobFairId, jobId);
+        if (relation == null) {
+            throw new ServiceException("当前招聘会不存在该岗位");
+        }
+        if (!companyId.equals(relation.getCompanyId())) {
+            throw new ServiceException("只能维护本企业报名岗位");
+        }
+        return relation;
+    }
+
+    private Company getCurrentCompanyOrThrow() {
+        Company company = getCurrentCompanyOrNull();
+        if (company == null) {
+            throw new ServiceException("未查询到当前登录企业信息");
+        }
+        return company;
+    }
+
+    /**
+     * 企业账号的历史数据可能只保存了统一信用代码，部分账号则通过 company.user_id 关联。
+     * 两种方式都保留，和户外招聘会的企业识别规则一致。
+     */
+    private Company getCurrentCompanyOrNull() {
+        if (!RoleUtils.isCompanyAdmin() || !SecurityUtils.isLogin()) {
+            return null;
+        }
+        LoginUser loginUser = SecurityUtils.getLoginUser();
+        if (loginUser == null || loginUser.getUser() == null) {
+            return null;
+        }
+        SysUser sysUser = loginUser.getUser();
+        if (StringUtils.isNotBlank(sysUser.getIdCard())) {
+            Company company = companyService.queryCodeCompany(sysUser.getIdCard());
+            if (company != null) {
+                return company;
+            }
+        }
+        Long userId = loginUser.getUserId() == null ? sysUser.getUserId() : loginUser.getUserId();
+        if (userId != null) {
+            Company company = companyMapper.selectOne(new LambdaQueryWrapper<Company>()
+                    .eq(Company::getUserId, userId)
+                    .eq(Company::getDelFlag, "0")
+                    .orderByDesc(Company::getUpdateTime)
+                    .last("LIMIT 1"));
+            if (company != null) {
+                return company;
+            }
+        }
+        List<String> names = new ArrayList<>();
+        if (StringUtils.isNotBlank(sysUser.getNickName())) {
+            names.add(sysUser.getNickName());
+        }
+        if (StringUtils.isNotBlank(sysUser.getUserName()) && !names.contains(sysUser.getUserName())) {
+            names.add(sysUser.getUserName());
+        }
+        if (!names.isEmpty()) {
+            List<Company> companies = companyMapper.selectList(new LambdaQueryWrapper<Company>()
+                    .in(Company::getName, names)
+                    .eq(Company::getStatus, 1)
+                    .eq(Company::getDelFlag, "0")
+                    .orderByDesc(Company::getUpdateTime));
+            if (companies.size() == 1) {
+                return companies.get(0);
+            }
+        }
+        return null;
+    }
+
     @Override
     public List<JobFairSignUpVO> selectSignUpList(String jobFairId) {
         return publicJobFairMapper.selectSignUpListByJobFairId(jobFairId);

ruoyi-bussiness/src/main/resources/mapper/rc/PublicJobFairMapper.xml

@@ -54,6 +54,25 @@
         <result property="scale" column="scale"/>
         <result property="industry" column="industry"/>
         <result property="companyType" column="nature"/>
+        <result property="reviewStatus" column="review_status"/>
+        <result property="reviewBy" column="review_by"/>
+        <result property="reviewTime" column="review_time"/>
+        <result property="reviewRemark" column="review_remark"/>
+    </resultMap>
+
+    <resultMap type="com.ruoyi.cms.domain.rc.PublicJobFairCompany" id="PublicJobFairCompanyResult">
+        <result property="id" column="id"/>
+        <result property="jobFairId" column="job_fair_id"/>
+        <result property="companyId" column="company_id"/>
+        <result property="createBy" column="create_by"/>
+        <result property="createTime" column="create_time"/>
+        <result property="updateBy" column="update_by"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="delFlag" column="del_flag"/>
+        <result property="reviewStatus" column="review_status"/>
+        <result property="reviewBy" column="review_by"/>
+        <result property="reviewTime" column="review_time"/>
+        <result property="reviewRemark" column="review_remark"/>
     </resultMap>
 
     <sql id="selectPublicJobFairVo">
@@ -91,17 +110,64 @@
     </select>
 
     <select id="selectCompanyListByJobFairId" resultMap="CompanyVOResult">
-        select pfc.id, pfc.company_id, c.name, c.scale, c.industry, c.nature
+        select pfc.id, pfc.company_id, c.name, c.scale, c.industry, c.nature,
+               pfc.review_status, pfc.review_by, pfc.review_time, pfc.review_remark
         from public_job_fair_company pfc
         left join company c on pfc.company_id = c.company_id
         where pfc.job_fair_id = #{jobFairId} and pfc.del_flag = '0'
         order by pfc.create_time desc
     </select>
 
+    <select id="selectCompanyRelation" resultMap="PublicJobFairCompanyResult">
+        select id, job_fair_id, company_id, create_by, create_time, update_by, update_time,
+               del_flag, review_status, review_by, review_time, review_remark
+        from public_job_fair_company
+        where job_fair_id = #{jobFairId}
+          and company_id = #{companyId}
+          and del_flag = '0'
+        order by create_time desc
+        limit 1
+    </select>
+
+    <select id="selectCompanyRelations" resultMap="PublicJobFairCompanyResult">
+        select id, job_fair_id, company_id, create_by, create_time, update_by, update_time,
+               del_flag, review_status, review_by, review_time, review_remark
+        from public_job_fair_company
+        where company_id = #{companyId}
+          and del_flag = '0'
+          and job_fair_id in
+        <foreach item="jobFairId" collection="jobFairIds" open="(" separator="," close=")">
+            #{jobFairId}
+        </foreach>
+        order by create_time desc
+    </select>
+
+    <select id="selectCompanyRelationById" resultMap="PublicJobFairCompanyResult">
+        select id, job_fair_id, company_id, create_by, create_time, update_by, update_time,
+               del_flag, review_status, review_by, review_time, review_remark
+        from public_job_fair_company
+        where id = #{id} and del_flag = '0'
+    </select>
+
+    <update id="updateCompanyReview">
+        update public_job_fair_company
+        <set>
+            review_status = #{reviewStatus},
+            review_by = #{reviewBy},
+            review_time = #{reviewTime},
+            review_remark = #{reviewRemark},
+            update_by = #{updateBy},
+            update_time = #{updateTime}
+        </set>
+        where id = #{id}
+          and job_fair_id = #{jobFairId}
+          and del_flag = '0'
+    </update>
+
     <select id="selectJobListByJobFairIdAndCompanyId" resultType="com.ruoyi.cms.domain.Job">
-        select j.job_id, j.job_title, j.min_salary, j.max_salary, j.education, j.experience,
+        select pfj.id as fair_relation_id, j.job_id, j.job_title, j.min_salary, j.max_salary, j.education, j.experience,
                j.company_name, j.job_location, j.job_location_area_code, j.posting_date, j.vacancies,
-               j.company_id, j.description, j.job_category
+               j.company_id, j.description, j.job_category, j.job_address
         from public_job_fair_job pfj
         inner join job j on pfj.job_id = j.job_id
         where pfj.job_fair_id = #{jobFairId} and pfj.company_id = #{companyId} and pfj.del_flag = '0' and j.del_flag = '0'
@@ -203,15 +269,27 @@
     </update>
 
     <insert id="insertJobFairCompany">
-        insert into public_job_fair_company (id, job_fair_id, company_id, create_by, create_time, del_flag)
+        insert into public_job_fair_company (
-        values (#{id}, #{jobFairId}, #{companyId}, #{createBy}, #{createTime}, '0')
+            id, job_fair_id, company_id, create_by, create_time, del_flag,
+            review_status, review_by, review_time, review_remark
+        )
+        values (
+            #{id}, #{jobFairId}, #{companyId}, #{createBy}, #{createTime}, '0',
+            #{reviewStatus}, #{reviewBy}, #{reviewTime}, #{reviewRemark}
+        )
     </insert>
 
     <insert id="insertJobFairCompanyBatch">
-        insert into public_job_fair_company (id, job_fair_id, company_id, create_by, create_time, del_flag)
+        insert into public_job_fair_company (
+            id, job_fair_id, company_id, create_by, create_time, del_flag,
+            review_status, review_by, review_time, review_remark
+        )
         values
         <foreach item="item" collection="list" separator=",">
-            (#{item.id}, #{item.jobFairId}, #{item.companyId}, #{item.createBy}, #{item.createTime}, '0')
+            (
+                #{item.id}, #{item.jobFairId}, #{item.companyId}, #{item.createBy}, #{item.createTime}, '0',
+                #{item.reviewStatus}, #{item.reviewBy}, #{item.reviewTime}, #{item.reviewRemark}
+            )
         </foreach>
     </insert>
 
@@ -219,6 +297,14 @@
         update public_job_fair_company set del_flag = '2' where id = #{id}
     </update>
 
+    <update id="deleteJobFairJobsByCompany">
+        update public_job_fair_job
+        set del_flag = '2', update_time = CURRENT_TIMESTAMP
+        where job_fair_id = #{jobFairId}
+          and company_id = #{companyId}
+          and del_flag = '0'
+    </update>
+
     <insert id="insertJobFairJob">
         insert into public_job_fair_job (id, job_fair_id, job_id, company_id, create_by, create_time, del_flag)
         values (#{id}, #{jobFairId}, #{jobId}, #{companyId}, #{createBy}, #{createTime}, '0')
@@ -236,6 +322,22 @@
         update public_job_fair_job set del_flag = '2' where id = #{id}
     </update>
 
+    <select id="selectJobRelation" resultType="com.ruoyi.cms.domain.rc.PublicJobFairJob">
+        select id, job_fair_id, job_id, company_id, create_by, create_time, update_by, update_time, del_flag
+        from public_job_fair_job
+        where job_fair_id = #{jobFairId}
+          and job_id = #{jobId}
+          and del_flag = '0'
+        limit 1
+    </select>
+
+    <select id="selectJobRelationById" resultType="com.ruoyi.cms.domain.rc.PublicJobFairJob">
+        select id, job_fair_id, job_id, company_id, create_by, create_time, update_by, update_time, del_flag
+        from public_job_fair_job
+        where id = #{id}
+          and del_flag = '0'
+    </select>
+
     <resultMap type="com.ruoyi.cms.domain.rc.JobFairSignUpVO" id="SignUpVOResult">
         <result property="id" column="id"/>
         <result property="jobFairId" column="job_fair_id"/>

sql/migration_public_job_fair_enterprise_no_detail.sql

@@ -0,0 +1,21 @@
+-- 公共招聘会：企业角色不能查看管理员详情页
+-- 企业保留列表、报名、岗位维护权限；管理员查询权限不受影响。
+
+BEGIN;
+
+DELETE FROM "shz"."sys_role_menu"
+WHERE "role_id" = 1102
+  AND "menu_id" IN (
+      SELECT "menu_id"
+      FROM "shz"."sys_menu"
+      WHERE "perms" = 'cms:publicJobFair:query'
+  );
+
+COMMIT;
+
+-- 验证：企业角色不应返回 cms:publicJobFair:query
+-- SELECT r.role_id, r.role_name, m.perms
+-- FROM shz.sys_role_menu rm
+-- JOIN shz.sys_role r ON r.role_id = rm.role_id
+-- JOIN shz.sys_menu m ON m.menu_id = rm.menu_id
+-- WHERE r.role_id = 1102 AND m.perms LIKE 'cms:publicJobFair:%';

sql/migration_public_job_fair_review_workflow.sql

@@ -0,0 +1,285 @@
+-- 公共招聘会企业报名审核及企业岗位维护权限
+--
+-- 说明：
+-- 1. 企业在 CMS 报名后进入 0-待审核；管理员审核为 1-通过或 2-驳回。
+-- 2. 历史企业关联没有审核字段，统一按 1-已通过处理，避免历史数据突然不能维护。
+-- 3. 脚本按权限标识和角色关联幂等执行，可重复执行。
+
+BEGIN;
+
+-- 1. 企业报名审核字段
+ALTER TABLE "shz"."public_job_fair_company"
+    ADD COLUMN IF NOT EXISTS "review_status" CHAR(1) DEFAULT '1';
+ALTER TABLE "shz"."public_job_fair_company"
+    ADD COLUMN IF NOT EXISTS "review_by" VARCHAR(64);
+ALTER TABLE "shz"."public_job_fair_company"
+    ADD COLUMN IF NOT EXISTS "review_time" TIMESTAMP;
+ALTER TABLE "shz"."public_job_fair_company"
+    ADD COLUMN IF NOT EXISTS "review_remark" VARCHAR(500);
+
+UPDATE "shz"."public_job_fair_company"
+SET "review_status" = '1'
+WHERE "review_status" IS NULL;
+
+COMMENT ON COLUMN "shz"."public_job_fair_company"."review_status"
+    IS '审核状态 0待审核 1通过 2驳回';
+COMMENT ON COLUMN "shz"."public_job_fair_company"."review_by"
+    IS '审核人';
+COMMENT ON COLUMN "shz"."public_job_fair_company"."review_time"
+    IS '审核时间';
+COMMENT ON COLUMN "shz"."public_job_fair_company"."review_remark"
+    IS '审核意见';
+
+-- 2. 新增 CMS 按钮权限。
+-- 当前线上招聘会列表菜单为 cms:publicJobFair:list；找不到时兼容已知父菜单 2056。
+INSERT INTO "shz"."sys_menu" (
+    "menu_id", "menu_name", "parent_id", "order_num", "path", "component",
+    "query", "route_name", "is_frame", "is_cache", "menu_type", "visible",
+    "status", "perms", "icon", "create_by", "create_time", "update_by",
+    "update_time", "remark"
+)
+SELECT
+    (SELECT COALESCE(MAX("menu_id"), 0) + 1 FROM "shz"."sys_menu"),
+    '企业报名公共招聘会', parent_menu."menu_id", 1, '', '', '', '',
+    1, 0, 'F', '0', '0', 'cms:publicJobFair:signup', '#', 'admin', CURRENT_TIMESTAMP,
+    '', NULL, '企业用户报名公共招聘会'
+FROM (
+    SELECT COALESCE((
+        SELECT "menu_id"
+        FROM "shz"."sys_menu"
+        WHERE "perms" = 'cms:publicJobFair:list'
+        ORDER BY "menu_id"
+        LIMIT 1
+    ), 2056) AS "menu_id"
+) parent_menu
+WHERE NOT EXISTS (
+    SELECT 1 FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:signup'
+);
+
+INSERT INTO "shz"."sys_menu" (
+    "menu_id", "menu_name", "parent_id", "order_num", "path", "component",
+    "query", "route_name", "is_frame", "is_cache", "menu_type", "visible",
+    "status", "perms", "icon", "create_by", "create_time", "update_by",
+    "update_time", "remark"
+)
+SELECT
+    (SELECT COALESCE(MAX("menu_id"), 0) + 1 FROM "shz"."sys_menu"),
+    '企业新增报名岗位', parent_menu."menu_id", 2, '', '', '', '',
+    1, 0, 'F', '0', '0', 'cms:publicJobFair:job:add', '#', 'admin', CURRENT_TIMESTAMP,
+    '', NULL, '审核通过后企业新增报名岗位'
+FROM (
+    SELECT COALESCE((
+        SELECT "menu_id" FROM "shz"."sys_menu"
+        WHERE "perms" = 'cms:publicJobFair:list'
+        ORDER BY "menu_id" LIMIT 1
+    ), 2056) AS "menu_id"
+) parent_menu
+WHERE NOT EXISTS (
+    SELECT 1 FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:job:add'
+);
+
+INSERT INTO "shz"."sys_menu" (
+    "menu_id", "menu_name", "parent_id", "order_num", "path", "component",
+    "query", "route_name", "is_frame", "is_cache", "menu_type", "visible",
+    "status", "perms", "icon", "create_by", "create_time", "update_by",
+    "update_time", "remark"
+)
+SELECT
+    (SELECT COALESCE(MAX("menu_id"), 0) + 1 FROM "shz"."sys_menu"),
+    '企业修改报名岗位', parent_menu."menu_id", 3, '', '', '', '',
+    1, 0, 'F', '0', '0', 'cms:publicJobFair:job:edit', '#', 'admin', CURRENT_TIMESTAMP,
+    '', NULL, '企业修改自己的报名岗位'
+FROM (
+    SELECT COALESCE((
+        SELECT "menu_id" FROM "shz"."sys_menu"
+        WHERE "perms" = 'cms:publicJobFair:list'
+        ORDER BY "menu_id" LIMIT 1
+    ), 2056) AS "menu_id"
+) parent_menu
+WHERE NOT EXISTS (
+    SELECT 1 FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:job:edit'
+);
+
+INSERT INTO "shz"."sys_menu" (
+    "menu_id", "menu_name", "parent_id", "order_num", "path", "component",
+    "query", "route_name", "is_frame", "is_cache", "menu_type", "visible",
+    "status", "perms", "icon", "create_by", "create_time", "update_by",
+    "update_time", "remark"
+)
+SELECT
+    (SELECT COALESCE(MAX("menu_id"), 0) + 1 FROM "shz"."sys_menu"),
+    '企业删除报名岗位', parent_menu."menu_id", 4, '', '', '', '',
+    1, 0, 'F', '0', '0', 'cms:publicJobFair:job:remove', '#', 'admin', CURRENT_TIMESTAMP,
+    '', NULL, '企业删除自己的报名岗位'
+FROM (
+    SELECT COALESCE((
+        SELECT "menu_id" FROM "shz"."sys_menu"
+        WHERE "perms" = 'cms:publicJobFair:list'
+        ORDER BY "menu_id" LIMIT 1
+    ), 2056) AS "menu_id"
+) parent_menu
+WHERE NOT EXISTS (
+    SELECT 1 FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:job:remove'
+);
+
+INSERT INTO "shz"."sys_menu" (
+    "menu_id", "menu_name", "parent_id", "order_num", "path", "component",
+    "query", "route_name", "is_frame", "is_cache", "menu_type", "visible",
+    "status", "perms", "icon", "create_by", "create_time", "update_by",
+    "update_time", "remark"
+)
+SELECT
+    (SELECT COALESCE(MAX("menu_id"), 0) + 1 FROM "shz"."sys_menu"),
+    '审核参会企业', parent_menu."menu_id", 5, '', '', '', '',
+    1, 0, 'F', '0', '0', 'cms:publicJobFair:review', '#', 'admin', CURRENT_TIMESTAMP,
+    '', NULL, '管理员审核招聘会企业报名'
+FROM (
+    SELECT COALESCE((
+        SELECT "menu_id" FROM "shz"."sys_menu"
+        WHERE "perms" = 'cms:publicJobFair:list'
+        ORDER BY "menu_id" LIMIT 1
+    ), 2056) AS "menu_id"
+) parent_menu
+WHERE NOT EXISTS (
+    SELECT 1 FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:review'
+);
+
+INSERT INTO "shz"."sys_menu" (
+    "menu_id", "menu_name", "parent_id", "order_num", "path", "component",
+    "query", "route_name", "is_frame", "is_cache", "menu_type", "visible",
+    "status", "perms", "icon", "create_by", "create_time", "update_by",
+    "update_time", "remark"
+)
+SELECT
+    (SELECT COALESCE(MAX("menu_id"), 0) + 1 FROM "shz"."sys_menu"),
+    '管理员添加参会企业', parent_menu."menu_id", 6, '', '', '', '',
+    1, 0, 'F', '0', '0', 'cms:publicJobFair:company:add', '#', 'admin', CURRENT_TIMESTAMP,
+    '', NULL, '管理员向招聘会添加参会企业'
+FROM (
+    SELECT COALESCE((
+        SELECT "menu_id" FROM "shz"."sys_menu"
+        WHERE "perms" = 'cms:publicJobFair:list'
+        ORDER BY "menu_id" LIMIT 1
+    ), 2056) AS "menu_id"
+) parent_menu
+WHERE NOT EXISTS (
+    SELECT 1 FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:company:add'
+);
+
+INSERT INTO "shz"."sys_menu" (
+    "menu_id", "menu_name", "parent_id", "order_num", "path", "component",
+    "query", "route_name", "is_frame", "is_cache", "menu_type", "visible",
+    "status", "perms", "icon", "create_by", "create_time", "update_by",
+    "update_time", "remark"
+)
+SELECT
+    (SELECT COALESCE(MAX("menu_id"), 0) + 1 FROM "shz"."sys_menu"),
+    '管理员移除参会企业', parent_menu."menu_id", 7, '', '', '', '',
+    1, 0, 'F', '0', '0', 'cms:publicJobFair:company:remove', '#', 'admin', CURRENT_TIMESTAMP,
+    '', NULL, '管理员从招聘会移除参会企业'
+FROM (
+    SELECT COALESCE((
+        SELECT "menu_id" FROM "shz"."sys_menu"
+        WHERE "perms" = 'cms:publicJobFair:list'
+        ORDER BY "menu_id" LIMIT 1
+    ), 2056) AS "menu_id"
+) parent_menu
+WHERE NOT EXISTS (
+    SELECT 1 FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:company:remove'
+);
+
+-- 3. 企业角色（线上 role_id=1102）获得企业端报名和岗位维护权限。
+INSERT INTO "shz"."sys_role_menu" ("role_id", "menu_id")
+SELECT 1102, menu."menu_id"
+FROM "shz"."sys_menu" menu
+WHERE menu."perms" IN (
+    'cms:publicJobFair:signup',
+    'cms:publicJobFair:job:add',
+    'cms:publicJobFair:job:edit',
+    'cms:publicJobFair:job:remove'
+)
+  AND NOT EXISTS (
+      SELECT 1
+      FROM "shz"."sys_role_menu" existing
+      WHERE existing."role_id" = 1102
+        AND existing."menu_id" = menu."menu_id"
+  );
+
+-- 管理员同时获得 CMS 详情页的企业/岗位维护权限；企业角色虽有同名岗位权限，
+-- 但 Service 层会拒绝其调用管理员关联接口。
+INSERT INTO "shz"."sys_role_menu" ("role_id", "menu_id")
+SELECT DISTINCT admin_role."role_id", menu."menu_id"
+FROM (
+    SELECT DISTINCT role_menu."role_id"
+    FROM "shz"."sys_role_menu" role_menu
+    JOIN "shz"."sys_menu" list_menu
+      ON list_menu."menu_id" = role_menu."menu_id"
+     AND list_menu."perms" = 'cms:publicJobFair:list'
+    WHERE role_menu."role_id" <> 1102
+    UNION
+    SELECT "role_id"
+    FROM "shz"."sys_role"
+    WHERE "role_name" IN ('管理员', '超级管理员')
+) admin_role
+JOIN "shz"."sys_menu" menu
+  ON menu."perms" IN (
+      'cms:publicJobFair:company:add',
+      'cms:publicJobFair:company:remove',
+      'cms:publicJobFair:job:add',
+      'cms:publicJobFair:job:remove'
+  )
+WHERE NOT EXISTS (
+    SELECT 1
+    FROM "shz"."sys_role_menu" existing
+    WHERE existing."role_id" = admin_role."role_id"
+      AND existing."menu_id" = menu."menu_id"
+);
+
+-- 5. 管理员角色获得企业审核权限：包括已有公共招聘会列表权限的非企业角色
+--    （当前线上为网格员 1103）以及超级管理员。企业角色不授予审核权限。
+INSERT INTO "shz"."sys_role_menu" ("role_id", "menu_id")
+SELECT DISTINCT admin_role."role_id", review_menu."menu_id"
+FROM (
+    SELECT DISTINCT role_menu."role_id"
+    FROM "shz"."sys_role_menu" role_menu
+    JOIN "shz"."sys_menu" list_menu
+      ON list_menu."menu_id" = role_menu."menu_id"
+     AND list_menu."perms" = 'cms:publicJobFair:list'
+    WHERE role_menu."role_id" <> 1102
+    UNION
+    SELECT "role_id"
+    FROM "shz"."sys_role"
+    WHERE "role_name" IN ('管理员', '超级管理员')
+) admin_role
+CROSS JOIN (
+    SELECT "menu_id"
+    FROM "shz"."sys_menu"
+    WHERE "perms" = 'cms:publicJobFair:review'
+    ORDER BY "menu_id"
+    LIMIT 1
+) review_menu
+WHERE NOT EXISTS (
+    SELECT 1
+    FROM "shz"."sys_role_menu" existing
+    WHERE existing."role_id" = admin_role."role_id"
+      AND existing."menu_id" = review_menu."menu_id"
+);
+
+COMMIT;
+
+-- 验证：
+-- SELECT column_name, data_type, column_default
+-- FROM information_schema.columns
+-- WHERE table_schema = 'shz' AND table_name = 'public_job_fair_company'
+-- ORDER BY ordinal_position;
+-- SELECT menu_id, menu_name, perms
+-- FROM shz.sys_menu
+-- WHERE perms LIKE 'cms:publicJobFair:%'
+-- ORDER BY menu_id;

sql/public_job_fair.sql

@@ -60,10 +60,18 @@ CREATE TABLE "public_job_fair_company" (
     "create_time" TIMESTAMP,
     "update_by" VARCHAR(64),
     "update_time" TIMESTAMP,
-    "del_flag" CHAR(1) DEFAULT '0'
+    "del_flag" CHAR(1) DEFAULT '0',
+    "review_status" CHAR(1) DEFAULT '1',
+    "review_by" VARCHAR(64),
+    "review_time" TIMESTAMP,
+    "review_remark" VARCHAR(500)
 );
 
 COMMENT ON TABLE "public_job_fair_company" IS '招聘会-企业关联表';
+COMMENT ON COLUMN "public_job_fair_company"."review_status" IS '审核状态 0待审核 1通过 2驳回';
+COMMENT ON COLUMN "public_job_fair_company"."review_by" IS '审核人';
+COMMENT ON COLUMN "public_job_fair_company"."review_time" IS '审核时间';
+COMMENT ON COLUMN "public_job_fair_company"."review_remark" IS '审核意见';
 
 -- 招聘会-岗位关联表
 CREATE TABLE "public_job_fair_job" (