package com.doumee.service.business.impl; 
 | 
  
 | 
import cn.hutool.core.lang.PatternPool; 
 | 
import cn.hutool.core.lang.Validator; 
 | 
import cn.hutool.core.util.ReUtil; 
 | 
import com.doumee.core.haikang.model.HKConstants; 
 | 
import com.doumee.core.model.PageData; 
 | 
import com.doumee.core.model.PageWrap; 
 | 
import com.doumee.core.utils.Constants; 
 | 
import com.doumee.core.utils.DateUtil; 
 | 
import com.doumee.core.utils.Utils; 
 | 
import com.doumee.dao.admin.response.DeviceEventDTO; 
 | 
import com.doumee.dao.business.DeviceEventMapper; 
 | 
import com.doumee.dao.business.join.DeviceEventJoinMapper; 
 | 
import com.doumee.dao.business.model.*; 
 | 
import com.doumee.dao.business.vo.DeviceEventVo; 
 | 
import com.doumee.dao.system.SystemDictDataMapper; 
 | 
import com.doumee.dao.system.model.SystemDictData; 
 | 
import com.doumee.service.business.DeviceEventService; 
 | 
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.springframework.beans.factory.annotation.Autowired; 
 | 
import org.springframework.stereotype.Service; 
 | 
import org.springframework.util.CollectionUtils; 
 | 
  
 | 
import java.text.ParseException; 
 | 
import java.util.*; 
 | 
import java.util.function.Function; 
 | 
import java.util.stream.Collectors; 
 | 
  
 | 
/** 
 | 
 * 门禁事件推送记录表Service实现 
 | 
 * @author 江蹄蹄 
 | 
 * @date 2023/11/30 15:33 
 | 
 */ 
 | 
@Service 
 | 
public class DeviceEventServiceImpl implements DeviceEventService { 
 | 
  
 | 
    @Autowired 
 | 
    private DeviceEventMapper deviceEventMapper; 
 | 
  
 | 
  
 | 
    @Autowired 
 | 
    private DeviceEventJoinMapper deviceEventJoinMapper; 
 | 
  
 | 
    @Autowired 
 | 
    private SystemDictDataMapper systemDictDataMapper; 
 | 
  
