AI接入逻辑完善

vetti-hotakes/src/main/java/com/vetti/hotake/service/impl/HotakeCvInfoServiceImpl.java

@@ -14,8 +14,10 @@ import com.vetti.common.utils.readFile.FileContentUtil;
 import com.vetti.hotake.domain.HotakeCvInfo;
 import com.vetti.hotake.domain.HotakeProblemBaseInfo;
 import com.vetti.hotake.domain.dto.HotakeCvInfoDto;
+import com.vetti.hotake.domain.dto.HotakeCvOptimizeDto;
 import com.vetti.hotake.domain.dto.VcDto.*;
 import com.vetti.hotake.mapper.HotakeCvInfoMapper;
+import com.vetti.hotake.service.IHotakeAiCommonToolsService;
 import com.vetti.hotake.service.IHotakeCvInfoService;
 import com.vetti.hotake.service.IHotakeProblemBaseInfoService;
 import io.minio.GetObjectArgs;
@@ -60,6 +62,9 @@ public class HotakeCvInfoServiceImpl extends BaseServiceImpl implements IHotakeC
     @Autowired
     private IHotakeProblemBaseInfoService hotakeProblemBaseInfoService;
 
+    @Autowired
+    private IHotakeAiCommonToolsService aiCommonToolsService;
+
     /**
      * 查询简历信息
      *
@@ -74,7 +79,23 @@ public class HotakeCvInfoServiceImpl extends BaseServiceImpl implements IHotakeC
             HotakeCvInfoDto cvInfoDto = JSONUtil.toBean(cvInfo.getCvTemplateJson(),HotakeCvInfoDto.class);
             cvInfo.setCvInfoDto(cvInfoDto);
         }
-
+        if(StrUtil.isNotEmpty(cvInfo.getCvOptimizeJson())){
+            //解析优化简历
+            HotakeCvOptimizeDto cvOptimizeDto =  JSONUtil.toBean(cvInfo.getCvOptimizeJson(),HotakeCvOptimizeDto.class);
+            if(cvOptimizeDto != null){
+                cvInfo.setCvOptimizeDto(cvOptimizeDto);
+                if(cvOptimizeDto.getTextCorrections() != null && CollectionUtil.isNotEmpty(cvOptimizeDto.getTextCorrections().getFormattingIssues())){
+                    cvInfo.setTextCorrectionsNums(cvOptimizeDto.getTextCorrections().getFormattingIssues().size());
+                }else{
+                    cvInfo.setTextCorrectionsNums(0);
+                }
+                if(cvOptimizeDto.getLogicCorrections() != null && CollectionUtil.isNotEmpty(cvOptimizeDto.getLogicCorrections().getCareerProgressionDtos())){
+                    cvInfo.setLogicCorrectionsNum(cvOptimizeDto.getTextCorrections().getFormattingIssues().size());
+                }else{
+                    cvInfo.setLogicCorrectionsNum(0);
+                }
+            }
+        }
         HotakeProblemBaseInfo query = new HotakeProblemBaseInfo();
         query.setCvId(id);
         List<HotakeProblemBaseInfo> problemBaseInfoList = hotakeProblemBaseInfoService.selectHotakeProblemBaseInfoList(query);
@@ -264,25 +285,42 @@ public class HotakeCvInfoServiceImpl extends BaseServiceImpl implements IHotakeC
                 //对简历数据进行处理生成相应的题库数据
                 HotakeProblemBaseInfo problemBaseInfo = handleHotakeCvInfo(cvInfoDto,hotakeCvInfo.getId());
                 cvInfo.setProblemBaseInfo(problemBaseInfo);
-                //生成对应的简历评分
-                String resultMsg = handleHotakeCvInfoScore(cvInfoDto);
-                cvInfo.setCvScore(resultMsg);
-                cvInfo.setExperience(cvInfoDto.getExperienceYear());
-                //分数解析
-                String[] strs = resultMsg.split("\n");
-                if(strs != null && strs.length > 0){
-                    String score = strs[0].replaceAll("Score:","").trim();
-                    String[] scores = score.split("/");
-                    if(scores != null && scores.length > 0){
-                        cvInfo.setAiMatchScore(scores[0]);
-                        try{
-                            cvInfo.setAiMatchScorePercentage(String.valueOf(new BigDecimal(scores[0]).
-                                    divide(new BigDecimal(5)).setScale(2,4)));
-                        }catch (Exception e){e.printStackTrace();}
+                //解析优化简历
+                HotakeCvOptimizeDto cvOptimizeDto =  aiCommonToolsService.getResumeAnalysisOptimizer(contents);
 
+                if(cvOptimizeDto != null){
+                    cvInfo.setCvOptimizeJson(JSONUtil.toJsonStr(cvOptimizeDto));
+                    if(cvOptimizeDto.getTextCorrections() != null && CollectionUtil.isNotEmpty(cvOptimizeDto.getTextCorrections().getFormattingIssues())){
+                        cvInfo.setTextCorrectionsNums(cvOptimizeDto.getTextCorrections().getFormattingIssues().size());
+                    }else{
+                        cvInfo.setTextCorrectionsNums(0);
                     }
+                    if(cvOptimizeDto.getLogicCorrections() != null && CollectionUtil.isNotEmpty(cvOptimizeDto.getLogicCorrections().getCareerProgressionDtos())){
+                        cvInfo.setLogicCorrectionsNum(cvOptimizeDto.getTextCorrections().getFormattingIssues().size());
+                    }else{
+                        cvInfo.setLogicCorrectionsNum(0);
+                    }
+                    cvInfo.setCvOptimizeDto(cvOptimizeDto);
                 }
 
+//                //生成对应的简历评分
+//                String resultMsg = handleHotakeCvInfoScore(cvInfoDto);
+//                cvInfo.setCvScore(resultMsg);
+                cvInfo.setExperience(cvInfoDto.getExperienceYear());
+                //分数解析
+//                String[] strs = resultMsg.split("\n");
+//                if(strs != null && strs.length > 0){
+//                    String score = strs[0].replaceAll("Score:","").trim();
+//                    String[] scores = score.split("/");
+//                    if(scores != null && scores.length > 0){
+//                        cvInfo.setAiMatchScore(scores[0]);
+//                        try{
+//                            cvInfo.setAiMatchScorePercentage(String.valueOf(new BigDecimal(scores[0]).
+//                                    divide(new BigDecimal(5)).setScale(2,4)));
+//                        }catch (Exception e){e.printStackTrace();}
+//
+//                    }
+//                }
                 cvInfo.setCvTemplateJson(JSONUtil.toJsonStr(cvInfoDto));
                 fill(FillTypeEnum.UPDATE.getCode(), cvInfo);
                 hotakeCvInfoMapper.updateHotakeCvInfo(cvInfo);

vetti-hotakes/src/main/java/com/vetti/hotake/service/impl/HotakeInitScreQuestionsReplyRecordInfoServiceImpl.java

@@ -22,11 +22,14 @@ import com.vetti.common.utils.SecurityUtils;
 import com.vetti.common.utils.readFile.FileContentUtil;
 import com.vetti.hotake.domain.*;
 import com.vetti.hotake.domain.dto.HotakeCvInfoDto;
+import com.vetti.hotake.domain.dto.HotakeInitialQuestionEliminationScoreDto;
 import com.vetti.hotake.domain.dto.VcDto.*;
 import com.vetti.hotake.domain.vo.HotakeInitScreQuestionsReplyRecordInfoVo;
+import com.vetti.hotake.domain.vo.HotakeInitialQuestionEliminationScoreVo;
 import com.vetti.hotake.mapper.HotakeCvInfoMapper;
 import com.vetti.hotake.mapper.HotakeRolesApplyInfoMapper;
 import com.vetti.hotake.mapper.HotakeRolesInfoMapper;
+import com.vetti.hotake.service.IHotakeAiCommonToolsService;
 import io.minio.GetObjectArgs;
 import io.minio.MinioClient;
 import lombok.extern.slf4j.Slf4j;
@@ -60,6 +63,9 @@ public class HotakeInitScreQuestionsReplyRecordInfoServiceImpl extends BaseServi
     @Autowired
     private HotakeCvInfoMapper hotakeCvInfoMapper;
 
+    @Autowired
+    private IHotakeAiCommonToolsService aiCommonToolsService;
+
     @Autowired
     private MinioClient minioClient;
 
@@ -180,62 +186,70 @@ public class HotakeInitScreQuestionsReplyRecordInfoServiceImpl extends BaseServi
         HotakeRolesApplyInfo applyInfo = hotakeRolesApplyInfoMapper.selectHotakeRolesApplyInfoById(initScreQuestionsReplyRecordInfoVo.getRoleApplyId());
         if (applyInfo != null) {
             HotakeRolesInfo rolesInf = hotakeRolesInfoMapper.selectHotakeRolesInfoById(initScreQuestionsReplyRecordInfoVo.getRoleId());
+            //获取初步筛选问题评分
+            HotakeInitialQuestionEliminationScoreVo eliminationScoreVo = new HotakeInitialQuestionEliminationScoreVo();
+            eliminationScoreVo.setRoleId(rolesInf.getId());
+            eliminationScoreVo.setRoleName(rolesInf.getRoleName());
+            eliminationScoreVo.setInitScreQuestionsReplyRecordInfoList(initScreQuestionsReplyRecordInfoVo.getInitScreQuestionsReplyRecordInfoList());
+            HotakeInitialQuestionEliminationScoreDto eliminationScoreDto = aiCommonToolsService.getInitialQuestionEliminationScore(eliminationScoreVo);
+
+
             //查询候选人的当前最新简历信息
-            HotakeCvInfo queryCv = new HotakeCvInfo();
-            queryCv.setUserId(SecurityUtils.getUserId());
-            queryCv.setCvFileType("cv");
-            List<HotakeCvInfo> cvInfos = hotakeCvInfoMapper.selectHotakeCvInfoList(queryCv);
-            HotakeCvInfo cvInfo = null;
-            if(CollectionUtil.isNotEmpty(cvInfos)) {
-                cvInfo = cvInfos.get(0);
-            }
-            //解析简历内容以及获取简历对应的评分数据
-            log.info("开始处理简历");
-            try {
-                InputStream inputStream = minioClient.getObject(
-                        GetObjectArgs.builder()
-                                .bucket(MinioBucketNameEnum.CV.getCode())
-                                .object(applyInfo.getCvFile())
-                                .build());
-                String contents = FileContentUtil.readFileContent(inputStream, applyInfo.getCvFileSuffix());
-                log.info("简历信息:{}", contents);
-                //验证文件内容是否改变,如果未改变不进行模型解析直接返回原有结果
-                String md5Hash = MD5.create().digestHex16(contents);
-                String scoreStr = "";
-                if (StrUtil.isNotEmpty(md5Hash) && cvInfo != null && md5Hash.equals(cvInfo.getCvMd5())) {
-                    //直接获取简历表中的简历解析的详细数据
-                    applyInfo.setCvScore(cvInfo.getCvScore());
-                    applyInfo.setCvTemplateJson(cvInfo.getCvTemplateJson());
-                    fill(FillTypeEnum.UPDATE.getCode(), applyInfo);
-                    applyInfo.setCvMd5(md5Hash);
-                    applyInfo.setExperience(cvInfo.getExperience());
-                    scoreStr = cvInfo.getCvScore();
-                }else{
-                    //生成简历模版数据信息
-                    HotakeCvInfoDto cvInfoDto = handleAnalysisCvInfo(contents);
-                    //生成对应的简历评分
-                    String resultMsg = handleHotakeCvInfoScore(cvInfoDto);
-                    applyInfo.setCvScore(resultMsg);
-                    applyInfo.setCvTemplateJson(JSONUtil.toJsonStr(cvInfoDto));
-                    fill(FillTypeEnum.UPDATE.getCode(), cvInfo);
-                    applyInfo.setCvMd5(md5Hash);
-                    applyInfo.setExperience(cvInfoDto.getExperienceYear());
-                    scoreStr = resultMsg;
-                }
+//            HotakeCvInfo queryCv = new HotakeCvInfo();
+//            queryCv.setUserId(SecurityUtils.getUserId());
+//            queryCv.setCvFileType("cv");
+//            List<HotakeCvInfo> cvInfos = hotakeCvInfoMapper.selectHotakeCvInfoList(queryCv);
+//            HotakeCvInfo cvInfo = null;
+//            if(CollectionUtil.isNotEmpty(cvInfos)) {
+//                cvInfo = cvInfos.get(0);
+//            }
+//            //解析简历内容以及获取简历对应的评分数据
+//            log.info("开始处理简历");
+//            try {
+//                InputStream inputStream = minioClient.getObject(
+//                        GetObjectArgs.builder()
+//                                .bucket(MinioBucketNameEnum.CV.getCode())
+//                                .object(applyInfo.getCvFile())
+//                                .build());
+//                String contents = FileContentUtil.readFileContent(inputStream, applyInfo.getCvFileSuffix());
+//                log.info("简历信息:{}", contents);
+//                //验证文件内容是否改变,如果未改变不进行模型解析直接返回原有结果
+//                String md5Hash = MD5.create().digestHex16(contents);
+//                String scoreStr = "";
+//                if (StrUtil.isNotEmpty(md5Hash) && cvInfo != null && md5Hash.equals(cvInfo.getCvMd5())) {
+//                    //直接获取简历表中的简历解析的详细数据
+//                    applyInfo.setCvScore(cvInfo.getCvScore());
+//                    applyInfo.setCvTemplateJson(cvInfo.getCvTemplateJson());
+//                    fill(FillTypeEnum.UPDATE.getCode(), applyInfo);
+//                    applyInfo.setCvMd5(md5Hash);
+//                    applyInfo.setExperience(cvInfo.getExperience());
+//                    scoreStr = cvInfo.getCvScore();
+//                }else{
+//                    //生成简历模版数据信息
+//                    HotakeCvInfoDto cvInfoDto = handleAnalysisCvInfo(contents);
+//                    //生成对应的简历评分
+//                    String resultMsg = handleHotakeCvInfoScore(cvInfoDto);
+//                    applyInfo.setCvScore(resultMsg);
+//                    applyInfo.setCvTemplateJson(JSONUtil.toJsonStr(cvInfoDto));
+//                    fill(FillTypeEnum.UPDATE.getCode(), cvInfo);
+//                    applyInfo.setCvMd5(md5Hash);
+//                    applyInfo.setExperience(cvInfoDto.getExperienceYear());
+//                    scoreStr = resultMsg;
+//                }
                 //更新岗位申请数据记录--根据评分进行计算
                 //分数解析
-                String[] strs = scoreStr.split("\n");
-                if(strs != null && strs.length > 0){
-                    String score = strs[0].replaceAll("Score:","").trim();
-                    String[] scores = score.split("/");
-                    if(scores != null && scores.length > 0){
-                        applyInfo.setAiMatchScore(scores[0]);
+//                String[] strs = scoreStr.split("\n");
+//                if(strs != null && strs.length > 0){
+//                    String score = strs[0].replaceAll("Score:","").trim();
+//                    String[] scores = score.split("/");
+//                    if(scores != null && scores.length > 0){
+//                        applyInfo.setAiMatchScore(scores[0]);
                         try{
-                            applyInfo.setAiMatchScorePercentage(new BigDecimal(scores[0]).
-                                    divide(new BigDecimal(5)).setScale(2,4));
+                            applyInfo.setAiMatchScorePercentage(new BigDecimal(eliminationScoreDto.getScore()).
+                                    divide(new BigDecimal(100)).setScale(2,4));
                         }catch (Exception e){e.printStackTrace();}
-                    }
-                }
+//                    }
+//                }
                 if(applyInfo.getAiMatchScorePercentage() != null){
                     if(applyInfo.getAiMatchScorePercentage().compareTo(new BigDecimal(0.85)) >= 0){
                         applyInfo.setCandidateStatus(CandidateStatusEnum.HOT.getCode());
@@ -252,9 +266,9 @@ public class HotakeInitScreQuestionsReplyRecordInfoServiceImpl extends BaseServi
                 applyInfo.setRecruiterId(rolesInf.getRecruiterId());
                 applyInfo.setStage(StageEnum.APPLIED.getCode());
                 hotakeRolesApplyInfoMapper.updateHotakeRolesApplyInfo(applyInfo);
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
+//            } catch (Exception e) {
+//                e.printStackTrace();
+//            }
             return 0;
         }
         return 0;

vetti-hotakes/src/main/java/com/vetti/hotake/service/impl/HotakeInitialScreeningQuestionsInfoServiceImpl.java

@@ -8,6 +8,7 @@ import com.vetti.common.enums.FillTypeEnum;
 import com.vetti.common.utils.SecurityUtils;
 import com.vetti.hotake.domain.HotakeInitialScreeningQuestionsInfo;
 import com.vetti.hotake.domain.dto.AnswerOptionsDto;
+import com.vetti.hotake.domain.vo.HotakeInitialScreeningQuestionsInfoVo;
 import com.vetti.hotake.mapper.HotakeInitialScreeningQuestionsInfoMapper;
 import com.vetti.hotake.service.IHotakeInitialScreeningQuestionsInfoService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -128,12 +129,26 @@ public class HotakeInitialScreeningQuestionsInfoServiceImpl extends BaseServiceI
     /**
      * 批量新增初步筛选问题信息
      *
-     * @param hotakeInitialScreeningQuestionsInfoList 初步筛选问题信息列表
+     * @param questionsInfoVo 初步筛选问题信息
      * @return 结果
      */
     @Transactional(rollbackFor=Exception.class)
     @Override
