api/src/main/java/com/xjrsoft/module/oa/service/impl/WfMeetingApplyServiceImpl.java

package com.xjrsoft.module.oa.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.enums.MeetingTypeEnum;
import com.xjrsoft.common.page.ConventPage;
import com.xjrsoft.common.page.PageOutput;
import com.xjrsoft.common.utils.LocalDateTimeUtil;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseOfficeBuild;
import com.xjrsoft.module.ledger.vo.WorkflowRecordVo;
import com.xjrsoft.module.oa.dto.*;
import com.xjrsoft.module.oa.entity.*;
import com.xjrsoft.module.oa.mapper.MeetingConfereeMapper;
import com.xjrsoft.module.oa.mapper.MeetingConfereeOpinionMapper;
import com.xjrsoft.module.oa.mapper.MeetingRoomMapper;
import com.xjrsoft.module.oa.mapper.WfMeetingApplyMapper;
import com.xjrsoft.module.oa.service.IWfMeetingApplyService;
import com.xjrsoft.module.oa.vo.*;
import com.xjrsoft.module.organization.dto.WeChatSendMessageDto;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.organization.service.IUserService;
import com.xjrsoft.module.organization.service.IWeChatService;
import com.xjrsoft.module.schedule.vo.TodayScheduleVo;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.system.entity.File;
import com.xjrsoft.module.system.mapper.FileMapper;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.workflow.entity.WorkflowExtra;
import com.xjrsoft.module.workflow.entity.WorkflowFormRelation;
import com.xjrsoft.module.workflow.entity.WorkflowRecord;
import com.xjrsoft.module.workflow.mapper.WorkflowExtraMapper;
import com.xjrsoft.module.workflow.mapper.WorkflowFormRelationMapper;
import com.xjrsoft.module.workflow.mapper.WorkflowRecordMapper;
import com.xjrsoft.module.workflow.service.IWorkflowExtraService;
import lombok.AllArgsConstructor;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.camunda.bpm.engine.history.HistoricProcessInstance;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @title: 物品申购
 * @Author dzx
 * @Date: 2024-02-19
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class WfMeetingApplyServiceImpl extends MPJBaseServiceImpl<WfMeetingApplyMapper, WfMeetingApply> implements IWfMeetingApplyService {

    private final IUserService userService;

    private final IWeChatService weChatService;

    private final IWorkflowExtraService extraService;

    private final MeetingRoomMapper meetingRoomMapper;

    private final WorkflowFormRelationMapper workflowFormRelationMapper;

    private final MeetingConfereeMapper meetingConfereeMapper;

    private final MeetingConfereeOpinionMapper meetingConfereeOpinionMapper;

    private final WorkflowRecordMapper workflowRecordMapper;

    private final WorkflowExtraMapper workflowExtraMapper;

    private final FileMapper fileMapper;

    @Override
    public List<MeetingRoomListVo> listMeetingRoom(MeetingRoomListDto dto) {
        List<MeetingRoomListVo> usableResult = new ArrayList<>();
        if (ObjectUtils.isEmpty(dto.getMeetingApplyDate())
                || ObjectUtils.isEmpty(dto.getMeetingApplyS())
                || ObjectUtils.isEmpty(dto.getMeetingApplyE())
        ) {
            return usableResult;
        }

        // 处理时间
        LocalDate meetingApplyDate = LocalDate.parse(dto.getMeetingApplyDate());
        LocalTime startTime = LocalTime.parse(dto.getMeetingApplyS());
        LocalTime endTime = LocalTime.parse(dto.getMeetingApplyE());

        // 获取所有的教室
        MPJLambdaWrapper<MeetingRoom> meetingRoomMPJLambdaWrapper = new MPJLambdaWrapper<>();
        meetingRoomMPJLambdaWrapper
                .select(MeetingRoom::getId)
                .selectAs(MeetingRoom::getName, MeetingRoomListVo::getName)
                .selectAs(MeetingRoom::getFloorNum, MeetingRoomListVo::getFloorNum)
                .selectAs(MeetingRoom::getCapacity, MeetingRoomListVo::getCapacity)
                .selectAs(BaseOfficeBuild::getName, MeetingRoomListVo::getOfficeBuildIdCn)
                .leftJoin(BaseOfficeBuild.class, BaseOfficeBuild::getId, MeetingRoom::getOfficeBuildId)
                .like(StringUtils.isNotEmpty(dto.getName()), MeetingRoom::getName, dto.getName())
                .like(StringUtils.isNotEmpty(dto.getOfficeBuildIdCn()), BaseOfficeBuild::getName, dto.getOfficeBuildIdCn())
                .eq(MeetingRoom::getStatus, 1)
        ;
        List<MeetingRoomListVo> result = meetingRoomMapper.selectJoinList(MeetingRoomListVo.class, meetingRoomMPJLambdaWrapper);

        // 获取会议申请日期已经预约的会议
        List<WfMeetingApply> wfMeetingApplyList = this.list(Wrappers.lambdaQuery(WfMeetingApply.class)
                .eq(WfMeetingApply::getMeetingApplyDate, meetingApplyDate)
                .eq(WfMeetingApply::getMeetingApplyFormat, MeetingTypeEnum.HMT0002.getCode())// 线下会议
                .ne(WfMeetingApply::getMeetingStatus, 1)
                .ne(WfMeetingApply::getWorkflowStatus, 2)
        );

        // 根据会议室id分组
        Map<Long, List<WfMeetingApply>> mapByMeetingRoomId = wfMeetingApplyList.stream()
                .collect(Collectors.groupingBy(WfMeetingApply::getMeetingRoomId));

        // 处理已经预约的会议室
        Map<Long, MeetingRoomListVo> reservationMap = new LinkedHashMap<>();
        MeetingRoomListVo meetingRoomListVo;
        for (Map.Entry<Long, List<WfMeetingApply>> entry : mapByMeetingRoomId.entrySet()) {
            Long key = entry.getKey();
            List<WfMeetingApply> value = entry.getValue();
            StringBuilder reservationDetail = new StringBuilder();
            boolean isReservation = false;
            meetingRoomListVo = new MeetingRoomListVo();
            for (WfMeetingApply wfMeetingApply : value) {
                // 会议时间是否重叠
                if (startTime.isBefore(wfMeetingApply.getMeetingApplyE()) && wfMeetingApply.getMeetingApplyS().isBefore(endTime)) {
                    isReservation = true;
                }
                reservationDetail.append(wfMeetingApply.getMeetingApplyS()).append("-").append(wfMeetingApply.getMeetingApplyE()).append("\r\n");
            }
            meetingRoomListVo.setReservationDetail(reservationDetail.toString());
            meetingRoomListVo.setStatus(isReservation ? 1 : 0);

            reservationMap.put(key, meetingRoomListVo);
        }

        for (MeetingRoomListVo vo : result) {
            vo.setStatus(0);
            MeetingRoomListVo reservationRoom = reservationMap.get(vo.getId());
            if (ObjectUtils.isEmpty(reservationRoom)) {
                usableResult.add(vo);
            }
            if (ObjectUtils.isNotEmpty(reservationRoom) && reservationRoom.getStatus() == 0) {
                usableResult.add(vo);
            }
        }

        // 根据可用排序
        usableResult.sort(Comparator.comparing(MeetingRoomListVo::getName));
        return usableResult;
    }

    @Override
    public IPage<WfMeetingApplyPageVo> pageRabAndHand(WfMeetingApplyPageDto dto) {
        // 权限设置
        Long loginId = StpUtil.getLoginIdAsLong();
        int permission = 1;
        if (StpUtil.hasRole("Conference") || StpUtil.hasRole("ADMIN")) {
            permission = 2;
        }

        // 当前时间
        LocalDate nowLocalDate = LocalDate.now();
        LocalTime nowLocalTime = LocalTime.now();

        MPJLambdaWrapper<WfMeetingApply> wfMeetingApplyPageVoMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfMeetingApplyPageVoMPJLambdaWrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(WfMeetingApplyPageVo.class).contains(x.getProperty()))
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, WfMeetingApply::getMeetingApplyFormat,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, WfMeetingApplyPageVo::getMeetingApplyFormatCn)
                )
                .leftJoin(MeetingRoom.class, MeetingRoom::getId, WfMeetingApply::getMeetingRoomId,
                        wrapper -> wrapper
                                .selectAs(MeetingRoom::getName, WfMeetingApplyPageVo::getMeetingRoomIdCn)
                )
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getMeetingApplyHost,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, WfMeetingApplyPageVo::getMeetingApplyHostCn)
                                .like(StringUtils.isNotEmpty(dto.getMeetingApplyHostCn()), XjrUser::getName, dto.getMeetingApplyHostCn())
                )
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getSponsorId,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, WfMeetingApplyPageVo::getSponsorIdCn)
                )
                .eq(permission == 1, WfMeetingApply::getSponsorId, loginId)
                .eq(WfMeetingApply::getWorkflowStatus, 1)
                .ge(ObjectUtils.isNotEmpty(dto.getStartMeetingApplyDate()), WfMeetingApply::getMeetingApplyDate, dto.getStartMeetingApplyDate())
                .le(ObjectUtils.isNotEmpty(dto.getEndMeetingApplyDate()), WfMeetingApply::getMeetingApplyDate, dto.getEndMeetingApplyDate())
                .eq(StringUtils.isNotEmpty(dto.getMeetingApplyFormat()), WfMeetingApply::getMeetingApplyFormat, dto.getMeetingApplyFormat())
                .like(StringUtils.isNotEmpty(dto.getMeetingApplyTheme()), WfMeetingApply::getMeetingApplyTheme, dto.getMeetingApplyTheme())
                .orderByDesc(WfMeetingApply::getMeetingApplyDate)
                .orderByAsc(WfMeetingApply::getMeetingApplyS)
        ;
        if (ObjectUtils.isNotEmpty(dto.getMeetingStatus()) && dto.getMeetingStatus() == 0) {
            wfMeetingApplyPageVoMPJLambdaWrapper
                    .ge(WfMeetingApply::getMeetingApplyDate, nowLocalDate)
                    .gt(WfMeetingApply::getMeetingApplyS, nowLocalTime)
                    .ne(WfMeetingApply::getMeetingStatus, 1)
            ;
        }

        if (ObjectUtils.isNotEmpty(dto.getMeetingStatus()) && dto.getMeetingStatus() == 1) {
            wfMeetingApplyPageVoMPJLambdaWrapper
                    .eq(WfMeetingApply::getMeetingStatus, 1)
            ;
        }

        if (ObjectUtils.isNotEmpty(dto.getMeetingStatus()) && dto.getMeetingStatus() == 2) {
            wfMeetingApplyPageVoMPJLambdaWrapper
                    .le(WfMeetingApply::getMeetingApplyDate, nowLocalDate)
                    .lt(WfMeetingApply::getMeetingApplyE, nowLocalTime)
                    .ne(WfMeetingApply::getMeetingStatus, 1)
            ;
        }

        if (ObjectUtils.isNotEmpty(dto.getMeetingStatus()) && dto.getMeetingStatus() == 3) {
            wfMeetingApplyPageVoMPJLambdaWrapper
                    .eq(WfMeetingApply::getMeetingApplyDate, nowLocalDate)
                    .le(WfMeetingApply::getMeetingApplyS, nowLocalTime)
                    .ge(WfMeetingApply::getMeetingApplyE, nowLocalTime)
                    .ne(WfMeetingApply::getMeetingStatus, 1)
            ;
        }

        IPage<WfMeetingApplyPageVo> page = this.selectJoinListPage(ConventPage.getPage(dto), WfMeetingApplyPageVo.class, wfMeetingApplyPageVoMPJLambdaWrapper);

        // 判断会议状态
        for (WfMeetingApplyPageVo vo : page.getRecords()) {
            if (vo.getMeetingStatus() != 1) {
                if (vo.getMeetingApplyDate().isBefore(nowLocalDate)) {
                    vo.setMeetingStatus(2);
                } else if (vo.getMeetingApplyDate().isAfter(nowLocalDate)) {
                    vo.setMeetingStatus(0);
                } else {
                    if (vo.getMeetingApplyE().isBefore(nowLocalTime)) {
                        vo.setMeetingStatus(2);
                    } else if (vo.getMeetingApplyS().isAfter(nowLocalTime)) {
                        vo.setMeetingStatus(0);
                    } else {
                        vo.setMeetingStatus(3);
                    }
                }
            }
        }

        return page;
    }

    @Override
    public IPage<TodayMeetingMobilePageVo> todayMeetingMobilePage(TodayMeetingMobilePageDto dto) {
        LocalTime nowLocalTime = LocalTime.now();
        if(ObjectUtils.isEmpty(dto.getMeetingApplyDate())){
            dto.setMeetingApplyDate(LocalDate.now());
        }
        Long loginId = StpUtil.getLoginIdAsLong();

        MPJLambdaWrapper<WfMeetingApply> wfMeetingApplyPageVoMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfMeetingApplyPageVoMPJLambdaWrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(TodayMeetingMobilePageVo.class).contains(x.getProperty()))
                .innerJoin(MeetingConferee.class, MeetingConferee::getWfMeetingApplyId, WfMeetingApply::getId,
                        wrapper -> wrapper
                                .selectAs(MeetingConferee::getCheckInStatus, TodayMeetingMobilePageVo::getCheckInStatus)
                )
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, WfMeetingApply::getMeetingApplyFormat,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, TodayMeetingMobilePageVo::getMeetingApplyFormatCn)
                )
                .leftJoin(MeetingRoom.class, MeetingRoom::getId, WfMeetingApply::getMeetingRoomId,
                        wrapper -> wrapper
                                .selectAs(MeetingRoom::getName, TodayMeetingMobilePageVo::getMeetingRoomIdCn)
                )
                .eq(WfMeetingApply::getMeetingApplyDate, dto.getMeetingApplyDate())
                .eq(MeetingConferee::getUserId, loginId)
                .eq(WfMeetingApply::getWorkflowStatus, 1)
                .orderByAsc(WfMeetingApply::getMeetingApplyS)
        ;
        IPage<TodayMeetingMobilePageVo> page = this.selectJoinListPage(ConventPage.getPage(dto), TodayMeetingMobilePageVo.class, wfMeetingApplyPageVoMPJLambdaWrapper);
        List<TodayMeetingMobilePageVo> record = page.getRecords();

        Map<String, LocalTime> startTimeMap = record.stream().collect(Collectors.toMap(TodayMeetingMobilePageVo::getId, TodayMeetingMobilePageVo::getMeetingApplyS));
        Map<String, LocalTime> endTimeMap = record.stream().collect(Collectors.toMap(TodayMeetingMobilePageVo::getId, TodayMeetingMobilePageVo::getMeetingApplyE));
        for (TodayMeetingMobilePageVo vo : record) {
            int adjustType = 1;
            LocalTime oneStartTime = vo.getMeetingApplyS();
            LocalTime oneEndTime =  vo.getMeetingApplyE();
            for (String id : startTimeMap.keySet()) {
                if(vo.getId().equals(id)){
                    continue;
                }
                LocalTime startTime = startTimeMap.get(id);
                LocalTime endTime = endTimeMap.get(id);
                if (oneStartTime.isBefore(endTime) && oneEndTime.isAfter(startTime)) {
                    adjustType = 0;
                }
            }
            vo.setConflictStatus(adjustType);
        }

        // 分割并重组列表
        List<TodayMeetingMobilePageVo> futureVo = new ArrayList<>(); // 当前时间之后的事件
        List<TodayMeetingMobilePageVo> pastVo = new ArrayList<>();   // 当前时间之前的事件

        // 处理状态
        for (TodayMeetingMobilePageVo vo : record){
            if (vo.getMeetingStatus() != 1) {
                if (vo.getMeetingApplyE().isBefore(nowLocalTime)) {
                    if(vo.getCheckInStatus() == 0){
                        vo.setMeetingStatus(4);
                    }
                    if(vo.getCheckInStatus() == 1){
                        vo.setMeetingStatus(2);
                    }
                } else if (vo.getMeetingApplyS().isAfter(nowLocalTime)) {
                    vo.setMeetingStatus(0);
                } else {
                    vo.setMeetingStatus(3);
                }
            }

            if (vo.getMeetingApplyS().isBefore(nowLocalTime)) {
                pastVo.add(vo); // 过去的事件
            } else {
                futureVo.add(vo); // 未来的事件
            }
        }

        List<TodayMeetingMobilePageVo> result = new ArrayList<>();
        result.addAll(futureVo);
        result.addAll(pastVo);

        page.setRecords(result);

        return page;
    }

    @Override
    public IPage<SponsorMeetingMobilePageVo> sponsorMeetingMobilePage(SponsorMeetingMobilePageDto dto) {
        Long loginId = StpUtil.getLoginIdAsLong();

        // 当前时间
        LocalDate nowLocalDate = LocalDate.now();
        LocalTime nowLocalTime = LocalTime.now();

        MPJLambdaWrapper<WfMeetingApply> wfMeetingApplyPageVoMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfMeetingApplyPageVoMPJLambdaWrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(SponsorMeetingMobilePageVo.class).contains(x.getProperty()))
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, WfMeetingApply::getMeetingApplyFormat,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, SponsorMeetingMobilePageVo::getMeetingApplyFormatCn)
                )
                .leftJoin(MeetingRoom.class, MeetingRoom::getId, WfMeetingApply::getMeetingRoomId,
                        wrapper -> wrapper
                                .selectAs(MeetingRoom::getName, SponsorMeetingMobilePageVo::getMeetingRoomIdCn)
                )
                .eq(WfMeetingApply::getSponsorId, loginId)
                .ge(ObjectUtils.isNotEmpty(dto.getStartMeetingApplyDate()), WfMeetingApply::getMeetingApplyDate, dto.getStartMeetingApplyDate())
                .le(ObjectUtils.isNotEmpty(dto.getEndMeetingApplyDate()), WfMeetingApply::getMeetingApplyDate, dto.getEndMeetingApplyDate())
                .eq(WfMeetingApply::getWorkflowStatus, 1)
                .orderByAsc("meeting_apply_date", "meeting_apply_s")
        ;

        IPage<SponsorMeetingMobilePageVo> page = this.selectJoinListPage(ConventPage.getPage(dto), SponsorMeetingMobilePageVo.class, wfMeetingApplyPageVoMPJLambdaWrapper);

        // 判断会议状态
        for (SponsorMeetingMobilePageVo vo : page.getRecords()) {
            if (vo.getMeetingStatus() != 1) {
                if (vo.getMeetingApplyDate().isBefore(nowLocalDate)) {
                    vo.setMeetingStatus(2);
                } else if (vo.getMeetingApplyDate().isAfter(nowLocalDate)) {
                    vo.setMeetingStatus(0);
                } else {
                    if (vo.getMeetingApplyE().isBefore(nowLocalTime)) {
                        vo.setMeetingStatus(2);
                    } else if (vo.getMeetingApplyS().isAfter(nowLocalTime)) {
                        vo.setMeetingStatus(0);
                    } else {
                        vo.setMeetingStatus(3);
                    }
                }
            }
        }

        return page;
    }

    @Override
    public IPage<HistoryMeetingMobilePageVo> historyMeetingMobilePage(HistoryMeetingMobilePageDto dto) {
        Long loginId = StpUtil.getLoginIdAsLong();

        if(ObjectUtils.isEmpty(dto.getEndMeetingApplyDate())){
            dto.setEndMeetingApplyDate(LocalDate.now().minusDays(1));
        }

        MPJLambdaWrapper<WfMeetingApply> wfMeetingApplyPageVoMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfMeetingApplyPageVoMPJLambdaWrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(HistoryMeetingMobilePageVo.class).contains(x.getProperty()))
                .innerJoin(MeetingConferee.class, MeetingConferee::getWfMeetingApplyId, WfMeetingApply::getId)
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, WfMeetingApply::getMeetingApplyFormat,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, HistoryMeetingMobilePageVo::getMeetingApplyFormatCn)
                )
                .leftJoin(MeetingRoom.class, MeetingRoom::getId, WfMeetingApply::getMeetingRoomId,
                        wrapper -> wrapper
                                .selectAs(MeetingRoom::getName, HistoryMeetingMobilePageVo::getMeetingRoomIdCn)
                )
                .eq(MeetingConferee::getUserId, loginId)
                .ge(ObjectUtils.isNotEmpty(dto.getStartMeetingApplyDate()), WfMeetingApply::getMeetingApplyDate, dto.getStartMeetingApplyDate())
                .le(ObjectUtils.isNotEmpty(dto.getEndMeetingApplyDate()), WfMeetingApply::getMeetingApplyDate, dto.getEndMeetingApplyDate())
                .eq(WfMeetingApply::getWorkflowStatus, 1)
                .orderByAsc("meeting_apply_date", "meeting_apply_s")
        ;

        return this.selectJoinListPage(ConventPage.getPage(dto), HistoryMeetingMobilePageVo.class, wfMeetingApplyPageVoMPJLambdaWrapper);
    }

    @Override
    public MeetingMobileInfoVo mobileInfo(Long id) {
        Long loginId = StpUtil.getLoginIdAsLong();

        MPJLambdaWrapper<WfMeetingApply> wfMeetingApplyPageVoMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfMeetingApplyPageVoMPJLambdaWrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .select(" (SELECT GROUP_CONCAT(a.name) FROM xjr_user a" +
                        " LEFT JOIN meeting_conferee b ON b.user_id = a.id" +
                        " WHERE b.delete_mark = 0 AND b.wf_meeting_apply_id = t.id) as meetingApplyParticipantsCn")
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(MeetingMobileInfoVo.class).contains(x.getProperty()))
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, WfMeetingApply::getMeetingApplyFormat,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, MeetingMobileInfoVo::getMeetingApplyFormatCn)
                )
                .leftJoin(MeetingRoom.class, MeetingRoom::getId, WfMeetingApply::getMeetingRoomId,
                        wrapper -> wrapper
                                .selectAs(MeetingRoom::getName, MeetingMobileInfoVo::getMeetingRoomIdCn)
                )
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getMeetingApplyHost,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, MeetingMobileInfoVo::getMeetingApplyHostCn)
                )
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getSponsorId,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, MeetingMobileInfoVo::getSponsorIdCn)
                )
                .eq(WfMeetingApply::getId, id)
        ;

        MeetingMobileInfoVo info = this.selectJoinOne(MeetingMobileInfoVo.class, wfMeetingApplyPageVoMPJLambdaWrapper);

        if (ObjectUtils.isNotEmpty(info)) {
            // 判断当前用户是否是当前会议的参与人
            LambdaQueryWrapper<MeetingConferee> isMeetingConferee = new LambdaQueryWrapper<>();
            isMeetingConferee
                    .eq(MeetingConferee::getWfMeetingApplyId, id)
                    .eq(MeetingConferee::getUserId, loginId)
                    ;
            List<MeetingConferee> meetingConfereeList = meetingConfereeMapper.selectList(isMeetingConferee);
            // 既不是发起人也不是参与人
            if(CollectionUtils.isEmpty(meetingConfereeList) && !info.getSponsorId().equals(loginId)){
                return new MeetingMobileInfoVo();
            }

            List<File> fileList = fileMapper.selectList(Wrappers.<File>query().lambda().eq(File::getFolderId, info.getPreMeetingInfoFileId()));
            info.setFileInfos(fileList);

            // 如果是会议参会人员，应该处理签到状态
            LambdaQueryWrapper<MeetingConferee> meetingConfereeLambdaQueryWrapper = new LambdaQueryWrapper<>();
            meetingConfereeLambdaQueryWrapper
                    .eq(MeetingConferee::getUserId, StpUtil.getLoginIdAsLong())
                    .eq(MeetingConferee::getWfMeetingApplyId, id)
                    ;
            MeetingConferee meetingConferee = meetingConfereeMapper.selectOne(meetingConfereeLambdaQueryWrapper);
            if(ObjectUtils.isNotEmpty(meetingConferee)){
                info.setCheckInStatus(meetingConferee.getCheckInStatus());
            }

            // 处理状态
            LocalTime nowLocalTime = LocalTime.now();
            LocalDate nowLocalDate = LocalDate.now();
            if (info.getMeetingStatus() != 1) {
                if (info.getMeetingApplyDate().isBefore(nowLocalDate)) {
                    info.setMeetingStatus(2);
                } else if (info.getMeetingApplyDate().isAfter(nowLocalDate)) {
                    info.setMeetingStatus(0);
                } else {
                    if (info.getMeetingApplyE().isBefore(nowLocalTime)) {
                        info.setMeetingStatus(2);
                    } else if (info.getMeetingApplyS().isAfter(nowLocalTime)) {
                        info.setMeetingStatus(0);
                    } else {
                        info.setMeetingStatus(3);
                    }
                }
            }
        }

        return info;
    }

    @Override
    public WfMeetingApplyInWorkflowVo infoInWorkflow(Long id) {
        MPJLambdaWrapper<WfMeetingApply> wfMeetingApplyPageVoMPJLambdaWrapper = new MPJLambdaWrapper<>();
        wfMeetingApplyPageVoMPJLambdaWrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .select(" (SELECT GROUP_CONCAT(a.name) FROM xjr_user a" +
                        " LEFT JOIN meeting_conferee b ON b.user_id = a.id" +
                        " WHERE b.delete_mark = 0 AND b.wf_meeting_apply_id = t.id) as meetingApplyParticipantsCn")
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(WfMeetingApplyInWorkflowVo.class).contains(x.getProperty()))
                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, WfMeetingApply::getMeetingApplyFormat,
                        wrapper -> wrapper
                                .selectAs(DictionaryDetail::getName, WfMeetingApplyInWorkflowVo::getMeetingApplyFormatCn)
                )
                .leftJoin(MeetingRoom.class, MeetingRoom::getId, WfMeetingApply::getMeetingRoomId,
                        wrapper -> wrapper
                                .selectAs(MeetingRoom::getName, WfMeetingApplyInWorkflowVo::getMeetingRoomIdCn)
                )
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getMeetingApplyHost,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, WfMeetingApplyInWorkflowVo::getMeetingApplyHostCn)
                )
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getSponsorId,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, WfMeetingApplyInWorkflowVo::getSponsorIdCn)
                )
                .eq(WfMeetingApply::getId, id)
        ;

        WfMeetingApplyInWorkflowVo info = this.selectJoinOne(WfMeetingApplyInWorkflowVo.class, wfMeetingApplyPageVoMPJLambdaWrapper);

        if (ObjectUtils.isNotEmpty(info)) {
            List<File> fileList = fileMapper.selectList(Wrappers.<File>query().lambda().eq(File::getFolderId, info.getPreMeetingInfoFileId()));
            info.setFileInfos(fileList);

            List<WorkflowRecord> recordList = workflowRecordMapper.selectList(
                    new MPJLambdaWrapper<WorkflowRecord>()
                            .select(WorkflowRecord.class, x -> VoToColumnUtil.fieldsToColumns(WorkflowRecordVo.class).contains(x.getProperty()))
                            .innerJoin(WorkflowFormRelation.class, WorkflowFormRelation::getProcessId, WorkflowRecord::getProcessId)
                            .eq(WorkflowFormRelation::getFormKeyValue, id)
            );
            info.setWorkflowRecordList(BeanUtil.copyToList(recordList, WorkflowRecordVo.class));
            List<WorkflowFormRelation> relations = workflowFormRelationMapper.selectList(new QueryWrapper<WorkflowFormRelation>().lambda().eq(WorkflowFormRelation::getFormKeyValue, id.toString()));

            if (!relations.isEmpty()) {
                info.setProcessId(relations.get(0).getProcessId());
            }

            //查询最后一个节点的taskId
            List<WorkflowExtra> taskList = workflowExtraMapper.selectList(
                    new QueryWrapper<WorkflowExtra>().lambda()
                            .eq(WorkflowExtra::getProcessId, info.getProcessId())
                            .orderByDesc(WorkflowExtra::getStartTime)
            );
            if (!taskList.isEmpty()) {
                info.setTaskId(taskList.get(0).getTaskId());
            }
        }

        return info;
    }

    @Override
    public List<MeetingConfereeListVo> listMeetingConferee(MeetingConfereeListDto dto) {
        MPJLambdaWrapper<MeetingConferee> meetingConfereeMPJLambdaWrapper = new MPJLambdaWrapper<>();
        meetingConfereeMPJLambdaWrapper
                .disableSubLogicDel()
                .select(MeetingConferee::getId)
                .select(MeetingConferee.class, x -> VoToColumnUtil.fieldsToColumns(MeetingConfereeListVo.class).contains(x.getProperty()))
                .leftJoin(XjrUser.class, XjrUser::getId, MeetingConferee::getUserId,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, MeetingConfereeListVo::getUserIdCn)
                                .selectAs(XjrUser::getUserName, MeetingConfereeListVo::getUserName)
                )
                .eq(MeetingConferee::getWfMeetingApplyId, dto.getWfMeetingApplyId())
        ;

        return meetingConfereeMapper.selectJoinList(MeetingConfereeListVo.class, meetingConfereeMPJLambdaWrapper);
    }

    @Override
    public List<MeetingConfereeOpinionListVo> listMeetingConfereeOpinion(MeetingConfereeOpinionListDto dto) {
        MPJLambdaWrapper<MeetingConfereeOpinion> meetingConfereeOpinionMPJLambdaWrapper = new MPJLambdaWrapper<>();
        meetingConfereeOpinionMPJLambdaWrapper
                .disableSubLogicDel()
                .select(MeetingConfereeOpinion::getId)
                .select(MeetingConfereeOpinion.class, x -> VoToColumnUtil.fieldsToColumns(MeetingConfereeOpinionListVo.class).contains(x.getProperty()))
                .leftJoin(XjrUser.class, XjrUser::getId, MeetingConfereeOpinion::getUserId,
                        wrapper -> wrapper
                                .selectAs(XjrUser::getName, MeetingConfereeOpinionListVo::getUserIdCn)
                                .leftJoin(DictionaryDetail.class, DictionaryDetail::getCode, XjrUser::getGender,
                                        wrap -> wrap
                                                .selectAs(DictionaryDetail::getName, MeetingConfereeOpinionListVo::getGenderCn)
                                )
                )
                .eq(MeetingConfereeOpinion::getWfMeetingApplyId, dto.getWfMeetingApplyId())
        ;
        return meetingConfereeOpinionMapper.selectJoinList(MeetingConfereeOpinionListVo.class, meetingConfereeOpinionMPJLambdaWrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void noticeParticipants(Long id) {
        MPJLambdaWrapper<WfMeetingApply> wrapper = new MPJLambdaWrapper<>();
        wrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .selectAs(MeetingRoom::getName, WfMeetingApply::getMeetingSummary) // 将会议室的名称暂时放在会议纪要字段中
                .selectAs(XjrUser::getName, WfMeetingApply::getMonogramTheme) // 将会议发起人名称暂时放在会标主题字段中
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(WfMeetingApply.class).contains(x.getProperty()))
                .leftJoin(MeetingRoom.class, MeetingRoom::getId, WfMeetingApply::getMeetingRoomId)
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getSponsorId)
                .eq(WfMeetingApply::getId, id)
        ;
        WfMeetingApply meetingApply = this.selectJoinOne(WfMeetingApply.class, wrapper);

        // 根据数据id找到所在流程得状态
        WorkflowFormRelation workflowFormRelation = workflowFormRelationMapper.selectOne(
                Wrappers.lambdaQuery(WorkflowFormRelation.class)
                        .eq(WorkflowFormRelation::getFormKeyValue, id)
        );

        if (ObjectUtils.isNotEmpty(meetingApply)
                && ObjectUtils.isNotEmpty(workflowFormRelation)
                && HistoricProcessInstance.STATE_COMPLETED.equals(workflowFormRelation.getCurrentState())
        ) {
            // 修改会议申请流程状态为正常通过结束
            WfMeetingApply updateWorkflowStatus = new WfMeetingApply();
            updateWorkflowStatus.setId(meetingApply.getId());
            updateWorkflowStatus.setWorkflowStatus(1);
            this.updateById(updateWorkflowStatus);

            if (meetingApply.getMeetingApplyParticipants() == null || meetingApply.getMeetingApplyParticipants().isEmpty()) {
                return;
            }

            List<String> userIds = Arrays.asList(meetingApply.getMeetingApplyParticipants().split(","));

            // 处理会议时间
            List<User> userList = userService.list(new QueryWrapper<User>().lambda().in(User::getId, userIds));
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime startLocalDateTime = LocalDateTime.of(meetingApply.getMeetingApplyDate(), meetingApply.getMeetingApplyS());
            LocalDateTime endLocalDateTime = LocalDateTime.of(meetingApply.getMeetingApplyDate(), meetingApply.getMeetingApplyE());
            String startTime = startLocalDateTime.format(formatter);
            String endTime = endLocalDateTime.format(formatter);

//             获取申请人
//            List<WorkflowExtra> list = extraService.list(
//                    new MPJLambdaWrapper<WorkflowExtra>()
//                            .select(WorkflowExtra.class, x -> VoToColumnUtil.fieldsToColumns(WorkflowExtra.class).contains(x.getProperty()))
//                            .innerJoin(WorkflowFormRelation.class, WorkflowFormRelation::getProcessId, WorkflowExtra::getProcessId)
//                            .eq(WorkflowFormRelation::getFormId, id)
//                            .orderByAsc(WorkflowExtra::getStartTime)
//            );
//            String startUserName = list.get(0).getStartUserName();

            MeetingConferee meetingConferee;

            // 添加参会人员到参会人员表
            for (User user : userList) {
                meetingConferee = new MeetingConferee();
                meetingConferee.setWfMeetingApplyId(id);
                meetingConferee.setUserId(user.getId());
                meetingConferee.setCheckInStatus(0);

                meetingConfereeMapper.insert(meetingConferee);
            }

            // 发送微信通知，和添加到记录分开是预防添加出现异常只通知一部人。
            for (User user : userList) {
                if (ObjectUtils.isNotEmpty(user.getOpenId())) {
                    WeChatSendMessageDto weChatSendMessageDto = new WeChatSendMessageDto();
                    weChatSendMessageDto.setUserId(user.getOpenId());
                    weChatSendMessageDto.setTemplateId("Hign0b3e4WSXe__YmBKyDsBgAjkfNYC7c6yIUHjk3Hg");
                    weChatSendMessageDto.setMsgId(IdUtil.getSnowflakeNextId() + "");
                    JSONObject paramJson = new JSONObject();

                    JSONObject thing2 = new JSONObject();
                    thing2.put("value", meetingApply.getMeetingApplyTheme());
                    paramJson.put("thing2", thing2);

                    JSONObject time5 = new JSONObject();
                    time5.put("value", startTime);
                    paramJson.put("time5", time5);

                    JSONObject time6 = new JSONObject();
                    time6.put("value", endTime);
                    paramJson.put("time6", time6);

                    JSONObject thing7 = new JSONObject();
                    thing7.put("value", meetingApply.getMeetingSummary());
                    paramJson.put("thing7", thing7);

                    JSONObject thing8 = new JSONObject();
                    thing8.put("value", meetingApply.getMonogramTheme());
                    paramJson.put("thing8", thing8);

                    weChatSendMessageDto.setContent(paramJson);
                    weChatService.sendTemplateMessage(weChatSendMessageDto);
                }
            }
        }

        if (ObjectUtils.isNotEmpty(meetingApply)
                && ObjectUtils.isNotEmpty(workflowFormRelation)
                && !HistoricProcessInstance.STATE_COMPLETED.equals(workflowFormRelation.getCurrentState())
                && !HistoricProcessInstance.STATE_ACTIVE.equals(workflowFormRelation.getCurrentState())
        ) {
            // 修改会议申请流程状态为不正常的结束
            WfMeetingApply updateWorkflowStatus = new WfMeetingApply();
            updateWorkflowStatus.setId(meetingApply.getId());
            updateWorkflowStatus.setWorkflowStatus(2);
            this.updateById(updateWorkflowStatus);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateRevocationMeeting(UpdateRevocationMeetingDto dto) {
        MPJLambdaWrapper<WfMeetingApply> wrapper = new MPJLambdaWrapper<>();
        wrapper
                .disableSubLogicDel()
                .select(WfMeetingApply::getId)
                .selectAs(XjrUser::getName, WfMeetingApply::getMonogramTheme) // 将会议发起人名称暂时放在会标主题字段中
                .select(WfMeetingApply.class, x -> VoToColumnUtil.fieldsToColumns(WfMeetingApply.class).contains(x.getProperty()))
                .leftJoin(XjrUser.class, XjrUser::getId, WfMeetingApply::getSponsorId)
                .eq(WfMeetingApply::getId, dto.getId())
        ;
        WfMeetingApply oldWfMeetingApply = this.selectJoinOne(WfMeetingApply.class, wrapper);

        WfMeetingApply updateWfMeetingApply = new WfMeetingApply();
        updateWfMeetingApply.setId(dto.getId());
        updateWfMeetingApply.setMeetingStatus(1);
        this.updateById(updateWfMeetingApply);

        if (StringUtils.isNotEmpty(oldWfMeetingApply.getMeetingApplyParticipants())) {
            List<String> userIds = Arrays.asList(oldWfMeetingApply.getMeetingApplyParticipants().split(","));
            List<User> userList = userService.list(new QueryWrapper<User>().lambda().in(User::getId, userIds).isNotNull(User::getOpenId));
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            LocalDateTime startLocalDateTime = LocalDateTime.of(oldWfMeetingApply.getMeetingApplyDate(), oldWfMeetingApply.getMeetingApplyS());
            String startTime = startLocalDateTime.format(formatter);
            // 发送消息通知
            for (User user : userList) {
                WeChatSendMessageDto weChatSendMessageDto = new WeChatSendMessageDto();
                weChatSendMessageDto.setUserId(user.getOpenId());
                weChatSendMessageDto.setTemplateId("sZcnORXfcQZf8zy5K16N3dsPgQomyQALqUeEzYvTwxo");
                weChatSendMessageDto.setMsgId(IdUtil.getSnowflakeNextId() + "");
                JSONObject paramJson = new JSONObject();

                JSONObject thing1 = new JSONObject();
                thing1.put("value", oldWfMeetingApply.getMeetingApplyTheme());
                paramJson.put("thing1", thing1);

                JSONObject time6 = new JSONObject();
                time6.put("value", startTime);
                paramJson.put("time6", time6);

                JSONObject thing8 = new JSONObject();
                thing8.put("value", oldWfMeetingApply.getMonogramTheme());
                paramJson.put("thing8", thing8);

                weChatSendMessageDto.setContent(paramJson);
                weChatService.sendTemplateMessage(weChatSendMessageDto);
            }
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateMeetingCheckIn(UpdateMeetingCheckInDto dto) {
        Long loginId = StpUtil.getLoginIdAsLong();

        LambdaUpdateWrapper<MeetingConferee> meetingConfereeLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        meetingConfereeLambdaUpdateWrapper
                .eq(MeetingConferee::getWfMeetingApplyId, dto.getId())
                .eq(MeetingConferee::getUserId, loginId)
                ;
        MeetingConferee meetingConferee = new MeetingConferee();
        meetingConferee.setCheckInStatus(1);
        meetingConferee.setCheckInDate(new Date());
        meetingConferee.setModifyDate(new Date());
        meetingConferee.setModifyUserId(loginId);
        meetingConfereeMapper.update(meetingConferee, meetingConfereeLambdaUpdateWrapper);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean addMeetingConfereeOpinion(AddMeetingConfereeOpinionDto dto) {
        MeetingConfereeOpinion insert = new MeetingConfereeOpinion();
        insert.setWfMeetingApplyId(dto.getWfMeetingApplyId());
        insert.setUserId(StpUtil.getLoginIdAsLong());
        insert.setOpinion(dto.getOpinion());
        insert.setCreateDate(new Date());
        insert.setCreateUserId(StpUtil.getLoginIdAsLong());
        meetingConfereeOpinionMapper.insert(insert);
        return true;
    }
}