package com.doumee.service.business.impl; 
 | 
  
 | 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 
 | 
import com.doumee.biz.system.SystemDictDataBiz; 
 | 
import com.doumee.core.constants.ResponseStatus; 
 | 
import com.doumee.core.exception.BusinessException; 
 | 
import com.doumee.core.haikang.model.param.request.TransparentChannelSingleRequest; 
 | 
import com.doumee.service.business.third.model.PageData; 
 | 
import com.doumee.service.business.third.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.PlatformBroadcastLogMapper; 
 | 
import com.doumee.dao.business.model.Device; 
 | 
import com.doumee.dao.business.model.PlatformBroadcastLog; 
 | 
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 com.doumee.service.business.impl.hksync.HkSyncPushServiceImpl; 
 | 
import org.springframework.beans.factory.annotation.Autowired; 
 | 
import org.springframework.stereotype.Service; 
 | 
import org.springframework.util.CollectionUtils; 
 | 
  
 | 
import java.util.*; 
 | 
  
 | 
/** 
 | 
 * 设备信息表Service实现 
 | 
 * @author 江蹄蹄 
 | 
 * @date 2023/11/30 15:33 
 | 
 */ 
 | 
@Service 
 | 
public class DeviceServiceImpl implements DeviceService { 
 | 
  
 | 
    @Autowired 
 | 
    private DeviceMapper deviceMapper; 
 | 
    @Autowired 
 | 
    private SystemDictDataBiz systemDictDataBiz; 
 | 
    @Autowired 
 | 
    private PlatformBroadcastLogMapper platformBroadcastLogMapper; 
 | 
  
 | 
  
 | 
    @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); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<Device> findList(Device device) { 
 | 
        QueryWrapper<Device> wrapper = new QueryWrapper<>(device); 
 | 
        return deviceMapper.selectList(wrapper); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public List<Device> findIdAndNameList(Device param) { 
 | 
        LambdaQueryWrapper<Device> wrapper = new LambdaQueryWrapper<>(param); 
 | 
        wrapper.select(Device::getId, Device::getName, Device::getDoorName,Device::getRegionPathName, Device::getRegionName); 
 | 
        wrapper.eq(null != param.getType(),Device::getType,param.getType()) 
 | 
               .eq(null !=param.getIsdeleted(),Device::getIsdeleted,param.getIsdeleted()) 
 | 
               .eq(Objects.isNull(param.getIsdeleted()),Device::getIsdeleted,Constants.ZERO) 
 | 
               .eq(null != param.getHkStatus(),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<>(); 
 | 
        pageWrap.getModel().setIsdeleted(Constants.ZERO); 
 | 
        Utils.MP.blankToNull(pageWrap.getModel()); 
 | 
        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); 
 | 
    } 
 | 
  
 | 
    @Override 
 | 
    public void setLedContent(TransparentChannelSingleRequest model) { 
 | 
        Device device = findById(model.getDeviceId()); 
 | 
        if(device == null 
 | 
                || Constants.equalsInteger(device.getIsdeleted(),Constants.ONE) 
 | 
                || !Constants.equalsInteger(device.getType(),Constants.TWO)){ 
 | 
            throw new BusinessException(ResponseStatus.DATA_EMPTY); 
 | 
        } 
 | 
        if(model.getSpeed()<=0){ 
 | 
            int speed = 13; 
 | 
            try { 
 | 
                speed = Integer.parseInt(systemDictDataBiz.queryByCode(Constants.HK_PARAM,Constants.LED_CONTENT_SPEED).getCode()); 
 | 
            }catch (Exception e){ 
 | 
            } 
 | 
            model.setSpeed(speed); 
 | 
        } 
 | 
        PlatformBroadcastLog log  =  HkSyncPushServiceImpl.dealLedContentBiz(0,device.getNo(),device.getName(),model.getContent(),model.getSpeed(),1); 
 | 
        platformBroadcastLogMapper.insert(log); 
 | 
        if(log.getHkStatus() == null || !Constants.equalsInteger(log.getHkStatus(), Constants.TWO)){ 
 | 
            throw  new BusinessException(ResponseStatus.SERVER_ERROR.getCode(), "对不起,屏幕内容设置失败"+(log!=null?log.getHkInfo():"")); 
 | 
        } 
 | 
    } 
 | 
} 
 |