-    public int batchInsertHotakeInitialScreeningQuestionsInfo(List<HotakeInitialScreeningQuestionsInfo> hotakeInitialScreeningQuestionsInfoList){
-        return hotakeInitialScreeningQuestionsInfoMapper.batchInsertHotakeInitialScreeningQuestionsInfo(hotakeInitialScreeningQuestionsInfoList);
+    public void batchInsertHotakeInitialScreeningQuestionsInfo(HotakeInitialScreeningQuestionsInfoVo questionsInfoVo){
+        //先删除之前的初步筛选问题数据
+//        hotakeInitialScreeningQuestionsInfoMapper.deleteHotakeInitialScreeningQuestionsInfoByRoleId(questionsInfoVo.getRoleId());
+        if(CollectionUtil.isNotEmpty(questionsInfoVo.getQuestionsInfoList())){
+            for(HotakeInitialScreeningQuestionsInfo questionsInfo : questionsInfoVo.getQuestionsInfoList()){
+                fill(FillTypeEnum.INSERT.getCode(), questionsInfo);
+                questionsInfo.setRecruiterId(SecurityUtils.getUserId());
+                if(CollectionUtil.isNotEmpty(questionsInfo.getAnswerOptionsList())){
+                    questionsInfo.setAnswerOptions(JSONUtil.toJsonStr(questionsInfo.getAnswerOptionsList()));
+                }else {
+                    questionsInfo.setAnswerOptions("");
+                }
+                questionsInfo.setRoleId(questionsInfoVo.getRoleId());
+            }
+            hotakeInitialScreeningQuestionsInfoMapper.batchInsertHotakeInitialScreeningQuestionsInfo(questionsInfoVo.getQuestionsInfoList());
+        }
     }
 }

