minispringboot/src/main/java/com/example/mini_program/service/AppointmentService.java

package com.example.mini_program.service;

import com.example.mini_program.entity.ReceptionPersonPO;
import com.example.mini_program.entity.VisitApplication;
import com.example.mini_program.mapper.ReceptionPersonMapper;
import com.example.mini_program.mapper.VisitApplicationMapper;
import com.example.mini_program.entity.ReceptionDepartmentPo;
import com.example.mini_program.vo.ReceptionPersonVo;
import com.example.mini_program.vo.VisitApplicationVo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * 访客预约服务
 * 创建预约 → 提交企微审批 → 推送订阅消息通知
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class AppointmentService {
    @Autowired
    private final VisitApplicationMapper visitApplicationMapper;
    @Autowired
    private final WxApprovalService wxApprovalService;
    @Autowired
    private ReceptionPersonMapper receptionPersonMapper;
    @Value("${wx.corp.creator-userid:}")
    private String creatorUserId;

    @Value("${wx.corp.approval-userid:}")
    private String approvalUserId;

    /**
     * 根据openid获取最新的一条预约记录
     */
    public VisitApplication getLatest(String openid) {
        log.info("查询用户最新预约记录, openid: {}", openid);
        VisitApplication result = visitApplicationMapper.selectLatestByOpenid(openid);
        if (result != null) {
            log.info("找到用户最新预约记录, id: {}", result.getId());
        } else {
            log.info("未找到用户最新预约记录");
        }
        return result;
    }

    /**
     * 获取用户所有预约记录（按创建时间倒序）
     */
    public List<VisitApplication> getList(String openid) {
        log.info("查询用户预约列表, openid: {}", openid);
        List<VisitApplication> list = visitApplicationMapper.selectListByOpenid(openid);
        log.info("查询到 {} 条预约记录", list.size());
        return list;
    }

    public VisitApplication getDetail(String id) {
        VisitApplication v = visitApplicationMapper.selectById(id);
        return v;
    }

    /**
     * 创建预约记录
     */
    public VisitApplication create(VisitApplication record) {
        record.setId(UUID.randomUUID().toString().replace("-", ""));
        record.setStatus("pending");
        record.setStatusText("待审核");
        // 发起企业微信审批
        try {
            String spNo = wxApprovalService.submitApproval(creatorUserId, approvalUserId, record);
            record.setSpNo(spNo);
            log.info("企业微信审批提交成功, spNo: {}", spNo);
        } catch (Exception e) {
            log.error("企业微信审批提交失败，预约记录仍会保存", e);
        }

        visitApplicationMapper.insert(record);
        log.info("创建预约成功, id={}", record.getId());
        return record;
    }

    /**
     * 取消预约（仅pending状态可取消，需校验openid）
     */
    public boolean cancel(String id, String openid) {
        log.info("取消预约, id: {}, openid: {}", id, openid);

        VisitApplication existing = visitApplicationMapper.selectByIdAndOpenid(id, openid);
        if (existing == null) {
            log.warn("预约记录不存在或不属于该用户, id: {}, openid: {}", id, openid);
            return false;
        }
        if (!"pending".equals(existing.getStatus())) {
            log.warn("预约状态不允许取消, id: {}, status: {}", id, existing.getStatus());
            return false;
        }
        int rows = visitApplicationMapper.updateStatusToCancelled(id, openid);
        if (rows > 0) {
            log.info("取消预约成功, id: {}", id);
            return true;
        }
        log.warn("取消预约失败, id: {}", id);
        return false;
    }

    /**
     * 预约详情
     */
    public VisitApplicationVo detail(String id, String openid) throws Exception {
        log.info("预约详情, id: {}, openid: {}", id, openid);
        VisitApplication existing = visitApplicationMapper.selectByIdAndOpenid(id, openid);
        if (existing == null) {
            throw new Exception("未查询到该用户的访客预约记录");
        }
        VisitApplicationVo visitApplicationVo = new VisitApplicationVo();
        BeanUtils.copyProperties(visitApplicationVo, existing);
        return visitApplicationVo;
    }

    /**
     * 审批预约（通过/拒绝）
     */
    public boolean approve(String id, String status) {
        log.info("审批预约, id: {}, status: {}", id, status);

        VisitApplication existing = visitApplicationMapper.selectById(id);
        if (existing == null) {
            log.warn("预约记录不存在, id: {}", id);
            return false;
        }
        if (!"pending".equals(existing.getStatus())) {
            log.warn("预约状态不允许审批, id: {}, currentStatus: {}", id, existing.getStatus());
            return false;
        }

        String statusText = "approved".equals(status) ? "已通过" : "已拒绝";
        int rows = visitApplicationMapper.updateStatus(id, status, statusText);
        if (rows <= 0) {
            log.warn("审批更新失败, id: {}", id);
            return false;
        }

        log.info("审批成功, id: {}, status: {}", id, statusText);
        return true;
    }

    /**
     * 获取被访者下拉框的值
     */
    public List<ReceptionPersonVo> personSelector(String department) {
        List<ReceptionPersonPO> receiptPersonList = receptionPersonMapper.selectReceptionPerson(department);
        List<ReceptionPersonVo> voList = new ArrayList<>();
        for (ReceptionPersonPO po : receiptPersonList) {
            ReceptionPersonVo vo = new ReceptionPersonVo();
            BeanUtils.copyProperties(po, vo);
            voList.add(vo);
        }
        return voList;
    }

    /**
     * 获取被访区域下拉框的值
     */
    public List<ReceptionDepartmentPo> departmentSelector() {
        return  receptionPersonMapper.selectReceptionDepartment();
    }

}