package com.doumee.service.business.impl; 
 | 
  
 | 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 
 | 
import com.doumee.core.constants.ResponseStatus; 
 | 
import com.doumee.core.exception.BusinessException; 
 | 
import com.doumee.core.haikang.model.HKConstants; 
 | 
import com.doumee.core.haikang.model.param.BaseResponse; 
 | 
import com.doumee.core.haikang.model.param.request.AcsDeviceListRequest; 
 | 
import com.doumee.core.haikang.model.param.respose.AcsDeviceInfoResponse; 
 | 
import com.doumee.core.haikang.model.param.respose.AcsDeviceListResponse; 
 | 
import com.doumee.core.haikang.service.HKService; 
 | 
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.DeviceMapper; 
 | 
import com.doumee.dao.business.model.Company; 
 | 
import com.doumee.dao.business.model.Device; 
 | 
import com.doumee.dao.business.model.Retention; 
 | 
import com.doumee.service.business.DeviceService; 
 | 
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 org.apache.commons.lang3.StringUtils; 
 | 
import org.springframework.beans.factory.annotation.Autowired; 
 | 
import org.springframework.scheduling.annotation.Async; 
 | 
import org.springframework.stereotype.Service; 
 | 
import org.springframework.util.CollectionUtils; 
 | 
  
 | 
import java.util.ArrayList; 
 | 
import java.util.Date; 
 | 
import java.util.List; 
 | 
import java.util.Objects; 
 | 
  
 | 
/** 
 | 
 * 设备信息表Service实现 
 | 
 * @author 江蹄蹄 
 | 
 * @date 2023/11/30 15:33 
 | 
 */ 
 | 
@Service 
 | 
public class DeviceServiceImpl implements DeviceService { 
 | 
  
 | 
    @Autowired 
 | 
    private DeviceMapper deviceMapper; 
 | 
  
 | 
  
