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

package com.xy.service;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xy.collections.list.JArrayList;
import com.xy.collections.list.JList;
import com.xy.config.DeviceThreadPoolConfig;
import com.xy.dto.DeviceInfoDto;
import com.xy.dto.DeviceRegisterDto;
import com.xy.dto.DeviceStatusDto;
import com.xy.dto.DeviceSysinfoDto;
import com.xy.entity.DeviceInfo;
import com.xy.entity.SysDictRedis;
import com.xy.error.CommRuntimeException;
import com.xy.mapper.DeviceInfoMapper;
import com.xy.mapper.entity.DeviceInfoQueryPage;
import com.xy.utils.*;
import com.xy.utils.enums.DictEnum;
import com.xy.utils.enums.DictSonEnum;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
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 java.util.ArrayList;
import java.util.List;

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

/**
 * <p>
 * 设备-信息 服务实现类
 * </p>
 *
 * @author lijin
 * @since 2022-12-23
 */
@Service
@RequiredArgsConstructor
@Api(tags = "设备-信息")
public class DeviceInfoServiceImpl extends ServiceImpl<DeviceInfoMapper, DeviceInfo> implements DeviceInfoService {

    private final DeviceSysinfoServiceImpl deviceSysinfoService;

    private final DeviceStatusServiceImpl deviceStatusService;

    private final DeviceRegisterServiceImpl deviceRegisterService;

    private final RedisService<String> redisService;

    private final String keyPrefix = "device:history:";

    @Override
    @ApiOperation("对象查询")
    public R<DeviceInfoDto.Vo> obj(DeviceInfoDto.Obj obj) {
        //设备信息
        LambdaQueryWrapper<DeviceInfo> lambdaQueryWrapper = new MybatisPlusQuery().eqWrapper(obj, DeviceInfo.class).build();
        List<DeviceInfo> list = list(lambdaQueryWrapper);
        if (!Emptys.check(list)) {
            return R.ok();
        }
        DeviceInfoDto.Vo deviceInfo = copy(DeviceInfoDto.Vo.class, list.get(0));
        ThreadPoolUtils.excPoll(DeviceThreadPoolConfig.DEVICE_COMMON_POLL, 3)
                .execute(() -> {
                    //系统信息
                    DeviceSysinfoDto.Vo deviceSysinfo = deviceSysinfoService.get(new DeviceSysinfoDto.Vo().setDeviceId(deviceInfo.getDeviceId())).getData();
                    deviceInfo.setDeviceSysinfo(deviceSysinfo);
                })
                .execute(() -> {
                    //状态信息
                    DeviceStatusDto.Vo deviceStatus = deviceStatusService.obj(new DeviceStatusDto.Vo().setDeviceId(deviceInfo.getDeviceId())).getData();
                    deviceInfo.setDeviceStatus(deviceStatus);
                })
                .execute(() -> {
                    //注册信息
                    DeviceRegisterDto.Vo deviceRegister = deviceRegisterService.obj(new DeviceRegisterDto.Vo().setDeviceId(deviceInfo.getDeviceId())).getData();
                    deviceInfo.setDeviceRegister(deviceRegister);
                })
                .end();
        return R.ok(deviceInfo);
    }

    @Override
    @ApiOperation("设备访问历史添加")
    public R history(DeviceInfoDto.Obj obj) {
        //获取字典
        SysDictRedis sysDictRedis = SysDictUtils.get(DictEnum.DATA_CLEAR_SIZE.getKey(), "device_history_twig");
        Integer value = Integer.valueOf(sysDictRedis.getValue());
        //获取redis
        String key = keyPrefix + AuthorizeUtils.getLoginId(Long.class);
        List<String> list = redisService.getList(key);
        list.add(0, String.valueOf(obj.getDeviceId()));
        //去重
        List<String> redisList = new ArrayList<>();
        JList<String> comparing = new JArrayList<>(list).comparing();
        if (comparing.size() > value) {
            for (int i = 0; i < value; i++) {
                redisList.add(comparing.get(i));
            }
        } else {
            redisList = comparing;
        }
        redisService.removeList(key);
        redisService.setList(key, redisList);
        return R.ok();
    }

    @Override
    @ApiOperation("开门检测")
    public R checkOpenDoor(DeviceInfoDto.Obj obj) {
        DeviceInfoDto.Vo deviceInfo = obj(new DeviceInfoDto.Obj().setDeviceId(obj.getDeviceId())).getData();
        if (deviceInfo == null) {
            return R.fail("设备不存在");
        }
        DeviceStatusDto.Vo deviceStatus = deviceInfo.getDeviceStatus();
        check(deviceInfo.getFreezeStatus(), 2, "设备已冻结");
        SysDictRedis sysDictRedis = SysDictUtils.get(DictEnum.DEVICE_FAULT_LEVEL_PAY_THRESHOLD.getKey(), DictSonEnum.DEVICE_FAULT_LEVEL_PAY_THRESHOLD_NOT_PAY.getKey());
        if (deviceInfo.getFaultLevel() >= Integer.valueOf(sysDictRedis.getValue())) {
            return R.fail("设备故障");
        }
        check(deviceStatus.getNetState(), 2, "设备已离线");
        check(obj.getIsTwoDoor() != null && obj.getIsTwoDoor() ? deviceStatus.getDeviceStateR() : deviceStatus.getDeviceStateL(), 2, "设备已锁机");
        check(obj.getIsTwoDoor() != null && obj.getIsTwoDoor() ? deviceStatus.getLockStateR() : deviceStatus.getLockStateL(), 2, "设备正在使用中，请稍后");
        return R.ok();
    }

