xy-device/device-api-service/src/main/java/com/xy/service/DeviceRegisterServiceImpl.java

package com.xy.service;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xy.annotation.Lock;
import com.xy.collections.list.JArrayList;
import com.xy.collections.list.JList;
import com.xy.collections.map.JMap;
import com.xy.config.DeviceThreadPoolConfig;
import com.xy.dto.DeviceCreateIdsDto;
import com.xy.dto.DeviceQualityDto;
import com.xy.dto.DeviceRegisterDto;
import com.xy.dto.MqttUserDto;
import com.xy.entity.*;
import com.xy.mapper.*;
import com.xy.utils.*;
import com.xy.utils.consts.CommConsts;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import javax.validation.constraints.NotBlank;
import java.io.IOException;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

import static com.xy.utils.PlusBeans.*;

/**
 * <p>
 * 设备-注册登记 服务实现类
 * </p>
 *
 * @author lijin
 * @since 2022-12-29
 */
@Service
@Api(tags = "设备-注册登记")
@AllArgsConstructor
public class DeviceRegisterServiceImpl extends ServiceImpl<DeviceRegisterMapper, DeviceRegister> implements DeviceRegisterService {

    private DeviceCreateIdsMapper deviceCreateIdsMapper;

    private DeviceInfoMapper deviceInfoMapper;

    private DeviceSysinfoMapper deviceSysinfoMapper;

    private DeviceStatusMapper deviceStatusMapper;

    private DeviceQualityServiceImpl deviceQualityService;

    private MqttUserServiceImpl mqttUserService;

    private DeviceSysinfoServiceImpl deviceSysinfoService;

    private DeviceCreateIdsServiceImpl deviceCreateIdsService;

    @PostMapping("save")
    @ApiOperation("添加")
    @Transactional(rollbackFor = Exception.class)
    @Lock(value = "save.deviceId", prefix = "device_register_")
    public R save(@RequestBody @Validated DeviceRegisterDto.Save save) {
        //重复校验
        DeviceRegister deviceRegister = copy(DeviceRegister.class, save);
        DeviceCreateIds deviceCreateIds = deviceCreateIdsMapper.selectById(deviceRegister.getDeviceId());
        if (deviceCreateIds == null) {
            return R.fail("设备ID不存在");
        }
        if (deviceCreateIds.getBindState()) {
            return R.fail("设备ID已被绑定");
        }
        long count = count(new LambdaQueryWrapper<DeviceRegister>().eq(DeviceRegister::getDeviceSn, save.getDeviceSn()));
        if (count > 0) {
            return R.fail("设备SN已被绑定");
        }
        deviceRegister.setDeviceType(deviceCreateIds.getDeviceType())
                .setCreateUser(AuthorizeUtils.getLoginId(Long.class))
                .setCreateTime(LocalDateTime.now());
        //操作注册序号
        String property = LambdaUtils.getProperty(DeviceRegister::getRegisterNum);
        QueryWrapper<DeviceRegister> queryWrapper = new QueryWrapper<DeviceRegister>()
                .select(String.format("max(%s) as %s", StringTools.humpToLine(property), property))
                .eq(StringTools.humpToLine(LambdaUtils.getProperty(DeviceRegister::getCreateUser)), AuthorizeUtils.getLoginId(Long.class));
        DeviceRegister one = getOne(queryWrapper);
        Integer registerNum = one == null || one.getRegisterNum() == null ? 0 : one.getRegisterNum();
        deviceRegister.setRegisterNum(registerNum + 1);
        //修改设备-机器ID号生成为已绑定
        deviceCreateIdsMapper.updateById(new DeviceCreateIds()
                .setDeviceId(deviceRegister.getDeviceId())
                .setBindState(true)
                .setBindTime(deviceRegister.getCreateTime())
        );
        DeviceInfo deviceInfo = new DeviceInfo()
                .setDeviceId(deviceRegister.getDeviceId())
                .setDeviceType(deviceRegister.getDeviceType())
                .setMercDeviceCode(deviceRegister.getAssetNo())
                .setCreateTime(deviceRegister.getCreateTime());
        DeviceSysinfo deviceSysinfo = new DeviceSysinfo()
                .setDeviceId(deviceRegister.getDeviceId())
                .setDeviceSn(deviceRegister.getDeviceSn())
                .setCreateTime(deviceRegister.getCreateTime());
        DeviceStatus deviceStatus = new DeviceStatus().setDeviceId(deviceRegister.getDeviceId());
        DeviceRegister deviceRegisterById = getById(deviceRegister.getDeviceId());
        //新增
        if (deviceRegisterById == null) {
            //设备-注册登记
            save(deviceRegister);
            //设备信息
            deviceInfoMapper.insert(deviceInfo);
            //设备-系统信息
            deviceSysinfoMapper.insert(deviceSysinfo);
            //设备-状态
            deviceStatusMapper.insert(deviceStatus);
            //mqtt认证信息
            String deviceId = deviceRegister.getDeviceId().toString();
            MqttUserDto.Save mqttUserInfo = new MqttUserDto.Save();
            mqttUserInfo.setUsername(deviceId);
            mqttUserInfo.setPasswordHash(deviceId);
            mqttUserInfo.setCreated(LocalDateTime.now());
            mqttUserInfo.setTopic(deviceId + CommConsts.DEVICE_MQTT_TOPIC_SUFFIX);
            mqttUserInfo.setSn(deviceRegister.getDeviceSn());
            mqttUserInfo.setDeviceId(deviceRegister.getDeviceId());
            mqttUserService.save(mqttUserInfo);
        } else {
            updateById(deviceRegister);
            deviceSysinfoMapper.updateById(deviceSysinfo);
            mqttUserService.update(new LambdaUpdateWrapper<MqttUser>()
                    .set(MqttUser::getSn, deviceRegister.getDeviceSn())
                    .eq(MqttUser::getDeviceId, deviceRegister.getDeviceId())
            );
        }
        return R.ok();
    }