 | 
    @Override 
 | 
    public Integer create(Device device) { 
 | 
        deviceMapper.insert(device); 
 | 
        return device.getId(); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void deleteById(Integer id) { 
 | 
        deviceMapper.deleteById(id); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void delete(Device device) { 
 | 
        UpdateWrapper<Device> deleteWrapper = new UpdateWrapper<>(device); 
 | 
        deviceMapper.delete(deleteWrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void deleteByIdInBatch(List<Integer> ids) { 
 | 
        if (CollectionUtils.isEmpty(ids)) { 
 | 
            return; 
 | 
        } 
 | 
        deviceMapper.deleteBatchIds(ids); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void updateById(Device device) { 
 | 
        deviceMapper.updateById(device); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void updateByIdInBatch(List<Device> devices) { 
 | 
        if (CollectionUtils.isEmpty(devices)) { 
 | 
            return; 
 | 
        } 
 | 
        for (Device device: devices) { 
 | 
            this.updateById(device); 
 | 
        } 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public Device findById(Integer id) { 
 | 
        return deviceMapper.selectById(id); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public Device findOne(Device device) { 
 | 
        QueryWrapper<Device> wrapper = new QueryWrapper<>(device); 
 | 
        return deviceMapper.selectOne(wrapper.last("limit 1")); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<Device> findList(Device device) { 
 | 
        device.setIsdeleted(Constants.ZERO); 
 | 
        QueryWrapper<Device> wrapper = new QueryWrapper<>(device); 
 | 
        return deviceMapper.selectList(wrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<Device> findIdAndNameList(Device param) { 
 | 
        LambdaQueryWrapper<Device> wrapper = new LambdaQueryWrapper<>(param); 
 | 
        param.setIsdeleted(Constants.ZERO); 
 | 
        wrapper.select(Device::getId, Device::getName, Device::getDoorName,Device::getRegionPathName, Device::getRegionName); 
 | 
        if(null != param.getType() && null != param.getIsdeleted() && null != param.getHkStatus()) { 
 | 
            wrapper.eq(Device::getType,param.getType()) 
 | 
                   .eq(Device::getIsdeleted,param.getIsdeleted()) 
 | 
                   .eq(Device::getHkStatus,param.getHkStatus()); 
 | 
        } 
 | 
        return deviceMapper.selectList(wrapper); 
 | 
    } 
 | 
   
 | 
    @Override 
 | 
    public PageData<Device> findPage(PageWrap<Device> pageWrap) { 
 | 
        IPage<Device> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity()); 
 | 
        QueryWrapper<Device> queryWrapper = new QueryWrapper<>(); 
 | 
        Utils.MP.blankToNull(pageWrap.getModel()); 
 | 
        pageWrap.getModel().setIsdeleted(Constants.ZERO); 
 | 
        if (pageWrap.getModel().getId() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getId, pageWrap.getModel().getId()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getCreator() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getCreator, pageWrap.getModel().getCreator()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getCreateDate() != null) { 
 | 
            queryWrapper.lambda().ge(Device::getCreateDate, Utils.Date.getStart(pageWrap.getModel().getCreateDate())); 
 | 
            queryWrapper.lambda().le(Device::getCreateDate, Utils.Date.getEnd(pageWrap.getModel().getCreateDate())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEdirot() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getEdirot, pageWrap.getModel().getEdirot()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getEditDate() != null) { 
 | 
            queryWrapper.lambda().ge(Device::getEditDate, Utils.Date.getStart(pageWrap.getModel().getEditDate())); 
 | 
            queryWrapper.lambda().le(Device::getEditDate, Utils.Date.getEnd(pageWrap.getModel().getEditDate())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIsdeleted() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getIsdeleted, pageWrap.getModel().getIsdeleted()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getRemark() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getRemark, pageWrap.getModel().getRemark()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIsEntrance() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getIsEntrance, pageWrap.getModel().getIsEntrance()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getName() != null) { 
 | 
            queryWrapper.lambda().like(Device::getName, pageWrap.getModel().getName()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getDoorName() != null) { 
 | 
            queryWrapper.lambda().like(Device::getDoorName, pageWrap.getModel().getDoorName()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getRegionPathName() != null) { 
 | 
            queryWrapper.lambda().like(Device::getRegionPathName, pageWrap.getModel().getRegionPathName()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getRegionName() != null) { 
 | 
            queryWrapper.lambda().like(Device::getRegionName, pageWrap.getModel().getRegionName()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getHkId() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getHkId, pageWrap.getModel().getHkId()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getHkStatus() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getHkStatus, pageWrap.getModel().getHkStatus()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getHkDate() != null) { 
 | 
            queryWrapper.lambda().ge(Device::getHkDate, Utils.Date.getStart(pageWrap.getModel().getHkDate())); 
 | 
            queryWrapper.lambda().le(Device::getHkDate, Utils.Date.getEnd(pageWrap.getModel().getHkDate())); 
 | 
        } 
 | 
        if (pageWrap.getModel().getSortnum() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getSortnum, pageWrap.getModel().getSortnum()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getType() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getType, pageWrap.getModel().getType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getResourceType() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getResourceType, pageWrap.getModel().getResourceType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getNo() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getNo, pageWrap.getModel().getNo()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getChannelNo() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getChannelNo, pageWrap.getModel().getChannelNo()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getDevTypeCode() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getDevTypeCode, pageWrap.getModel().getDevTypeCode()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getManufature() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getManufature, pageWrap.getModel().getManufature()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIp() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getIp, pageWrap.getModel().getIp()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getPort() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getPort, pageWrap.getModel().getPort()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getInoutType() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getInoutType, pageWrap.getModel().getInoutType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getLevel() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getLevel, pageWrap.getModel().getLevel()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getIsUsed() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getIsUsed, pageWrap.getModel().getIsUsed()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getOnline() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getOnline, pageWrap.getModel().getOnline()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getKqType() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getKqType, pageWrap.getModel().getKqType()); 
 | 
        } 
 | 
        if (pageWrap.getModel().getStatus() != null) { 
 | 
            queryWrapper.lambda().eq(Device::getStatus, pageWrap.getModel().getStatus()); 
 | 
        } 
 | 
        for(PageWrap.SortData sortData: pageWrap.getSorts()) { 
 | 
            if (sortData.getDirection().equalsIgnoreCase(PageWrap.DESC)) { 
 | 
                queryWrapper.orderByDesc(sortData.getProperty()); 
 | 
            } else { 
 | 
                queryWrapper.orderByAsc(sortData.getProperty()); 
 | 
            } 
 | 
        } 
 | 
        return PageData.from(deviceMapper.selectPage(page, queryWrapper)); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public long count(Device device) { 
 | 
        QueryWrapper<Device> wrapper = new QueryWrapper<>(device); 
 | 
        return deviceMapper.selectCount(wrapper); 
 | 
    } 
 | 
  
 | 
} 
 |