jihe-dc/zc-business/src/main/java/com/zc/business/controller/DcDeviceController.java

package com.zc.business.controller;

import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.zc.business.constant.DeviceTypeConstants;
import com.zc.business.domain.DcDevice;
import com.zc.business.request.DeviceGetPropertiesOperateRequest;
import com.zc.business.service.IDcDeviceService;
import com.zc.common.core.httpclient.OkHttp;
import com.zc.common.core.httpclient.exception.HttpException;
import com.zc.common.core.httpclient.request.RequestParams;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.v3.oas.annotations.Parameter;
import okhttp3.Response;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.*;

/**
 * 设备Controller
 *
 * @author zhaoxianglong
 */
@Api(tags = {"设备"})
@RestController
@RequestMapping("/business/device")
public class DcDeviceController extends BaseController {

    @Resource
    private IDcDeviceService dcDeviceService;

    @Value("${iot.address}")
    private String iotAddress;

    @Resource
    private BroadcastController broadcastController;

    //*********************************设备增删改查******************************************

    /**
     * 分页查询设备列表
     *
     * @param dcDevice 请求参数
     * @return 分页查询结果
     */
    @ApiOperation("分页查询设备列表")
    @PreAuthorize("@ss.hasPermi('iot:device:list')")
    @GetMapping("list")
    public TableDataInfo listDevice(DcDevice dcDevice) {
        return getDataTable(dcDeviceService.pageDevice(dcDevice));
    }

    /**
     * 统计异常设备
     *
     * @return 查询结果
     */
    @ApiOperation("统计异常设备")
    @PreAuthorize("@ss.hasPermi('iot:device:list')")
    @GetMapping("abnormalDevice")
    public AjaxResult statisticalAnomalyDevice() {
        return AjaxResult.success(dcDeviceService.statisticalAnomalyDevice());
    }

    /**
     * 无分页查询设备列表
     *
     * @param dcDevice 请求参数
     * @return 查询结果
     */
    @ApiOperation("无分页查询设备列表")
    @PreAuthorize("@ss.hasPermi('iot:device:query')")
    @GetMapping("query")
    public AjaxResult queryDevice(DcDevice dcDevice) {
        return AjaxResult.success(dcDeviceService.listDevice(dcDevice));
    }

    /**
     * 无分页根据设备桩号查询设备列表
     *
     * @param parameter 请求参数
     * @return 查询结果
     */
    @ApiOperation("无分页根据设备桩号查询设备列表")
    @PreAuthorize("@ss.hasPermi('iot:device:query')")
    @PostMapping("pileNumberQuery")
    public AjaxResult devicePileNumberQueryDevice(@RequestBody Map<String, Object> parameter) {
        return AjaxResult.success(dcDeviceService.devicePileNumberQueryDevice(parameter));
    }

    /**
     * 根据id查询设备信息
     *
     * @param id id
     * @return 查询结果
     */
    @ApiOperation("根据id查询设备信息")
    @PreAuthorize("@ss.hasPermi('iot:device:query')")
    @GetMapping("{id}")
    public AjaxResult getDevice(@PathVariable String id) {
        return AjaxResult.success(dcDeviceService.getDevice(id));
    }