    @PostMapping("page")
    @ApiOperation("分页查询")
    public R<PageBean<DeviceRegisterDto.Vo>> page(@RequestBody DeviceRegisterDto.Page page) {
        PageBean pageBean = page.getPage();
        LambdaQueryWrapper<DeviceRegister> lambdaQueryWrapper = new MybatisPlusQuery().eqWrapper(page, DeviceRegister.class)
                .ge(DeviceRegister::getCreateTime, page.getBeginCreateTime())
                .le(DeviceRegister::getCreateTime, page.getEndCreateTime())
                .likeRight(DeviceRegister::getDeviceSn)
                .build()
                .and(page.getIsBind() != null && page.getIsBind(), deviceRegisterLambdaQueryWrapper -> deviceRegisterLambdaQueryWrapper
                        .isNotNull(DeviceRegister::getDeviceSn)
                        .ne(DeviceRegister::getDeviceSn, "")
                )
                .and(page.getIsBind() != null && !page.getIsBind(), deviceRegisterLambdaQueryWrapper -> deviceRegisterLambdaQueryWrapper
                        .isNull(DeviceRegister::getDeviceSn)
                        .or()
                        .eq(DeviceRegister::getDeviceSn, "")
                )
                .orderByDesc(!Emptys.check(pageBean.getOrders()), DeviceRegister::getCreateTime);
        IPage<DeviceRegister> iPage = page(toIPage(pageBean), lambdaQueryWrapper);
        PageBean<DeviceRegisterDto.Vo> voPageBean = toPageBean(DeviceRegisterDto.Vo.class, iPage);
        List<DeviceRegisterDto.Vo> deviceRegisters = voPageBean.getRecords();
        if (deviceRegisters.size() > 0) {
            JList<Long> deviceIds = new JArrayList<>(deviceRegisters).getProperty(DeviceRegisterDto.Vo::getDeviceId);
            List<DeviceQualityDto.Vo> vos = deviceQualityService.list(new DeviceQualityDto.SelectList().setDeviceIds(deviceIds)
                    .setShowStatus(true)
            ).getData();
            JMap<Long, DeviceQualityDto.Vo> map = new JArrayList<>(vos).toMap(DeviceQualityDto.Vo::getDeviceId).cover();
            for (DeviceRegisterDto.Vo deviceRegister : deviceRegisters) {
                DeviceQualityDto.Vo vo = map.get(deviceRegister.getDeviceId());
                if (vo != null) {
                    deviceRegister.setFactoryState(vo.getFactoryState()).setQualityState(vo.getQualityState());
                }
            }
        }
        return R.ok(voPageBean);
    }