vetti-hotakes/src/main/java/com/vetti/hotake/service/impl/HotakeMeetingCalendarInfoServiceImpl.java

@@ -1,5 +1,7 @@
 package com.vetti.hotake.service.impl;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -10,9 +12,11 @@ import com.vetti.common.core.service.BaseServiceImpl;
 import com.vetti.common.enums.FillTypeEnum;
 import com.vetti.common.enums.MeetingCalendarStatus;
 import com.vetti.common.enums.StageEnum;
+import com.vetti.common.utils.SecurityUtils;
 import com.vetti.hotake.domain.HotakeMeetingCalendarDetail;
 import com.vetti.hotake.domain.HotakeRolesApplyInfo;
 import com.vetti.hotake.domain.HotakeRolesInfo;
+import com.vetti.hotake.domain.dto.HotakeMeetingCalendarDataDto;
 import com.vetti.hotake.domain.vo.HotakeMeetingCalendarInfoVo;
 import com.vetti.hotake.domain.vo.HotakeMeetingCalendarVo;
 import com.vetti.hotake.mapper.HotakeMeetingCalendarDetailMapper;
@@ -160,6 +164,69 @@ public class HotakeMeetingCalendarInfoServiceImpl extends BaseServiceImpl implem
         return calendarInfos;
     }
 
