device-link-ykc/src/main/java/com/tmzn/devicelinkykc/controller/DeviceController.java

package com.tmzn.devicelinkykc.controller;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.server.HttpServerRequest;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tmzn.devicelinkykc.constant.Constant;
import com.tmzn.devicelinkykc.constant.DeviceOnlineStatus;
import com.tmzn.devicelinkykc.constant.PortStatusConstant;
import com.tmzn.devicelinkykc.constant.RedisConstant;
import com.tmzn.devicelinkykc.constant.ykc.StatusConstant;
import com.tmzn.devicelinkykc.entity.*;
import com.tmzn.devicelinkykc.entity.param.AjaxResult;
import com.tmzn.devicelinkykc.entity.param.vo.TransOrderVO;
import com.tmzn.devicelinkykc.mapstruct.DeviceMapping;
import com.tmzn.devicelinkykc.mapstruct.TransMapping;
import com.tmzn.devicelinkykc.redis.RedisCache;
import com.tmzn.devicelinkykc.service.*;
import com.tmzn.devicelinkykc.socket.SocketHandle;
import com.tmzn.devicelinkykc.transdata.entity.DeviceParam;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * @author xp
 * @date 2024/4/10
 * @explain " 开放接口 "
 */
@RestController
@CrossOrigin(origins = "*")
@RequestMapping("api/device")
public class DeviceController {

    private static final Logger logger = LoggerFactory.getLogger(DeviceController.class);

    @Autowired
    private DeviceService deviceService;
    @Autowired
    private DeviceStatusService deviceStatusService;
    @Autowired
    private DeviceMapping deviceMapping;
    @Autowired
    private TransMapping transMapping;
    @Autowired
    private BillingModelService billingModelService;

    @Autowired
    private SocketHandle socketHandle;
    @Autowired
    private TransOrderService transOrderService;

    @Autowired
    private RedisCache redisCachel;
    @Autowired
    private DeviceControlerService deviceControlerService;

  /*  *//**
     * 接收到充电桩后台提交的云快充连接设备进行保存
     *
     * @param
     * @return
     *//*
    @PostMapping
    public AjaxResult addAndUpdate(@RequestBody DeviceDTO deviceDTO) {
        String deviceSn = deviceDTO.getDeviceSn();
        String deviceImei = deviceDTO.getDeviceImei();
        String pileCode = deviceDTO.getPileCode();
        QueryWrapper<Device> deviceQueryWrapper = new QueryWrapper<>();
        deviceQueryWrapper.eq("device_sn", deviceSn).eq("device_imei", deviceImei).eq("pile_code", pileCode);
        Device device = deviceService.getOne(deviceQueryWrapper);
        if (device == null) {
            Device add = deviceMapping.deviceDTOTOdevice(deviceDTO);
            boolean save = deviceService.save(add);
            if (save) {
                return AjaxResult.success("设备连接云快充信息保存成功!");
            } else {
                return AjaxResult.error("设备连接云快充信息保存异常!");
            }
        } else {
            //更新操作分情况;TODO:设备双枪，枪禁用情况？
            QueryWrapper<DeviceStatus> deviceStatusQueryWrapper = new QueryWrapper<>();
            deviceStatusQueryWrapper.eq("device_sn", deviceSn).eq("device_imei", deviceImei).eq("pile_code", pileCode);
            List<DeviceStatus> deviceStatusList = deviceStatusService.list(deviceStatusQueryWrapper);
            if (device.getDisabled() == deviceDTO.getDisabled()) {
                //禁用状态没变化,更新设备信息
                deviceService.updateById(device);
                return AjaxResult.success();
            } else {
                if (device.getDisabled() == DeviceOnlineStatus.DISABLED) {
                    //1.禁用变正常状态
                    device.setDisabled(DeviceOnlineStatus.NORMAL);
                    deviceService.updateById(device);
                    return AjaxResult.success();
                } else {
                    //2.设备是正常状态,更新成禁用状态,设备禁用后设备离线:一.校验设备是充电中不能操作,二.deviceStatus需要删除,不保留设备的状态信息
                    List<DeviceStatus> collect = deviceStatusList.stream().filter(deviceStatus ->
                            deviceStatus.getGunStatus() == StatusConstant.CHARGING
                    ).collect(Collectors.toList());
                    if (collect.size() > 0) {
                        //设备有正在充电的端口
                        return AjaxResult.error("设备有正在充电端口,不能设置禁用状态!");
                    } else {
                        //断开socket
                        if (socketHandle.existDeviceConnection(pileCode)) {
                            socketHandle.removeDeviceConnection(pileCode);
                        }
                        deviceStatusService.removeBatchByIds(deviceStatusList);
                        device.setDisabled(DeviceOnlineStatus.DISABLED);
                        deviceService.updateById(device);
                        QueryWrapper<BillingModel> billingModelQueryWrapper = new QueryWrapper<>();
                        billingModelQueryWrapper.eq("device_imei", deviceImei).eq("device_sn", deviceSn).eq("pile_code", pileCode);
                        billingModelService.remove(billingModelQueryWrapper);
                        return AjaxResult.success();
                    }
                }
            }
        }
    }
*/
    @DeleteMapping("/{pileCode}")
    public AjaxResult delete( @PathVariable("pileCode") String pileCode) {
        AjaxResult ajaxResult = deviceService.deleteDevice(pileCode);
        return ajaxResult;
    }