    @PostMapping("obj")
    @ApiOperation("对象查询")
    public R<DeviceRegisterDto.Vo> obj(@RequestBody DeviceRegisterDto.Vo vo) {
        LambdaQueryWrapper<DeviceRegister> lambdaQueryWrapper = new MybatisPlusQuery().eqWrapper(vo, DeviceRegister.class).build();
        List<DeviceRegister> list = list(lambdaQueryWrapper);
        if (!Emptys.check(list)) {
            return R.ok();
        }
        DeviceRegisterDto.Vo deviceRegister = copy(DeviceRegisterDto.Vo.class, list.get(0));
        DeviceQualityDto.Vo deviceQuality = deviceQualityService.obj(new DeviceQualityDto.Obj()
                .setDeviceId(deviceRegister.getDeviceId())
                .setShowStatus(true)
        ).getData();
        if (deviceQuality != null) {
            deviceRegister.setFactoryState(deviceQuality.getFactoryState()).setQualityState(deviceQuality.getQualityState());
        }
        return R.ok(deviceRegister);
    }

    @PostMapping("list")
    @ApiOperation("集合查询")
    public R<List<DeviceRegisterDto.Vo>> list(@RequestBody DeviceRegisterDto.SelectList selectList) {
        LambdaQueryWrapper<DeviceRegister> lambdaQueryWrapper = new MybatisPlusQuery().eqWrapper(selectList, DeviceRegister.class)
                .in(DeviceRegister::getDeviceId, selectList.getDeviceIds())
                .in(DeviceRegister::getDeviceSn, selectList.getDeviceSns())
                .in(DeviceRegister::getDeviceType, selectList.getDeviceTypes())
                .in(DeviceRegister::getDevicePc, selectList.getDevicePcs())
                .in(DeviceRegister::getAssetNo, selectList.getAssetNos())
                .build();
        List<DeviceRegister> list = list(lambdaQueryWrapper);
        return R.ok(copy(DeviceRegisterDto.Vo.class, list));
    }

    @ApiOperation("修改sn")
    @PostMapping("updateSn")
    @Transactional(rollbackFor = Exception.class)
    public R updateSn(@RequestBody @Validated DeviceRegisterDto.UpdateSn updateSn) {
        //校验
        String deviceSn = updateSn.getDeviceSn();
        Long deviceId = updateSn.getDeviceId();
        if (Emptys.check(deviceSn)) {
            DeviceRegister deviceRegister = getById(deviceId);
            if (!deviceSn.equals(deviceRegister.getDeviceSn())) {
                long count = count(new LambdaQueryWrapper<DeviceRegister>().eq(DeviceRegister::getDeviceSn, deviceSn));
                if (count > 0) {
                    return R.fail("sn号已被绑定");
                }
            }
        }
        //修改注册等级
        update(new LambdaUpdateWrapper<DeviceRegister>()
                .set(DeviceRegister::getDeviceSn, updateSn.getDeviceSn())
                .eq(DeviceRegister::getDeviceId, deviceId));
        //修改系统信息
        deviceSysinfoService.update(new LambdaUpdateWrapper<DeviceSysinfo>()
                .set(DeviceSysinfo::getDeviceSn, updateSn.getDeviceSn())
                .eq(DeviceSysinfo::getDeviceId, deviceId));
        //修改mqtt认证
        mqttUserService.update(new LambdaUpdateWrapper<MqttUser>()
                .set(MqttUser::getSn, deviceSn)
                .eq(MqttUser::getDeviceId, deviceId));
        //机器ID号生成清除绑定
        if (!Emptys.check(deviceSn)) {
            deviceCreateIdsService.update(new LambdaUpdateWrapper<DeviceCreateIds>()
                    .set(DeviceCreateIds::getBindState, false)
                    .set(DeviceCreateIds::getBindTime, null)
                    .eq(DeviceCreateIds::getDeviceId, deviceId)
            );
        }
        return R.ok();
    }