 | 
    @Override 
 | 
    public Integer create(DeviceEvent deviceEvent) { 
 | 
        deviceEventMapper.insert(deviceEvent); 
 | 
        return deviceEvent.getId(); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void deleteById(Integer id) { 
 | 
        deviceEventMapper.deleteById(id); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void delete(DeviceEvent deviceEvent) { 
 | 
        UpdateWrapper<DeviceEvent> deleteWrapper = new UpdateWrapper<>(deviceEvent); 
 | 
        deviceEventMapper.delete(deleteWrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void deleteByIdInBatch(List<Integer> ids) { 
 | 
        if (CollectionUtils.isEmpty(ids)) { 
 | 
            return; 
 | 
        } 
 | 
        deviceEventMapper.deleteBatchIds(ids); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void updateById(DeviceEvent deviceEvent) { 
 | 
        deviceEventMapper.updateById(deviceEvent); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void updateByIdInBatch(List<DeviceEvent> deviceEvents) { 
 | 
        if (CollectionUtils.isEmpty(deviceEvents)) { 
 | 
            return; 
 | 
        } 
 | 
        for (DeviceEvent deviceEvent: deviceEvents) { 
 | 
            this.updateById(deviceEvent); 
 | 
        } 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public DeviceEvent findById(Integer id) { 
 | 
        return deviceEventMapper.selectById(id); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public DeviceEvent findOne(DeviceEvent deviceEvent) { 
 | 
        QueryWrapper<DeviceEvent> wrapper = new QueryWrapper<>(deviceEvent); 
 | 
        return deviceEventMapper.selectOne(wrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<DeviceEvent> findList(DeviceEvent deviceEvent) { 
 | 
        QueryWrapper<DeviceEvent> wrapper = new QueryWrapper<>(deviceEvent); 
 | 
        return deviceEventMapper.selectList(wrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public PageData<DeviceEvent> findPage(PageWrap<DeviceEvent> pageWrap) { 
 | 
        IPage<DeviceEvent> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity()); 
 | 
        QueryWrapper<DeviceEvent> queryWrapper = new QueryWrapper<>(); 
 | 
        Utils.MP.blankToNull(pageWrap.getModel()); 
 | 
        if (pageWrap.getModel().getId() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getId, pageWrap.getModel().getId()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getCreator() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getCreator, pageWrap.getModel().getCreator()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getCreateDate() != null) { 
 | 
            queryWrapper.lambda().ge(DeviceEvent::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate())); 
 | 
            queryWrapper.lambda().le(DeviceEvent::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEditor() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getEditor, pageWrap.getModel().getEditor()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEditDate() != null) { 
 | 
            queryWrapper.lambda().ge(DeviceEvent::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate())); 
 | 
            queryWrapper.lambda().le(DeviceEvent::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIsdeleted() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getIsdeleted, pageWrap.getModel().getIsdeleted()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getRemark() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getRemark, pageWrap.getModel().getRemark()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEventId() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getEventId, pageWrap.getModel().getEventId()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEventType() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getEventType, pageWrap.getModel().getEventType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSrcType() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getSrcType, pageWrap.getModel().getSrcType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getHappenTime() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getHappenTime, pageWrap.getModel().getHappenTime()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSrcIndex() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getSrcIndex, pageWrap.getModel().getSrcIndex()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSrcName() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getSrcName, pageWrap.getModel().getSrcName()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getStatus() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getStatus, pageWrap.getModel().getStatus()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getTimeout() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getTimeout, pageWrap.getModel().getTimeout()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtAccessChannel() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtAccessChannel, pageWrap.getModel().getExtAccessChannel()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventAlarmInID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventAlarmInID, pageWrap.getModel().getExtEventAlarmInID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventAlarmOutID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventAlarmOutID, pageWrap.getModel().getExtEventAlarmOutID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventCardNo() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventCardNo, pageWrap.getModel().getExtEventCardNo()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventCaseID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventCaseID, pageWrap.getModel().getExtEventCaseID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventCode() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventCode, pageWrap.getModel().getExtEventCode()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventDoorID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventDoorID, pageWrap.getModel().getExtEventDoorID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventIDCardPictureURL() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventIDCardPictureURL, pageWrap.getModel().getExtEventIDCardPictureURL()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventInOut() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventInOut, pageWrap.getModel().getExtEventInOut()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventLocalControllerID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventLocalControllerID, pageWrap.getModel().getExtEventLocalControllerID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventMainDevID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventMainDevID, pageWrap.getModel().getExtEventMainDevID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventPersonNo() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventPersonNo, pageWrap.getModel().getExtEventPersonNo()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventReaderKind() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventReaderKind, pageWrap.getModel().getExtEventReaderKind()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventReaderID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventReaderID, pageWrap.getModel().getExtEventReaderID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventPictureURL() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventPictureURL, pageWrap.getModel().getExtEventPictureURL()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSvrIndexCode() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getSvrIndexCode, pageWrap.getModel().getSvrIndexCode()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventReportChannel() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventReportChannel, pageWrap.getModel().getExtEventReportChannel()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventRoleID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventRoleID, pageWrap.getModel().getExtEventRoleID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventEubDevID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventEubDevID, pageWrap.getModel().getExtEventEubDevID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventEwipNum() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventEwipNum, pageWrap.getModel().getExtEventEwipNum()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventType() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventType, pageWrap.getModel().getExtEventType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventVerifyID() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventVerifyID, pageWrap.getModel().getExtEventVerifyID()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtEventWhiteListNo() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtEventWhiteListNo, pageWrap.getModel().getExtEventWhiteListNo()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExtReceiveTime() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExtReceiveTime, pageWrap.getModel().getExtReceiveTime()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSeq() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getSeq, pageWrap.getModel().getSeq()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getUserType() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getUserType, pageWrap.getModel().getUserType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getAddress() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getAddress, pageWrap.getModel().getAddress()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getBirth() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getBirth, pageWrap.getModel().getBirth()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEndDate() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getEndDate, pageWrap.getModel().getEndDate()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIdNum() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getIdNum, pageWrap.getModel().getIdNum()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIssuingAuthority() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getIssuingAuthority, pageWrap.getModel().getIssuingAuthority()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getName() != null) { 
 | 
            queryWrapper.lambda().like(DeviceEvent::getName, pageWrap.getModel().getName()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSex() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getSex, pageWrap.getModel().getSex()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getStartDate() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getStartDate, pageWrap.getModel().getStartDate()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getTermOfValidity() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getTermOfValidity, pageWrap.getModel().getTermOfValidity()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getAccessChannel() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getAccessChannel, pageWrap.getModel().getAccessChannel()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEntryTimes() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getEntryTimes, pageWrap.getModel().getEntryTimes()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getExitTimes() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getExitTimes, pageWrap.getModel().getExitTimes()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getTotalTimes() != null) { 
 | 
            queryWrapper.lambda().eq(DeviceEvent::getTotalTimes, pageWrap.getModel().getTotalTimes()); 
 | 
        } 
 | 
        for(PageWrap.SortData sortData: pageWrap.getSorts()) { 
 | 
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) { 
 | 
                queryWrapper.orderByDesc(sortData.getProperty()); 
 | 
            } else { 
 | 
                queryWrapper.orderByAsc(sortData.getProperty()); 
 | 
            } 
 | 
        } 
 | 
        return PageData.from(deviceEventMapper.selectPage(page, queryWrapper)); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public long count(DeviceEvent deviceEvent) { 
 | 
        QueryWrapper<DeviceEvent> wrapper = new QueryWrapper<>(deviceEvent); 
 | 
        return deviceEventMapper.selectCount(wrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public PageData<DeviceEventDTO> findDeviceEventDTOPage(PageWrap<DeviceEvent> pageWrap) { 
 | 
  
 | 
        IPage<DeviceEventDTO> deviceEventDTOIPage = getDataInfo(pageWrap); 
 | 
        if(null != deviceEventDTOIPage && deviceEventDTOIPage.getRecords().size() > 0) { 
 | 
            deviceEventDTOIPage.setRecords(newDeviceEvent(deviceEventDTOIPage.getRecords())); 
 | 
        } 
 | 
        return PageData.from(deviceEventDTOIPage); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<DeviceEventVo> findDeviceEventExcel(PageWrap<DeviceEvent> pageWrap) { 
 | 
        IPage<DeviceEventDTO> deviceEventExcel = getDataInfo(pageWrap); 
 | 
        List<DeviceEventVo> voList = new ArrayList<>(); 
 | 
        if(null != deviceEventExcel && deviceEventExcel.getRecords().size() > 0) { 
 | 
            deviceEventExcel.getRecords().stream().forEach(obj-> { 
 | 
                DeviceEventVo eventVo = new DeviceEventVo(); 
 | 
                if(null != obj.getPersonType()) { 
 | 
                    if(Constants.ZERO == obj.getPersonType()){ 
 | 
                        eventVo.setPersonTypeName(Constants.Status.LW_FK.getDes()); 
 | 
                    }else if(Constants.ONE == obj.getPersonType()) { 
 | 
                        eventVo.setPersonTypeName(Constants.Status.PT_FK.getDes()); 
 | 
                    }else { 
 | 
                        eventVo.setPersonTypeName(Constants.Status.NB_FK.getDes()); 
 | 
                    } 
 | 
                }else { 
 | 
                    eventVo.setPersonTypeName(""); 
 | 
                } 
 | 
                eventVo.setPersonName(obj.getPersonName()); 
 | 
                eventVo.setPersonPhone(obj.getPersonName()); 
 | 
                eventVo.setPersonIdcardDecode(obj.getPersonIdcardDecode()); 
 | 
                eventVo.setPersonCompanyName(obj.getPersonCompanyName()); 
 | 
                eventVo.setDevName(obj.getDevName()); 
 | 
                eventVo.setSrcName(obj.getSrcName()); 
 | 
                if(null != obj.getExtEventInOut()) { 
 | 
                    if(Constants.ZERO == obj.getExtEventInOut()){ 
 | 
                        eventVo.setExtEventInOutName(Constants.Status.OUT.getDes()); 
 | 
                    }else if(Constants.ONE == obj.getPersonType()) { 
 | 
                        eventVo.setExtEventInOutName(Constants.Status.PT_FK.getDes()); 
 | 
                    } 
 | 
                }else { 
 | 
                    eventVo.setExtEventInOutName(""); 
 | 
                } 
 | 
                eventVo.setEventTypeName(HKConstants.EventTypes.getName(obj.getEventType())) ; 
 | 
                try { 
 | 
                    eventVo.setHappenTime(DateUtil.timeEscape(obj.getHappenTime())); 
 | 
                } catch (ParseException e) { 
 | 
                    e.printStackTrace(); 
 | 
                } 
 | 
                voList.add(eventVo); 
 | 
            }); 
 | 
        } 
 | 
        return voList; 
 | 
    } 
 | 
  
 | 
    private IPage<DeviceEventDTO> getDataInfo(PageWrap<DeviceEvent> pageWrap) { 
 | 
        IPage<DeviceEvent> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity()); 
 | 
        MPJLambdaWrapper<DeviceEvent> queryWrapper = new MPJLambdaWrapper<>(); 
 | 
        Utils.MP.blankToNull(pageWrap.getModel()); 
 | 
  
 | 
        //是否是数字 
 | 
        boolean number = Validator.isNumber(pageWrap.getModel().getKeyWords()); 
 | 
        //是否包含中文 
 | 
        boolean b = Validator.hasChinese(pageWrap.getModel().getKeyWords()); 
 | 
        //是否包含英文 
 | 
        boolean hasWord = ReUtil.contains(PatternPool.WORD, pageWrap.getModel().getKeyWords()); 
 | 
        queryWrapper.leftJoin(Member.class,Member::getHkId,DeviceEvent::getExtEventPersonNo) 
 | 
                .leftJoin(Company.class,Company::getId,Member::getCompanyId) 
 | 
                .leftJoin(Device.class,Device::getHkId,DeviceEvent::getSrcParentIndex) 
 | 
                .selectAll(DeviceEvent.class) 
 | 
                .selectAs(Member::getName,DeviceEventDTO::getPersonName) 
 | 
                .selectAs(Member::getId,DeviceEventDTO::getMemberId) 
 | 
                .selectAs(Member::getType,DeviceEventDTO::getPersonType) 
 | 
                .selectAs(Member::getPhone,DeviceEventDTO::getPersonPhone) 
 | 
                .selectAs(Member::getIdcardDecode,DeviceEventDTO::getPersonIdcardDecode) 
 | 
                .selectAs(Device::getName,DeviceEventDTO::getDevName) 
 | 
                .selectAs(Company::getName,DeviceEventDTO::getPersonCompanyName) 
 | 
                .selectAs(Company::getType,DeviceEventDTO::getCompanyType); 
 | 
  
 | 
        queryWrapper.and(StringUtils.isNotBlank(pageWrap.getModel().getKeyWords()),w-> 
 | 
                        w.like(Member::getName,pageWrap.getModel().getKeyWords()).or().like(Member::getPhone,pageWrap.getModel().getKeyWords())) 
 | 
  
 | 
  
 | 
                .eq( pageWrap.getModel().getQueryUserType()!=null&&Constants.equalsInteger(pageWrap.getModel().getQueryUserType(),Constants.ONE), 
 | 
                        Company::getType, Constants.ZERO) 
 | 
  
 | 
                .isNull( pageWrap.getModel().getQueryUserType()!=null&&Constants.equalsInteger(pageWrap.getModel().getQueryUserType(),Constants.ZERO), 
 | 
                        Member::getCompanyId) 
 | 
  
 | 
                .eq( pageWrap.getModel().getQueryUserType()!=null&&Constants.equalsInteger(pageWrap.getModel().getQueryUserType(),Constants.TWO), 
 | 
                        Company::getType, Constants.ONE) 
 | 
  
 | 
                .eq(Member::getIsdeleted,Constants.ZERO) 
 | 
  
 | 
                .eq(Objects.nonNull(pageWrap.getModel().getEventType()), 
 | 
                        DeviceEvent::getEventType, 
 | 
                        pageWrap.getModel().getEventType()) 
 | 
                .like(Objects.nonNull(pageWrap.getModel().getCompanyName()),Company::getName, 
 | 
                        pageWrap.getModel().getCompanyName()) 
 | 
                .ge(Objects.nonNull(pageWrap.getModel().getStartTime()), 
 | 
                        DeviceEvent::getCreateDate, 
 | 
                        pageWrap.getModel().getStartTime()) 
 | 
                .le(Objects.nonNull(pageWrap.getModel().getEndTime()), 
 | 
                        DeviceEvent::getCreateDate, 
 | 
                        pageWrap.getModel().getEndTime()) 
 | 
  
 | 
                .orderByDesc(DeviceEvent::getCreateDate); 
 | 
        queryWrapper.orderByDesc(DeviceEvent::getHappenTime); 
 | 
        IPage<DeviceEventDTO> deviceEventDTOIPage = deviceEventJoinMapper.selectJoinPage(page, DeviceEventDTO.class, queryWrapper); 
 | 
        return deviceEventDTOIPage; 
 | 
    } 
 | 
  
 | 
    // 对图片进行判断处理 
 | 
    private List<DeviceEventDTO> newDeviceEvent(List<DeviceEventDTO> DeviceEventDTOList) { 
 | 
        List<DeviceEventDTO> newDeviceEventDTOS = new ArrayList<>(); 
 | 
        List<String> codes = Arrays.asList(Constants.FTP_RESOURCE_PATH,Constants.DEVICE_EVENT_IMG); 
 | 
        List<SystemDictData> list = systemDictDataMapper.list(codes); 
 | 
        Map<String,SystemDictData> dataMap = list.stream().collect(Collectors.toMap(SystemDictData::getLabel, Function.identity())); 
 | 
        for (DeviceEventDTO dto:DeviceEventDTOList) { 
 | 
           if(StringUtils.isNotBlank(dto.getExtEventPictureURL()) 
 | 
                   && !dto.getExtEventPictureURL().startsWith(HKConstants.IMG_INDEX) 
 | 
                   && !dto.getExtEventPictureURL().startsWith(HKConstants.IMG_INDEX_ERROR)) { 
 | 
                   if(null != list && list.size() > 0) { 
 | 
                           dto.setExtEventPictureURL(dataMap.get(Constants.FTP_RESOURCE_PATH).getCode() 
 | 
                                   +dataMap.get(Constants.DEVICE_EVENT_IMG).getCode() 
 | 
                                   +dto.getExtEventPictureURL()); 
 | 
                   } 
 | 
           }else{ 
 | 
               dto.setExtEventPictureURL(null); 
 | 
           } 
 | 
            dto.setEventTypeName(HKConstants.EventTypes.getName(dto.getEventType())) ; 
 | 
            try { 
 | 
                dto.setHappenTime(DateUtil.timeEscape(dto.getHappenTime())); 
 | 
            } catch (ParseException e) { 
 | 
                e.printStackTrace(); 
 | 
            } 
 | 
            newDeviceEventDTOS.add(dto); 
 | 
        } 
 | 
        return newDeviceEventDTOS; 
 | 
    } 
 | 
} 
 |