    @GetMapping("order")
    public AjaxResult getOrder(TransOrderVO transOrderVO) {
        Page<TransOrder> transOrderPage = transOrderService.selectAndPage(transOrderVO);
        return AjaxResult.success(transOrderPage);
    }

    @PostMapping("/openLink/{imei}")
    public AjaxResult openLink(@PathVariable("imei")String imei) {

        Set<String> imeis = new HashSet<>();
        if (redisCachel.hasKey(RedisConstant.DEVICE_INFO)) {
            imeis = redisCachel.getCacheObject(RedisConstant.DEVICE_INFO);
        }
        //启用通知
        imeis.add(imei);
        //redisCachel.setCacheObject(RedisConstant.DEVICE_INFO, imeis, 6 * 1000 * 60, TimeUnit.MILLISECONDS);
        redisCachel.setCacheObject(RedisConstant.DEVICE_INFO,imeis);
        //imei保存后发个获取103,让新增设备立马上线
        DeviceParam deviceParam = new DeviceParam();
        deviceParam.setDeviceId(imei);
        deviceParam.setCcid(imei);
        deviceControlerService.sendPortDetailCmd(deviceParam);

        return AjaxResult.success();
    }

    @PostMapping("/handoff")
    public AjaxResult  handoff(@RequestBody List<Device> deviceList) {
        //ip和端口的修改,必须从新登录
        if (deviceList.size()>0){
            for (Device device : deviceList) {
                QueryWrapper<DeviceStatus> deviceStatusQueryWrapper = new QueryWrapper<>();
                deviceStatusQueryWrapper.eq("gun_status",StatusConstant.CHARGING).eq("device_imei",device.getDeviceImei());
                List<DeviceStatus> list = deviceStatusService.list(deviceStatusQueryWrapper);
                if (list.size()>0){
                    return AjaxResult.error("有充电中设备IP和端口无法修改!");
                }
            }
            deviceList.stream().forEach(device -> {
                //修改
                String key = redisCachel.getCacheMapValue(RedisConstant.YKC_KEY_MAP,device.getPileCode());
                if(key!=null){
                    if (socketHandle.existDeviceConnection(device.getPileCode())){
                        socketHandle.removeDeviceConnection(device.getPileCode());
                    }
                    redisCachel.deleteCacheMapValue(RedisConstant.YKC_KEY_MAP,device.getPileCode());
                }

                Device byId = deviceService.getById(device.getId());
                byId.setIp(device.getIp());
                byId.setPort(device.getPort());
                deviceService.updateById(byId);

                logger.info(device.toString());
                DeviceParam deviceParam = new DeviceParam();
                deviceParam.setDeviceId(byId.getDeviceImei());
                deviceParam.setCcid(byId.getDeviceImei());
                deviceControlerService.sendPortDetailCmd(deviceParam);
            });
        }
        return AjaxResult.success();
    }

    /**
     * 主动断开与运营商平台的TCPsocket连接,触发重新登录
     * @param pileCode
     * @return
     */
    @PostMapping("/restLogin/{pileCode}")
    public AjaxResult restLogin(@PathVariable("pileCode")String pileCode,HttpServerRequest request) {

        System.out.printf("111");
        socketHandle.removeDeviceConnection(pileCode);

        return AjaxResult.success("断开连接!!!!!!");
    }
}