    @ApiOperation("上传sn注册设备")
    @PostMapping("uploadSaveBySn")
    public R uploadSaveBySn(@RequestParam("file") MultipartFile file, @RequestParam("deviceType") Integer deviceType, @RequestParam("devicePc") String devicePc, @RequestParam("assetNo") String assetNo) {
        ThreadPoolUtils.excPoll(DeviceThreadPoolConfig.DEVICE_COMMON_POLL, 1)
                .execute(() -> {
                    try {
                        EasyExcel.read(file.getInputStream(), UploadSaveBySn.class, new UploadSaveBySnListener(deviceCreateIdsService, this, deviceType, devicePc, assetNo)).sheet().doRead();
                    } catch (IOException e) {
                        log.error("", e);
                    }
                });
        return R.ok();
    }

    @Slf4j
    @RequiredArgsConstructor
    public static class UploadSaveBySnListener implements ReadListener<UploadSaveBySn> {

        private final DeviceCreateIdsServiceImpl deviceCreateIdsService;

        private final DeviceRegisterServiceImpl deviceRegisterService;

        private final Integer deviceType;

        private final String devicePc;

        private final String assetNo;

        private List<UploadSaveBySn> sns = new ArrayList<>();

        /**
         * 这个每一条数据解析都会来调用
         *
         * @param data    one row value. Is is same as {@link AnalysisContext#readRowHolder()}
         * @param context
         */
        @Override
        public void invoke(UploadSaveBySn data, AnalysisContext context) {
            sns.add(data);
        }

        /**
         * 所有数据解析完成了 都会来调用
         *
         * @param context
         */
        @Override
        public void doAfterAllAnalysed(AnalysisContext context) {
            log.info("上传sn注册设备文件解析完毕，总数量：{}，批次：{}", sns.size(), devicePc);
            //生成设备号
            JList<DeviceCreateIds> deviceCreateIds = deviceCreateIdsService.save(new DeviceCreateIdsDto.Save()
                    .setDeviceType(deviceType)
                    .setDoorType("1")
                    .setCreatePc(devicePc)
                    .setNum(sns.size())
            ).getData();
            JList<Long> deviceIds = deviceCreateIds.getProperty(DeviceCreateIds::getDeviceId);
            //注册设备
            ThreadPoolUtils.Execute execute = ThreadPoolUtils.excPoll(DeviceThreadPoolConfig.DEVICE_COMMON_POLL, sns.size());
            for (int i = 0; i < sns.size(); i++) {
                UploadSaveBySn sn = sns.get(i);
                Long deviceId = deviceIds.get(i);
                execute.execute(() -> {
                    DeviceRegisterDto.Save save = new DeviceRegisterDto.Save()
                            .setDeviceId(deviceId)
                            .setDeviceSn(sn.getSn())
                            .setDevicePc(devicePc)
                            .setAssetNo(assetNo);
                    R r = deviceRegisterService.save(save);
                    if (r.getCode() == R.Enum.FAIL.getCode()) {
                        log.error("{},{}", sn.getSn(), r.getMsg());
                    }
                });
            }
            execute.end();
            log.info("上传sn注册设备注册完毕，批次：{}", devicePc);
        }
    }

    @Data
    public static class UploadSaveBySn {

        private String sn;
    }
}