package com.doumee.service.business.impl;

import com.doumee.biz.system.SystemDictDataBiz;
import com.doumee.core.constants.ResponseStatus;
import com.doumee.core.exception.BusinessException;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.LoginUserInfo;
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.Constants;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.*;
import com.doumee.dao.business.model.*;
import com.doumee.dao.system.MultifileMapper;
import com.doumee.dao.system.SystemUserMapper;
import com.doumee.dao.system.model.Multifile;
import com.doumee.dao.system.model.SystemUser;
import com.doumee.service.business.YwWorkorderService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.checkerframework.checker.units.qual.C;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.*;

/**
 * 运维工单信息表Service实现
 * @author 江蹄蹄
 * @date 2024/11/19 16:07
 */
@Service
public class YwWorkorderServiceImpl implements YwWorkorderService {

    @Autowired
    private YwWorkorderMapper ywWorkorderMapper;
    @Autowired
    private SystemUserMapper systemUserMapper;
    @Autowired
    private YwWorkorderLogMapper ywWorkorderLogMapper;
    @Autowired
    private SystemDictDataBiz systemDictDataBiz;
    @Autowired
    private MultifileMapper multifileMapper;
    @Autowired
    private YwProjectMapper ywProjectMapper;
    @Autowired
    private YwRoomMapper ywRoomMapper;
    @Autowired
    private YwBuildingMapper ywBuildingMapper;
    @Autowired
    private YwFloorMapper ywFloorMapper;

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public Integer create(YwWorkorder model) {

        dealParamValid(model);
        model.setCreator(model.getLoginUserInfo().getId());
        model.setIsdeleted(Constants.ZERO);
        model.setCreateDate(new Date());
        model.setStatus(Constants.ZERO);
        model.setDealStatus(Constants.ZERO);
        model.setEditDate(model.getCreateDate());
        model.setEditor(model.getCreator());
        ywWorkorderMapper.insert(model);

        List<Multifile> fileList = new ArrayList<>();
        if(model.getFileList()!=null && model.getFileList().size()>0){
            boolean isTrue = false;
            for (int i = 0; i <  model.getFileList().size(); i++) {
                Multifile multifile =  model.getFileList().get(i);
                if(StringUtils.isBlank(multifile.getFileurl())){
                    continue;
                }
                multifile.setCreateDate(model.getCreateDate());
                multifile.setEditDate(model.getCreateDate());
                multifile.setCreator(model.getEditor());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(model.getId());
                multifile.setEditor(model.getCreator());
                multifile.setObjType(Constants.MultiFile.YW_WORKORDER_PROBLEM.getKey());
                multifile.setSortnum(i+1);
                fileList.add(multifile);
            }
        }
        if(fileList.size()>0){
            multifileMapper.insert(fileList);
        }
        dealLogBiz(model,Constants.YwLogType.WORKORDER_CREATE,model.getLoginUserInfo().getRealname(),null);//记录新建日志
        return model.getId();
    }

    private void dealLogBiz(YwWorkorder model,Constants.YwLogType type,String param1,String param2) {
        YwWorkorderLog log = new YwWorkorderLog();
        log.setCreateDate(model.getEditDate());
        log.setCreator(model.getCreator());
        log.setJobId(model.getId());
        log.setIsdeleted(Constants.ZERO);
        log.setObjId(model.getId()+"");
        log.setObjType(type.getKey());
        log.setParam1(param1);
        log.setParam2(param2);
        log.setTitle(type.getNoteinfo());
        ywWorkorderLogMapper.insert(log);
    }

    private void dealParamValid(YwWorkorder model) {
        if(Constants.equalsInteger(model.getAreaType(),Constants.ZERO))   {
            //如果是市内装修，必须选择房源信息
            if(model.getRoomId()==null){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，请选择正确的房源信息！");
            }
            YwRoom room = ywRoomMapper.selectById(model.getRoomId());
            if(room ==null || Constants.equalsInteger(room.getIsdeleted(),Constants.ONE)){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，请选择正确的房源信息！");
            }
            model.setBuildingId(room.getBuildingId());
            model.setProjectId(room.getProjectId());
        }else{
            //如果是公共区域装修，必须选择楼宇信息
            if(model.getFloorId()==null){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，请选择正确的楼层信息！");
            }
            YwFloor room = ywFloorMapper.selectById(model.getFloorId());
            if(room ==null || Constants.equalsInteger(room.getIsdeleted(),Constants.ONE)){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，请选择正确的楼层信息！");
            }
            model.setBuildingId(room.getBuildingId());
            model.setProjectId(room.getProjectId());
        }
    }