    @PostMapping("historyList")
    @ApiOperation("设备访问历史查询")
    public R<List<DeviceInfoDto.Vo>> historyList() {
        //获取redis
        String key = keyPrefix + AuthorizeUtils.getLoginId(Long.class);
        List<String> deviceIds = redisService.getList(key);
        if (!Emptys.check(deviceIds)) {
            return R.ok();
        }
        //查询数据库
        List<DeviceInfo> list = list(new LambdaQueryWrapper<DeviceInfo>().in(DeviceInfo::getDeviceId, deviceIds));
        return R.ok(copy(DeviceInfoDto.Vo.class, list));
    }

    @ApiOperation("修改")
    @PostMapping("update")
    public R update(@RequestBody @Validated DeviceInfoDto.Update update) {
        DeviceInfo deviceInfo = copy(DeviceInfo.class, update);
        updateById(deviceInfo);
        return R.ok();
    }

    @PostMapping("page")
    @ApiOperation("分页查询")
    public R<PageBean<DeviceInfoDto.Vo2>> page(@RequestBody DeviceInfoDto.Page page) {
        //数据鉴权
        boolean authByData = AuthorizeUtils.authByData(AuthorizeUtils.getSysId(), AuthorizeUtils.getUri());
        if (!authByData) {
            //todo 授权处理
            boolean deviceAuth = true;
            if (deviceAuth) {
                page.setMerc(String.valueOf(AuthorizeUtils.getLoginId(Long.class)));
            }
        }
        return queryPage(page);
    }

    @PostMapping("nearbyPage")
    @ApiOperation("附近设备分页查询")
    public R<PageBean<DeviceInfoDto.Vo2>> nearbyPage(@RequestBody DeviceInfoDto.Page page) {
        if (!Emptys.check(page.getLon()) || !Emptys.check(page.getLat())) {
            throw new CommRuntimeException("经纬度不能为空");
        }
        return queryPage(page);
    }

    @ApiOperation("商户设备授权")
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R<Boolean> mercDeviceAuth(DeviceInfoDto.MercDeviceAuthDto auth) {
        Long mercId = auth.getMercId();
        String mercCode = auth.getMercCode();
        //商户最终设备列表
        List<Long> deviceIds = auth.getDeviceIds();
        List<DeviceInfo> devices = getDevicesByMercId(mercId);
        //取消商户设备授权
        if (CollUtil.isEmpty(deviceIds)) {
            if (CollUtil.isEmpty(devices)) {
                return R.ok(Boolean.TRUE);
            }
            return R.ok(removeMerRefDevices(devices));
        }
        //更新商户设备授权
        List<DeviceInfo> deviceInfos = this.listByIds(deviceIds);
        deviceInfos.forEach(deviceInfo -> {
            //绑定关系
            deviceInfo.setMercId(mercId).setMercCode(mercCode);
        });
        updateBatchById(deviceInfos);
        //原来存在的设备关系，不在最终设备列表中的移除
        if (CollUtil.isNotEmpty(devices)) {
            List<Long> oldIds = new ArrayList<>();
            List<Long> removeIds = new ArrayList<>();
            devices.forEach(device -> oldIds.add(device.getDeviceId()));
            oldIds.forEach(deviceId -> {
                //不在最终设备列表中的待移除
                if (!deviceIds.contains(deviceId)) {
                    removeIds.add(deviceId);
                }
            });
            if (CollUtil.isNotEmpty(removeIds)) {
                List<DeviceInfo> removeList = this.listByIds(removeIds);
                removeMerRefDevices(removeList);
            }
        }
        return R.ok(Boolean.TRUE);
    }

    /**
     * 批量移除商户设备绑定关系
     *
     * @param deviceInfos
     * @return
     */
    private Boolean removeMerRefDevices(List<DeviceInfo> deviceInfos) {
        deviceInfos.forEach(deviceInfo -> {
            //-1 释放关系
            deviceInfo.setMercId(-1L);
        });
        //批量更新
        updateBatchById(deviceInfos);
        return updateBatchById(deviceInfos);
    }


    @ApiOperation("集合查询")
    @Override
    public R<List<DeviceInfoDto.Vo>> list(DeviceInfoDto.ListDto dto) {
        List<DeviceInfo> list = list(new LambdaQueryWrapper<DeviceInfo>().in(CollUtil.isNotEmpty(dto.getDeviceIds()), DeviceInfo::getDeviceId, dto.getDeviceIds()));
        return R.ok(copy(DeviceInfoDto.Vo.class, list));
    }

    /**
     * 获取商户设备列表
     *
     * @param mercId
     * @return
     */
    private List<DeviceInfo> getDevicesByMercId(Long mercId) {
        return list(Wrappers.<DeviceInfo>lambdaQuery().eq(DeviceInfo::getMercId, mercId));
    }

    private R<PageBean<DeviceInfoDto.Vo2>> queryPage(DeviceInfoDto.Page page) {
        IPage<DeviceInfoQueryPage> iPage = baseMapper.queryPage(toIPage(page.getPage()), page);
        return R.ok(toPageBean(DeviceInfoDto.Vo2.class, iPage));
    }

    private <T> void check(T value, T value2, String msg) {
        if (value.toString().equals(value2.toString())) {
            throw new CommRuntimeException(msg);
        }
    }
}