    /**
     * 新增
     *
     * @param dcDevice 新增参数
     * @return 新增操作结果
     */
    @ApiOperation("新增")
    @PreAuthorize("@ss.hasPermi('iot:device:add')")
    @Log(title = "新增设备", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult addDevice(@Valid @RequestBody DcDevice dcDevice) {
        return toAjax(dcDeviceService.addDevice(dcDevice));
    }

    /**
     * 修改
     *
     * @param dcDevice 修改参数
     * @return 修改操作结果
     */
    @ApiOperation("修改")
    @PreAuthorize("@ss.hasPermi('iot:device:edit')")
    @Log(title = "修改设备", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult editDevice(@Valid @RequestBody DcDevice dcDevice) {
        return toAjax(dcDeviceService.editDevice(dcDevice));
    }

    /**
     * 删除
     *
     * @param ids id集
     * @return 删除操作结果
     */
    @ApiOperation("删除")
    @PreAuthorize("@ss.hasPermi('iot:device:remove')")
    @Log(title = "删除", businessType = BusinessType.DELETE)
    @DeleteMapping("{ids}")
    public AjaxResult removeDevice(@PathVariable List<String> ids) {
        return toAjax(dcDeviceService.removeDevice(ids));
    }


    //***********************************物联设备接口**************************************


    /**
     * 根据物联产品id获取设备数据
     *
     * @param productId 物联产品id
     * @return 获取设备数据操作结果
     */
    @ApiOperation("根据物联产品id获取设备数据")
    @GetMapping("/devices/{productId}")
    public AjaxResult getDeviceByProductId(@PathVariable @Parameter(description = "产品ID") String productId) throws HttpException, IOException {

        if (!StringUtils.hasText(productId)) {
            return AjaxResult.error("产品ID不能为空");
        }

        OkHttp okHttp = new OkHttp();
        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/cache/" + productId) // 请求地址
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }


    /**
     * 根据物联设备id获取最新属性数据
     *
     * @param deviceId 物联设备id
     * @return 获取属性数据操作结果
     */
    @ApiOperation("获取设备最新属性数据")
    @GetMapping("/properties/latest/{deviceId}")
    public AjaxResult getDeviceLatestProperties(@PathVariable @Parameter(description = "设备ID") String deviceId) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId)) {
            return AjaxResult.error("设备未接入");
        }

        OkHttp okHttp = new OkHttp();
        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/properties/latest/" + deviceId) // 请求地址
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    /**
     * 查询当天设备指定属性列表
     *
     * @param deviceId   设备id
     * @param propertyId 属性id
     * @return 属性列表
     */
    @ApiOperation("查询当天设备指定属性列表")
    @GetMapping("/properties/history/day/{deviceId}/{propertyId}")
    public AjaxResult queryDevicePropertiesOneDay(@PathVariable @Parameter(description = "设备ID") String deviceId,
                                                  @PathVariable @Parameter(description = "属性ID") String propertyId) throws HttpException, IOException {

        HashMap<String, Object> props = new HashMap<>();
        // 设置查询条件的键为“timestamp$BTW”，表示时间戳在一定范围内
        props.put("terms[0].column", "timestamp$BTW");
        ArrayList<String> dateList = new ArrayList<>();
        // 添加当前日期的开始和结束时间到列表，用于设定时间范围
        dateList.add(DateUtil.beginOfDay(new Date()).toString());
        dateList.add(DateUtil.endOfDay(new Date()).toString());
        // 将日期列表以逗号分隔并设置为查询条件的值
        props.put("terms[0].value", String.join(",", dateList));
        props.put("paging", false);
        props.put("sorts[0].order", "asc");
        props.put("sorts[0].name", "timestamp");
        AjaxResult ajaxResult = queryDeviceProperties(deviceId, propertyId, props);
        if (!ajaxResult.get("code").equals(200)) {
            return ajaxResult;
        }

        Object data = JSON.parseObject(queryDeviceProperties(deviceId, propertyId, props).get("data").toString()).get("data");
        JSONArray dataArray = JSON.parseArray(data.toString());
        List<Object> list = new ArrayList<>();
        dataArray.forEach(o -> {
            Map<String, Object> map = new HashMap<>();
            JSONObject jsonObject = JSON.parseObject(o.toString());
            JSONObject formatValue = JSON.parseObject(jsonObject.get("formatValue").toString());
            map.put("1", formatValue.get("1"));
            map.put("3", formatValue.get("3"));
            map.put("timestamp", jsonObject.get("timestamp"));
            list.add(map);
        });
        return AjaxResult.success(list);
    }