+    /**
+     * 查询候选者相关的会议记录数据
+     * @param hotakeMeetingCalendarInfo 会议日历记录主
+     * @return
+     */
+    @Override
+    public List<HotakeMeetingCalendarInfo> selectHotakeMeetingCalendarInfoCandidateList(HotakeMeetingCalendarInfo hotakeMeetingCalendarInfo) {
+        //根据候选者查询会议明细数据
+        HotakeMeetingCalendarDetail queryCalendarDetail = new HotakeMeetingCalendarDetail();
+        queryCalendarDetail.setCandidateId(SecurityUtils.getUserId());
+        List<HotakeMeetingCalendarDetail> calendarDetailList = hotakeMeetingCalendarDetailMapper.selectHotakeMeetingCalendarDetailList(queryCalendarDetail);
+
+        if(CollectionUtil.isNotEmpty(calendarDetailList)) {
+            //查询明细中的会议主表ID
+            List<Long> meetingIds = calendarDetailList.stream().map(HotakeMeetingCalendarDetail::getMeetingId).collect(Collectors.toList());
+            hotakeMeetingCalendarInfo.setMeetingIds(meetingIds);
+            List<HotakeMeetingCalendarInfo> calendarInfos = hotakeMeetingCalendarInfoMapper.selectHotakeMeetingCalendarInfoList(hotakeMeetingCalendarInfo);
+            if (CollectionUtil.isNotEmpty(calendarInfos)) {
+                //查询岗位数据
+                HotakeRolesInfo query = new HotakeRolesInfo();
+                List<HotakeRolesInfo> rolesInfoList = hotakeRolesInfoMapper.selectHotakeRolesInfoList(query);
+
+                //查询岗位数据
+                HotakeRolesApplyInfo queryApply = new HotakeRolesApplyInfo();
+                List<HotakeRolesApplyInfo> applyInfoList = hotakeRolesApplyInfoMapper.selectHotakeRolesApplyInfoList(queryApply);
+                //获取对应的参会人员数据
+                HotakeMeetingCalendarDetail queryDetail = new HotakeMeetingCalendarDetail();
+                List<HotakeMeetingCalendarDetail> detailList = calendarDetailService.selectHotakeMeetingCalendarDetailList(queryDetail);
+                if (CollectionUtil.isNotEmpty(detailList)) {
+                    Map<Long, List<HotakeMeetingCalendarDetail>> mapDetailList = detailList.stream().collect(Collectors.groupingBy(HotakeMeetingCalendarDetail::getMeetingId));
+                    SysUser queryUser = new SysUser();
+                    List<SysUser> userList = userService.selectUserList(queryUser);
+                    for (HotakeMeetingCalendarInfo calendarInfo : calendarInfos) {
+                        List<HotakeMeetingCalendarDetail> calendarDetails = mapDetailList.get(calendarInfo.getId());
+                        for (HotakeMeetingCalendarDetail detail : calendarDetails) {
+                            List<SysUser> users = userList.stream().filter(e -> e.getUserId() == detail.getCandidateId()).collect(Collectors.toList());
+                            if (CollectionUtil.isNotEmpty(users)) {
+                                detail.setCandidateUser(users.get(0));
+                            }
+                        }
+                        calendarInfo.setCalendarDetails(calendarDetails);
+                        //返回岗位数据信息
+                        List<HotakeRolesApplyInfo> applyInfos = applyInfoList.stream().filter(e->e.getId().longValue() == calendarInfo.getRoleApplyId().longValue()).toList();
+                        if(CollectionUtil.isNotEmpty(applyInfos)) {
+                            HotakeRolesApplyInfo applyInfo = applyInfos.get(0);
+                            List<HotakeRolesInfo> rolesInfos = rolesInfoList.stream().filter(e->e.getId().longValue() == applyInfo.getRoleId().longValue()).toList();
+                            if(CollectionUtil.isNotEmpty(rolesInfos)) {
+                                HotakeRolesInfo rolesInfo = rolesInfos.get(0);
+                                calendarInfo.setRolesInfo(rolesInfo);
+                            }
+                        }
+                    }
+                }
+            }
+            return calendarInfos;
+        }else{
+            return new ArrayList<>();
+        }
+
+
+
+    }
+
     /**
      * 新增会议日历记录主
      *
@@ -262,7 +329,7 @@ public class HotakeMeetingCalendarInfoServiceImpl extends BaseServiceImpl implem
                 calendarInfo.setMeetingName(meetingName);
                 //保存主表数据
                 fill(FillTypeEnum.INSERT.getCode(), calendarInfo);
-                insertHotakeMeetingCalendarInfo(calendarInfo);
+                hotakeMeetingCalendarInfoMapper.insertHotakeMeetingCalendarInfo(calendarInfo);
                 //保存明细数据
                 HotakeMeetingCalendarDetail hotakeMeetingCalendarDetail = new HotakeMeetingCalendarDetail();
                 hotakeMeetingCalendarDetail.setMeetingId(calendarInfo.getId());
@@ -279,4 +346,41 @@ public class HotakeMeetingCalendarInfoServiceImpl extends BaseServiceImpl implem
             }
         }
     }
+
+    /**
+     * 查询当前候选者会议日历数据
+     * @return
+     */
+    @Override
+    public List<HotakeMeetingCalendarDataDto> selectHotakeMeetingCalendarDataDtoList() {
+        List<HotakeMeetingCalendarDataDto> dataDtos = new ArrayList<>();
+        //根据候选者查询会议明细数据
+        HotakeMeetingCalendarDetail queryCalendarDetail = new HotakeMeetingCalendarDetail();
+        queryCalendarDetail.setCandidateId(SecurityUtils.getUserId());
+        List<HotakeMeetingCalendarDetail> calendarDetailList = hotakeMeetingCalendarDetailMapper.selectHotakeMeetingCalendarDetailList(queryCalendarDetail);
+        if(CollectionUtil.isNotEmpty(calendarDetailList)) {
+            HotakeMeetingCalendarInfo queryCalendarInfo = new HotakeMeetingCalendarInfo();
+            //查询明细中的会议主表ID
+            List<Long> meetingIds = calendarDetailList.stream().map(HotakeMeetingCalendarDetail::getMeetingId).collect(Collectors.toList());
+            queryCalendarInfo.setMeetingIds(meetingIds);
+            List<HotakeMeetingCalendarInfo> calendarInfos = hotakeMeetingCalendarInfoMapper.selectHotakeMeetingCalendarInfoList(queryCalendarInfo);
+            if (CollectionUtil.isNotEmpty(calendarInfos)) {
+                //获取对应的参会人员数据
+                Map<String,List<HotakeMeetingCalendarInfo>> mapCalendarInfo = calendarInfos.stream().collect(Collectors.groupingBy(HotakeMeetingCalendarInfo::getMeetingDate));
+                if(mapCalendarInfo != null) {
+                    for(String key : mapCalendarInfo.keySet()) {
+                        List<HotakeMeetingCalendarInfo> calendarInfoList = mapCalendarInfo.get(key);
+                        HotakeMeetingCalendarDataDto dataDto = new HotakeMeetingCalendarDataDto();
+                        dataDto.setMeetingDate(key);
+                        dataDto.setMeetingFlag("1");
+                        dataDto.setNums(calendarInfoList.size());
+                        dataDtos.add(dataDto);
+                    }
+                }
+            }
+            return dataDtos;
+        }else{
+            return new ArrayList<>();
+        }
+    }
 }