    @Override
    public void deleteById(Integer id, LoginUserInfo user) {
        YwWorkorder model = new YwWorkorder();
        model.setId(id);
        model.setEditDate(new Date());
        model.setEditor(user.getId());
        model.setIsdeleted(Constants.ONE);
        ywWorkorderMapper.updateById(model);
    }

    @Override
    public void delete(YwWorkorder ywWorkorder) {
        UpdateWrapper<YwWorkorder> deleteWrapper = new UpdateWrapper<>(ywWorkorder);
        ywWorkorderMapper.delete(deleteWrapper);
    }

    @Override
    public void deleteByIdInBatch(List<Integer> ids, LoginUserInfo user) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        for(Integer id : ids){
            this.deleteById(id,user);
        }
    }

    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public  void dispatchOrder(YwWorkorder ywWorkorder){
        YwWorkorder model = this.findById(ywWorkorder.getId());
        if(model ==null || Constants.equalsInteger(model.getIsdeleted(),Constants.ONE)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，工单信息不存在！");
        }
        if(!Constants.equalsInteger(model.getDealStatus(),Constants.ZERO)
//                && !Constants.equalsInteger(model.getDealStatus(),Constants.ONE)
        ){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，工单状态已流转，不支持当前操作！");
        }

        SystemUser user = systemUserMapper.selectById(ywWorkorder.getDealUserId());
        if(user ==null ||  (user.getDeleted()!=null&& user.getDeleted() )){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，员工信息不存在！");
        }
        YwWorkorder update = new YwWorkorder();
        update.setId(model.getId());
        update.setEditDate(new Date());
        update.setEditor(ywWorkorder.getLoginUserInfo().getId());
        update.setDealStatus(Constants.ONE);
        update.setDispatchUserId(update.getEditor());
        update.setDispatchDate(update.getEditDate());
        update.setDispatchInfo(ywWorkorder.getDispatchInfo());
        update.setDealUserId(ywWorkorder.getDealUserId());
        ywWorkorderMapper.updateById(update);
        dealLogBiz(model,Constants.YwLogType.WORKORDER_DISPATCH,ywWorkorder.getLoginUserInfo().getRealname(),user.getRealname());//记录新建日志
    }
    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public  void dealOrder(YwWorkorder ywWorkorder){
        YwWorkorder model = this.findById(ywWorkorder.getId());
        if(model ==null || Constants.equalsInteger(model.getIsdeleted(),Constants.ONE)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，工单信息不存在！");
        }
        if(!Constants.equalsInteger(model.getDealStatus(),Constants.ZERO) && !Constants.equalsInteger(model.getDealStatus(),Constants.ONE)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，工单状态已流转，不支持当前操作！");
        }

//        SystemUser user = systemUserMapper.selectById(ywWorkorder.getDealUserId());
//        if(user ==null ||  (user.getDeleted()!=null&& user.getDeleted() )){
//            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"对不起，员工信息不存在！");
//        }
        YwWorkorder update = new YwWorkorder();
        update.setId(model.getId());
        update.setEditDate(new Date());
        update.setEditor(ywWorkorder.getLoginUserInfo().getId());
        update.setDealStatus(Constants.TWO);
        update.setDealUserId(update.getEditor());
        update.setDealDate(update.getEditDate());
        update.setDealInfo(ywWorkorder.getDealInfo());
        ywWorkorderMapper.updateById(update);

        List<Multifile> fileList = new ArrayList<>();
        if(ywWorkorder.getDealFileList()!=null && ywWorkorder.getDealFileList().size()>0){
            for (int i = 0; i <  ywWorkorder.getDealFileList().size(); i++) {
                Multifile multifile =  ywWorkorder.getDealFileList().get(i);
                if(StringUtils.isBlank(multifile.getFileurl())){
                    continue;
                }
                multifile.setCreateDate(update.getEditDate());
                multifile.setCreator(update.getEditor());
                multifile.setEditDate(update.getEditDate());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(model.getId());
                multifile.setEditor(update.getEditor());
                multifile.setObjType(Constants.MultiFile.YW_WORKORDER_DEAL.getKey());
                multifile.setSortnum(i+1);
                fileList.add(multifile);
            }
        }
        if(fileList.size()>0){
            multifileMapper.insert(fileList);
        }
        dealLogBiz(model,Constants.YwLogType.WORKORDER_DEAL,ywWorkorder.getLoginUserInfo().getRealname(),null);//记录新建日志
    }
    @Override
    @Transactional(rollbackFor = {BusinessException.class,Exception.class})
    public void updateById(YwWorkorder model) {
        dealParamValid(model);
        model.setEditDate(new Date());
        model.setEditor(model.getLoginUserInfo().getId());
        ywWorkorderMapper.updateById(model);

        List<Multifile> fileList = new ArrayList<>();
        if(model.getFileList()!=null && model.getFileList().size()>0){
            for (int i = 0; i <  model.getFileList().size(); i++) {
                Multifile multifile =  model.getFileList().get(i);
                if(StringUtils.isBlank(multifile.getFileurl())){
                    continue;
                }
                multifile.setCreateDate(new Date());
                multifile.setCreator(model.getEditor());
                multifile.setIsdeleted(Constants.ZERO);
                multifile.setObjId(model.getId());
                multifile.setCreator(model.getCreator());
                multifile.setObjType(Constants.MultiFile.YW_WORKORDER_PROBLEM.getKey());
                multifile.setSortnum(i+1);
                fileList.add(multifile);
            }
        }
        multifileMapper.update(null,new UpdateWrapper<Multifile>().lambda()
                .set(Multifile::getIsdeleted,Constants.ONE)
                .set(Multifile::getEditDate,model.getEditDate())
                .set(Multifile::getEditor,model.getEditor())
                .eq(Multifile::getIsdeleted, Constants.ZERO)
                .eq(Multifile::getObjType,Constants.MultiFile.YW_WORKORDER_PROBLEM.getKey())
        );
        if(fileList.size()>0){
            multifileMapper.insert(fileList);
        }
    }
    private void initFiles(YwWorkorder model) {
        List<Multifile> multifiles = multifileMapper.selectList(new QueryWrapper<Multifile>().lambda()
                .eq(Multifile::getObjId, model.getId() )
                .in(Multifile::getObjType, Arrays.asList(new Integer[]{Constants.MultiFile.YW_WORKORDER_PROBLEM.getKey()
                        ,Constants.MultiFile.YW_WORKORDER_DEAL.getKey() }))
                .eq(Multifile::getIsdeleted,Constants.ZERO));
        if(multifiles!=null){
            String path = systemDictDataBiz.queryByCode(Constants.FTP,Constants.FTP_RESOURCE_PATH).getCode()
                    +systemDictDataBiz.queryByCode(Constants.FTP,Constants.YW_WORKORDER_FILE).getCode();
            for(Multifile f : multifiles){
                if(StringUtils.isBlank(f.getFileurl())){
                    continue;
                }
                f.setFileurlFull(path+f.getFileurl());
                if(Constants.equalsInteger(f.getObjType(),Constants.MultiFile.YW_WORKORDER_PROBLEM.getKey())){
                    //现场情况
                    if(model.getFileList() == null){
                        model.setFileList(new ArrayList<>());
                    }
                    model.getFileList().add(f);
                }
                if(Constants.equalsInteger(f.getObjType(),Constants.MultiFile.YW_WORKORDER_DEAL.getKey())){
                    //处理附件
                    if(model.getDealFileList() == null){
                        model.setDealFileList(new ArrayList<>());
                    }
                    model.getDealFileList().add(f);
                }

            }
        }
    }
    @Override
    public void updateByIdInBatch(List<YwWorkorder> ywWorkorders) {
        if (CollectionUtils.isEmpty(ywWorkorders)) {
            return;
        }
        for (YwWorkorder ywWorkorder: ywWorkorders) {
            this.updateById(ywWorkorder);
        }
    }

    @Override
    public YwWorkorder findById(Integer id) {
        MPJLambdaWrapper<YwWorkorder> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(YwWorkorder.class )
                .selectAs(SystemUser::getRealname,YwWorkorder::getDealUserName)
                .selectAs(Company::getName,YwWorkorder::getDealUserCompany)
                .select("t3.realname",YwWorkorder::getCreatorName)
                .select("t3.mobile",YwWorkorder::getCreatorMobile)
                .select("t9.name",YwWorkorder::getCreatorCompany)
                .selectAs(Category::getName,YwWorkorder::getCategoryName)
                .selectAs(YwRoom::getName,YwWorkorder::getRoomName)
                .selectAs(YwRoom::getRoomNum,YwWorkorder::getRoomNum)
                .selectAs(YwFloor::getName,YwWorkorder::getFloorName)
                .selectAs(YwBuilding::getName,YwWorkorder::getBuildingName)
                .selectAs(YwProject::getName,YwWorkorder::getProjectName)
                .leftJoin(SystemUser.class,SystemUser::getId,YwWorkorder::getDealUserId)
                .leftJoin(Category.class,Category::getId,YwWorkorder::getCateId)
                .leftJoin(SystemUser.class,SystemUser::getId,YwWorkorder::getCreator)
                .leftJoin(Company.class,Company::getId,SystemUser::getCompanyId)
                .leftJoin(YwRoom.class,YwRoom::getId,YwWorkorder::getRoomId)
                .leftJoin(YwFloor.class,YwFloor::getId,YwWorkorder::getFloorId)
                .leftJoin(YwBuilding.class,YwBuilding::getId,YwWorkorder::getBuildingId)
                .leftJoin(YwProject.class,YwProject::getId,YwWorkorder::getProjectId)
                .leftJoin(" company t9 on t9.id = t1.company_id  ")
                .eq(YwWorkorder::getId,id);
        YwWorkorder model = ywWorkorderMapper.selectJoinOne(YwWorkorder.class,queryWrapper);
        initFiles(model);//读取附件信息
        YwWorkorderLog log = new YwWorkorderLog();
        log.setJobId(model.getId());
        log.setIsdeleted(Constants.ZERO);
        model.setLogList(ywWorkorderLogMapper.selectList(new QueryWrapper<YwWorkorderLog>(log)
                 .lambda()
                 .in(YwWorkorderLog::getObjType,Constants.YwLogType.WORKORDER_DEAL.getKey()
                 ,Constants.YwLogType.WORKORDER_CREATE.getKey()
                   ,Constants.YwLogType.WORKORDER_DISPATCH.getKey())
                .orderByAsc(YwWorkorderLog::getCreateDate)));
        return model;
    }

    @Override
    public YwWorkorder findOne(YwWorkorder ywWorkorder) {
        QueryWrapper<YwWorkorder> wrapper = new QueryWrapper<>(ywWorkorder);
        return ywWorkorderMapper.selectOne(wrapper);
    }

    @Override
    public List<YwWorkorder> findList(YwWorkorder ywWorkorder) {
        ywWorkorder.setIsdeleted(Constants.ZERO);
        QueryWrapper<YwWorkorder> wrapper = new QueryWrapper<>(ywWorkorder);
        return ywWorkorderMapper.selectList(wrapper);
    }
  
    @Override
    public PageData<YwWorkorder> findPage(PageWrap<YwWorkorder> pageWrap) {
        IPage<YwWorkorder> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
        MPJLambdaWrapper<YwWorkorder> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.selectAll(YwWorkorder.class )
                .selectAs(SystemUser::getRealname,YwWorkorder::getDealUserName)
                .select("t3.realname",YwWorkorder::getCreatorName)
                .selectAs(Category::getName,YwWorkorder::getCategoryName)
                .selectAs(YwRoom::getName,YwWorkorder::getRoomName)
                .selectAs(YwRoom::getRoomNum,YwWorkorder::getRoomNum)
                .selectAs(YwFloor::getName,YwWorkorder::getFloorName)
                .selectAs(YwBuilding::getName,YwWorkorder::getBuildingName)
                .selectAs(YwProject::getName,YwWorkorder::getProjectName)
                .leftJoin(SystemUser.class,SystemUser::getId,YwWorkorder::getDealUserId)
                .leftJoin(Category.class,Category::getId,YwWorkorder::getCateId)
                .leftJoin(SystemUser.class,SystemUser::getId,YwWorkorder::getCreator)
                .leftJoin(YwRoom.class,YwRoom::getId,YwWorkorder::getRoomId)
                .leftJoin(YwFloor.class,YwFloor::getId,YwWorkorder::getFloorId)
                .leftJoin(YwBuilding.class,YwBuilding::getId,YwWorkorder::getBuildingId)
                .leftJoin(YwProject.class,YwProject::getId,YwBuilding::getProjectId)
                .apply(StringUtils.isNotBlank(pageWrap.getModel().getQueryStatus())," find_in_set(t.DEAL_STATUS ,'"+pageWrap.getModel().getQueryStatus()+"') ");
        pageWrap.getModel().setIsdeleted(Constants.ZERO);
        Utils.MP.blankToNull(pageWrap.getModel());
        if (pageWrap.getModel().getId() != null) {
            queryWrapper.eq(YwWorkorder::getId, pageWrap.getModel().getId());
        }
        if (pageWrap.getModel().getDispatchUserId() != null) {
            queryWrapper.eq(YwWorkorder::getDispatchUserId, pageWrap.getModel().getDispatchUserId());
        }
        if(Objects.nonNull(pageWrap.getModel().getRoomName())){
            queryWrapper.and(i->i.like(YwFloor::getName,pageWrap.getModel().getRoomName()).or()
                    .like(YwRoom::getRoomNum,pageWrap.getModel().getRoomName())
            );
        }
        if (pageWrap.getModel().getCreator() != null) {
            queryWrapper.eq(YwWorkorder::getCreator, pageWrap.getModel().getCreator());
        }
        if (pageWrap.getModel().getCreateDate() != null) {
            queryWrapper.ge(YwWorkorder::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate()));
            queryWrapper.le(YwWorkorder::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate()));
        }
        if (pageWrap.getModel().getEditor() != null) {
            queryWrapper.eq(YwWorkorder::getEditor, pageWrap.getModel().getEditor());
        }
        if (pageWrap.getModel().getEditDate() != null) {
            queryWrapper.ge(YwWorkorder::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate()));
            queryWrapper.le(YwWorkorder::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate()));
        }
        if (pageWrap.getModel().getIsdeleted() != null) {
            queryWrapper.eq(YwWorkorder::getIsdeleted, pageWrap.getModel().getIsdeleted());
        }
        if (pageWrap.getModel().getTitle() != null) {
            queryWrapper.eq(YwWorkorder::getTitle, pageWrap.getModel().getTitle());
        }
        if (pageWrap.getModel().getRemark() != null) {
            queryWrapper.eq(YwWorkorder::getRemark, pageWrap.getModel().getRemark());
        }
        if (pageWrap.getModel().getStatus() != null) {
            queryWrapper.eq(!Constants.equalsInteger(pageWrap.getModel().getStatus(),-1),YwWorkorder::getStatus, pageWrap.getModel().getStatus());
            queryWrapper.in(Constants.equalsInteger(pageWrap.getModel().getStatus(),-1),YwWorkorder::getStatus, Constants.ZERO,Constants.ONE);
        }
        if (pageWrap.getModel().getSortnum() != null) {
            queryWrapper.eq(YwWorkorder::getSortnum, pageWrap.getModel().getSortnum());
        }
        if (pageWrap.getModel().getContent() != null) {
            queryWrapper.eq(YwWorkorder::getContent, pageWrap.getModel().getContent());
        }
        if (pageWrap.getModel().getGetDate() != null) {
            queryWrapper.ge(YwWorkorder::getGetDate, Utils.Date.getStart(pageWrap.getModel().getGetDate()));
            queryWrapper.le(YwWorkorder::getGetDate, Utils.Date.getEnd(pageWrap.getModel().getGetDate()));
        }
        if (pageWrap.getModel().getProjectId() != null) {
            queryWrapper.eq(YwWorkorder::getProjectId, pageWrap.getModel().getProjectId());
        }
        if (pageWrap.getModel().getBuildingId() != null) {
            queryWrapper.eq(YwWorkorder::getBuildingId, pageWrap.getModel().getBuildingId());
        }
        if (pageWrap.getModel().getRoomId() != null) {
            queryWrapper.eq(YwWorkorder::getRoomId, pageWrap.getModel().getRoomId());
        }
        if (pageWrap.getModel().getUserId() != null) {
            queryWrapper.eq(YwWorkorder::getUserId, pageWrap.getModel().getUserId());
        }
        if (pageWrap.getModel().getPhone() != null) {
            queryWrapper.eq(YwWorkorder::getPhone, pageWrap.getModel().getPhone());
        }
        if (pageWrap.getModel().getSubmitDate() != null) {
            queryWrapper.ge(YwWorkorder::getSubmitDate, Utils.Date.getStart(pageWrap.getModel().getSubmitDate()));
            queryWrapper.le(YwWorkorder::getSubmitDate, Utils.Date.getEnd(pageWrap.getModel().getSubmitDate()));
        }
        if (pageWrap.getModel().getCateId() != null) {
            queryWrapper.eq(YwWorkorder::getCateId, pageWrap.getModel().getCateId());
        }
        if (pageWrap.getModel().getAreaType() != null) {
            queryWrapper.eq(YwWorkorder::getAreaType, pageWrap.getModel().getAreaType());
        }
        if (pageWrap.getModel().getCode() != null) {
            queryWrapper.eq(YwWorkorder::getCode, pageWrap.getModel().getCode());
        }
        if (pageWrap.getModel().getDealStatus() != null) {
            queryWrapper.eq(YwWorkorder::getDealStatus, pageWrap.getModel().getDealStatus());
        }
        if (pageWrap.getModel().getDispatchDate() != null) {
            queryWrapper.ge(YwWorkorder::getDispatchDate, Utils.Date.getStart(pageWrap.getModel().getDispatchDate()));
            queryWrapper.le(YwWorkorder::getDispatchDate, Utils.Date.getEnd(pageWrap.getModel().getDispatchDate()));
        }
        if (pageWrap.getModel().getDispatchInfo() != null) {
            queryWrapper.eq(YwWorkorder::getDispatchInfo, pageWrap.getModel().getDispatchInfo());
        }
        if (pageWrap.getModel().getDealUserId() != null) {
            queryWrapper.eq(YwWorkorder::getDealUserId, pageWrap.getModel().getDealUserId());
        }
        if (pageWrap.getModel().getDealDate() != null) {
            queryWrapper.ge(YwWorkorder::getDealDate, Utils.Date.getStart(pageWrap.getModel().getDealDate()));
            queryWrapper.le(YwWorkorder::getDealDate, Utils.Date.getEnd(pageWrap.getModel().getDealDate()));
        }
        if (pageWrap.getModel().getDealInfo() != null) {
            queryWrapper.eq(YwWorkorder::getDealInfo, pageWrap.getModel().getDealInfo());
        }
        if (pageWrap.getModel().getDealType() != null) {
            queryWrapper.eq(YwWorkorder::getDealType, pageWrap.getModel().getDealType());
        }
        for(PageWrap.SortData sortData: pageWrap.getSorts()) {
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) {
                queryWrapper.orderByDesc(sortData.getProperty());
            } else {
                queryWrapper.orderByAsc(sortData.getProperty());
            }
        }
        if(StringUtils.isNotBlank(pageWrap.getModel().getBuildingName())){
            queryWrapper.and(rw ->{
                rw.like(YwBuilding::getName,pageWrap.getModel().getBuildingName()).or()
                        .like(YwRoom::getName,pageWrap.getModel().getBuildingName());
            });
        }
        queryWrapper.ge(Objects.nonNull(pageWrap.getModel().getQueryStartTime()), YwWorkorder::getCreateDate, pageWrap.getModel().getQueryStartTime())
                .le(Objects.nonNull(pageWrap.getModel().getQueryEndTime()), YwWorkorder::getCreateDate, pageWrap.getModel().getQueryEndTime());
        queryWrapper.orderByDesc(YwContract::getCreateDate );

        PageData<YwWorkorder> result =   PageData.from(ywWorkorderMapper.selectPage(page, queryWrapper));
        if(result!=null && result.getRecords()!=null){
            for(YwWorkorder m : result.getRecords()){
                if(Constants.equalsInteger(m.getAreaType(),Constants.ZERO)){
                        //0室内维修
                    m.setAreaNameInfo(StringUtils.defaultString(m.getBuildingName(),"")+"/"+StringUtils.defaultString(m.getRoomNum(),""));
                }else{
                    m.setAreaNameInfo(StringUtils.defaultString(m.getBuildingName(),"")+"/"+StringUtils.defaultString(m.getFloorName(),""));
                }
            }
        }
        return result;
    }

    @Override
    public long count(YwWorkorder ywWorkorder) {
        QueryWrapper<YwWorkorder> wrapper = new QueryWrapper<>(ywWorkorder);
        return ywWorkorderMapper.selectCount(wrapper);
    }
}