    /**
     * 查询设备指定属性列表
     *
     * @param deviceId   设备id
     * @param propertyId 属性id
     * @param props      查询条件
     * @return 属性列表
     */
    @ApiOperation("获取设备历史属性列表")
    @GetMapping("/properties/history/{deviceId}/{propertyId}")
    public AjaxResult queryDeviceProperties(@PathVariable @Parameter(description = "设备ID") String deviceId,
                                            @PathVariable @Parameter(description = "属性ID") String propertyId,
                                            @Parameter(hidden = true) HashMap<String, Object> props) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId) || !StringUtils.hasText(propertyId)) {
            return AjaxResult.error("设备未接入");
        }

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams(props);

        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/properties/history/" + deviceId + "/" + propertyId) // 请求地址
                .data(requestParams)
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    /**
     * 根据物联设备id获取最新属性数据
     *
     * @param deviceId   物联设备id
     * @param propertyId 属性id
     * @return 获取属性数据操作结果
     */
    @ApiOperation("获取设备指定属性最新数据")
    @GetMapping("/properties/latest/{deviceId}/{propertyId}")
    public AjaxResult getDeviceLatestProperty(@PathVariable @Parameter(description = "设备ID") String deviceId,
                                              @PathVariable @Parameter(description = "属性ID") String propertyId) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId) || !StringUtils.hasText(propertyId)) {
            return AjaxResult.error("设备未接入");
        }

        OkHttp okHttp = new OkHttp();
        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/properties/latest/" + deviceId + "/" + propertyId) // 请求地址
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    /**
     * 获取物联设备实时属性值
     *
     * @param deviceId   物联设备id
     * @param propertyId 属性
     * @return 属性实时数据
     */
    @ApiOperation("获取设备指定属性实时数据")
    @GetMapping("/properties/realtime/{deviceId}/{propertyId}")
    public AjaxResult getDeviceRealtimeProperty(
            @PathVariable String deviceId,
            @PathVariable String propertyId,
            @RequestParam HashMap<String, Object> props) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId) || !StringUtils.hasText(propertyId)) {
            return AjaxResult.error("设备未接入");
        }

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams(props);

        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/properties/realtime/" + deviceId + "/" + propertyId) // 请求地址
                .data(requestParams)
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    /**
     * 批量获取物联设备实时属性
     *
     * @param deviceId 物联设备id
     * @param props    属性id集
     * @return 属性实时数据
     */
    @ApiOperation("获取设备属性实时数据")
    @PostMapping("/properties/realtime/{deviceId}")
    public AjaxResult getDeviceRealtimeProperties(
            @PathVariable String deviceId,
            @RequestBody DeviceGetPropertiesOperateRequest props) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId)) {
            return AjaxResult.error("设备未接入");
        }

        OkHttp okHttp = new OkHttp();


        String string = JSON.toJSONString(props);
        JSONObject jsonObject = JSON.parseObject(string);
        RequestParams requestParams = new RequestParams(jsonObject);


        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/properties/realtime/" + deviceId) // 请求地址
                .data(requestParams)
                .post(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    /**
     * 发送设置属性指令到设备
     *
     * @param deviceId 物联设备id
     * @param props    参数
     * @return 设备属性操作结果
     */
    @ApiOperation("设置设备属性值")
    @PostMapping("/properties/setting/{deviceId}")
    public AjaxResult setDeviceProperties(
            @PathVariable String deviceId,
            @RequestBody HashMap<String, Object> props
    ) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId)) {
            return AjaxResult.error("设备未接入");
        }

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams(props);

        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/properties/setting/" + deviceId) // 请求地址
                .data(requestParams)
                .post(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    /**
     * 设备功能调用
     *
     * @param deviceId   物联设备id
     * @param functionId 功能id
     * @param props      调用参数
     * @return 调用结果
     */
    @ApiOperation("设备功能调用")
    @PostMapping("/functions/{deviceId}/{functionId}")
    public AjaxResult invokedFunction(
            @PathVariable String deviceId,
            @PathVariable String functionId,
            @RequestBody HashMap<String, Object> props) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId) || !StringUtils.hasText(functionId)) {
            return AjaxResult.error("设备未接入");
        }

        try {

            OkHttp okHttp = new OkHttp();

            RequestParams requestParams = new RequestParams(props);


            Response response // 请求响应
                    = okHttp
                    .url(iotAddress + "/api/iot/device/functions/" + deviceId + "/" + functionId) // 请求地址
                    .data(requestParams)
                    .post(); // 请求方法
            return JSON.parseObject(response.body().string(), AjaxResult.class);
        } catch (Exception e) {
            return AjaxResult.error("请求失败");
        }

    }

    /**
     * 批量设备功能调用
     *
     * @param props 调用参数列表
     * @return 调用结果
     */
    @ApiOperation("批量设备功能调用")
    @PostMapping("/batchFunctions")
    public AjaxResult batchInvokedFunction(@RequestBody Map<String, Object> props) throws HttpException, IOException, InterruptedException {
        List<DcDevice> devices = (List<DcDevice>) props.get("devices");
        JSONArray functions = (JSONArray) props.get("functions");
        JSONArray resultArray = new JSONArray();
        for (DcDevice device : devices) {
            String iotDeviceId = device.getIotDeviceId();
            for (Object function : functions) {
                JSONObject functionJSONObject = JSONObject.parseObject(String.valueOf(function));
                String functionId = functionJSONObject.getString("functionId");
                JSONObject jsonObject = functionJSONObject.getJSONObject("params");
                resultArray.add(getResult(device, iotDeviceId, functionId, jsonObject));
            }
        }
        return AjaxResult.success(resultArray);
    }

    private JSONObject getResult(DcDevice device, String iotDeviceId, String functionId, JSONObject jsonObject) throws HttpException, IOException {
        HashMap<String, Object> params = jsonObject.toJavaObject(new TypeReference<HashMap<String, Object>>() {
        });
        JSONObject result = new JSONObject();
        result.put("device", device.getId());
        if (device.getDeviceType().equals(DeviceTypeConstants.ROAD_SECTION_VOICE_BROADCASTING)) {
            result.put("result", broadcastController.nearCamListDistance(jsonObject));
        } else {
            result.put("result", invokedFunction(iotDeviceId, functionId, params));
        }
        return result;
    }


    /**
     * 批量设备功能调用
     *
     * @param props 调用参数列表
     * @return 调用结果
     */
    @ApiOperation("批量激光疲劳设备功能调用")
    @PostMapping("/batchLaserFatigueInvokedFunction")
    public AjaxResult batchLaserFatigueInvokedFunction(@RequestBody Map<String, Object> props) throws HttpException, IOException, InterruptedException {
        String deviceId = (String) props.get("deviceId");
        String functionId = (String) props.get("functionId");
        ArrayList params = (ArrayList) props.get("params");
        JSONArray resultArray = new JSONArray();
        for (Object param : params) {
            resultArray.add(invokedFunction(deviceId, functionId, (HashMap<String, Object>) param));
        }
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("SET", "7");
        invokedFunction(deviceId, "SETMD", hashMap);
        return AjaxResult.success(resultArray);
    }

    public HashMap<String, Object> objectToMap(Object obj) {
        Map<String, Object> map = new HashMap<>();
        for (Field field : obj.getClass().getDeclaredFields()) {
            try {
                field.setAccessible(true);
                map.put(field.getName(), field.get(obj));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return (HashMap<String, Object>) map;
    }

    /**
     * 查询物联设备事件数据
     *
     * @param deviceId   物联设备id
     * @param eventId    事件id
     * @param queryParam 查询条件
     * @return 查询事件结果
     */
    @ApiOperation("查询事件历史数据列表")
    @GetMapping("/events/history/{deviceId}/{eventId}")
    public AjaxResult queryPagerDeviceEvents(
            @PathVariable @Parameter(description = "设备ID") String deviceId,
            @PathVariable @Parameter(description = "事件ID") String eventId,
            @Parameter(hidden = true) HashMap<String, Object> queryParam
    ) throws HttpException, IOException {

        if (!StringUtils.hasText(deviceId) || !StringUtils.hasText(eventId)) {
            return AjaxResult.error("设备未接入");
        }

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams(queryParam);

        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/events/history/" + deviceId + "/" + eventId) // 请求地址
                .data(requestParams)
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    /**
     * 获取物联设备物模型
     *
     * @param id 物联设备id
     * @return 更新结果
     */
    @ApiOperation("获取设备物模型")
    @GetMapping(value = "/metadata/{id}")
    public AjaxResult getMetadata(@PathVariable String id) throws HttpException, IOException {

        OkHttp okHttp = new OkHttp();
        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/metadata/" + id) // 请求地址
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

}