@jdlinker/linker/src/api/device/instance.ts

jdLinker 系统模块

import { LocalStore, TOKEN_KEY, BASE_API_PATH } from '@jdlinker/utils';
import { defHttp, useMessage } from '@jdlinker/func';
import { DeviceInstance } from '../../views/device/Instance/typings';
import { DeviceMetadata, UnitType } from '../../views/device/Product/typings';

const { createConfirm } = useMessage();

/**
 * 重置设备继承产品的物模型规则
 * @param deviceId 设备ID
 * @param productId 产品ID
 */
export const resetRule = (productId: string, deviceId: string, data: any) =>
  defHttp.delete({
    url: `/virtual/property/product/${productId}/${deviceId}/_batch`,
    data
  });

/**
 * 删除设备物模型
 * @param deviceId 设备ID
 * @returns
 */
export const deleteMetadata = (deviceId: string) => defHttp.delete({ url: `/device/instance/${deviceId}/metadata` });

/**
 * 保存设备物模型
 * @param id 设备ID
 * @param data 物模型
 * @returns
 */
export const saveMetadata = (id: string, data: DeviceMetadata) =>
  defHttp.put({ url: `/device/instance/${id}/metadata`, data }, { isTransformResponse: false });

/**
 * 根据设备ID获取设备详情
 * @param id 设备ID
 * @returns 设备详情
 */
export const detail = (id: string) => defHttp.get({ url: `/device/instance/${id}/detail` }, { isTransformResponse: false });

/**
 * 查询数据
 * @param data 分页搜索数据
 * @returns
 */
export const query = (data: any) => {
  const params = { ...data };
  return defHttp.post({ url: '/device/instance/list', data, params }, { isTransformResponse: false });
};

export const queryDeviceList = (data?: Record<string, any>) =>
  defHttp.post({ url: '/device/instance/list', data }, { isTransformResponse: false });
/**
 * 不分页查询设备
 * @param data
 * @returns
 */
export const queryNoPagingPost = (data?: Record<string, any>) =>
  defHttp.post({ url: '/device/instance/_query/no-paging?paging=false', data });

/**
 * 删除单个
 */
export const deleteOne = (params, handleSuccess) => {
  return defHttp.delete({ url: '/device/instance/delete', params }, { joinParamsToUrl: true }).then(() => {
    handleSuccess();
  });
};
/**
 * 批量删除
 * @param params
 */
export const batchDelete = (params, handleSuccess) => {
  createConfirm({
    iconType: 'warning',
    title: '确认删除',
    content: '是否删除选中数据',
    okText: '确认',
    cancelText: '取消',
    onOk: () => {
      return defHttp.delete({ url: '/device/instance/deleteBatch', data: params }, { joinParamsToUrl: true }).then(() => {
        handleSuccess();
      });
    }
  });
};

/**
 * 删除设备
 * @param id 设备ID
 * @returns
 */
export const _delete = (id: string) => defHttp.delete({ url: `/device/instance/${id}` });

/**
 * 启用设备
 * @param id 设备ID
 * @returns
 */
export const _deploy = (id: string) =>
  defHttp.post({ url: `/device/instance/${id}/deploy` }, { isTransformResponse: false });

/**
 * 禁用设备
 * @param id 设备ID
 * @returns
 */
export const _undeploy = (id: string) => defHttp.post({ url: `/device/instance/${id}/undeploy` });

/**
 * 批量激活设备
 * @param data 设备id数组
 * @returns
 */
export const batchDeployDevice = (data: string[]) => defHttp.put({ url: `/device/instance/batch/_deploy`, data });

/**
 * 批量注销设备
 * @param data 设备id数组
 * @returns
 */
export const batchUndeployDevice = (data: string[]) => defHttp.put({ url: `/device/instance/batch/_unDeploy`, data });

/**
 * 批量删除
 * @param data 设备id数组
 * @returns
 */
export const batchDeleteDevice = (data: string[]) => defHttp.put({ url: `/device/instance/batch/_delete`, data });

/**
 * 下载设备模板
 * @param productId 产品id
 * @param type 文件类型
 * @returns
 */
export const deviceTemplateDownload = (productId: string, type: string) =>
  `${BASE_API_PATH}/device/instance/${productId}/template.${type}`;

export const templateDownload = (productId: string, type: string) =>
  defHttp.get({ url: `/device/instance/${productId}/template.${type}` });
/**
 * 设备导入
 * @param productId 产品id
 * @param fileUrl
 * @param autoDeploy
 * @returns
 */
export const deviceImport = (productId: string, fileUrl: string, autoDeploy: boolean) =>
  `${BASE_API_PATH}/device/instance/${productId}/import?fileUrl=${fileUrl}&autoDeploy=${autoDeploy}&:X_Access_Token=${LocalStore.get(
    TOKEN_KEY
  )}`;

/**
 * 设备导出
 * @param productId 产品id
 * @param type 文件类型
 * @returns
 */
export const deviceExport = (productId: string, type: string, params?: any) =>
  defHttp.get(
    {
      url: `/device/instance${!!productId ? `/${productId}` : ''}/export.${type}`,
      params,
      responseType: 'blob'
    },
    { isTransformResponse: false }
  );

/**
 * 验证设备ID是否重复
 * @param id 设备id
 * @returns
 */
export const isExists = (id: string) =>
  defHttp.get({ url: `/device/instance/${id}/exists` }, { isTransformResponse: false });

/**
 * 修改设备信息
 * @param data 设备信息
 * @returns
 */
export const update = (data: Partial<DeviceInstance>) =>
  data.id ? defHttp.put({ url: `/device/instance`, data }) : defHttp.post({ url: `/device/instance`, data });

/**
 * 修改设备信息
 * @param id 设备id
 * @param data 设备信息
 * @returns
 */
export const modify = (id: string, data: Partial<DeviceInstance>) =>
  defHttp.put({ url: `/device/instance/${id}`, data }, { isTransformResponse: false });

/**
 * 获取配置信息
 * @param id 设备id
 * @returns
 */
export const getConfigMetadata = (id: string) =>
  defHttp.get({ url: `/device/instance/${id}/config-metadata` }, { isTransformResponse: false });

/**
 * 断开连接
 * @param id 设备id
 * @returns
 */
export const _disconnect = (id: string) => defHttp.post({ url: `/device/instance/${id}/disconnect` });

/**
 * 查询用户列表
 * @returns
 */
export const queryUserListNoPaging = () => {
  const params = {
    paging: false,
    sorts: [{ name: 'name', order: 'asc' }]
  };
  return defHttp.post({ url: `/user/_query/no-paging`, params });
};

/**
 * 保存设备关系
 * @param id 设备id
 * @param data
 * @returns
 */
export const saveRelations = (id: string, data: Record<string, any>) =>
  defHttp.put({ url: `/device/instance/${id}/relations`, data });

/**
 * 修改标签
 * @param id 设备id
 * @param data
 * @returns
 */
export const saveTags = (id: string, data: Record<string, any>) => defHttp.put({ url: `/device/instance/${id}/tag`, data });

/**
 * 删除标签
 * @param deviceId 设备id
 * @param id 标签id
 * @returns
 */
export const delTags = (deviceId: string, id: string) => defHttp.delete({ url: `/device/instance/${deviceId}/tag/${id}` });

/**
 * 恢复默认配置
 * @param deviceId 设备id
 * @returns
 */
export const configurationReset = (deviceId: string) =>
  defHttp.put({ url: `/device/instance/${deviceId}/configuration/_reset` });

/**
 * 查询事件详情列表
 * @param deviceId 设备id
 * @param eventId 事件id
 * @param data
 * @returns
 */
export const getEventList = (deviceId: string, eventId: string, data: Record<string, any>) => {
  // if (data?.terms && data?.terms.length < 1) {
  //    delete data?.terms;
  // }
  return defHttp.post(
    { url: `/device/instance/${deviceId}/event/${eventId}?format=true`, data },
    { isTransformResponse: false }
  );
};

/**
 * 设置属性至设备
 * @param deviceId 设备id
 * @param data
 * @returns
 */
export const setProperty = (deviceId: string, data: Record<string, any>) =>
  defHttp.put({ url: `/device/instance/${deviceId}/property`, data });

/**
 * 获取最新属性值
 * @param deviceId 设备id
 * @param type 属性id
 * @returns
 */
export const getProperty = (deviceId: string, type: string) =>
  defHttp.get({ url: `/device/standard/${deviceId}/property/${type}` }, { isTransformResponse: false });

/**
 * 查询是否存在云端映射设备
 */
export const queryDeviceMapping = (deviceId: string, data?: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/device-mapping-list/invoke`,
    data
  });

/**
 * 批量保存云端映射设备
 */
export const saveDeviceMapping = (deviceId: string, data: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/device-mapping-save-batch/invoke`,
    data
  });

/**
 * 查询设备的物模型指标
 * @param deviceId 设备id
 * @param propertyId 属性id
 * @returns
 */
export const queryMetric = (deviceId: string, propertyId: string) =>
  defHttp.get({
    url: `/device/instance/${deviceId}/metric/property/${propertyId}`
  });

/**
 *批量删除云端映射设备
 */
export const deleteDeviceMapping = (deviceId: string, data: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/device-mapping-delete-by-deviceid/invoke`,
    data
  });

/**
 * 保存设备的物模型指标
 * @param deviceId 设备id
 * @param propertyId 属性id
 * @param data
 * @returns
 */
export const saveMetric = (deviceId: string, propertyId: string, data: Record<string, any>) =>
  defHttp.put({
    url: `/device/instance/${deviceId}/metric/property/${propertyId}`,
    data
  });

/**
 * 解绑子设备
 * @param deviceId 设备id
 * @param childrenId 子设备id
 * @param data
 * @returns
 */
export const unbindDevice = (deviceId: string, childrenId: string, data: Record<string, any>) =>
  defHttp.post({
    url: `/device/gateway/${deviceId}/unbind/${childrenId}`,
    data
  });

/**
 * 批量解绑子设备
 * @param deviceId 设备id
 * @param data
 * @returns
 */
export const unbindBatchDevice = (deviceId: string, data: Record<string, any>) =>
  defHttp.post({ url: `/device/gateway/${deviceId}/unbind`, data });

/**
 * 子设备绑定
 * @param deviceId 设备id
 * @param data
 * @returns
 */
export const bindDevice = (deviceId: string, data: Record<string, any>) =>
  defHttp.post({ url: `/device/gateway/${deviceId}/bind`, data });

/**
 * 获取产品列表
 * @param data
 */
export const getProductListNoPage = (data: any) =>
  defHttp.post({ url: '/device/product/_query/no-paging?paging=false', data });

/**
 * 修改设备
 */
export const editDevice = (data: any) => defHttp.put({ url: '/device/instance', data });

/**
 * 新增设备
 */
export const addDevice = (params: any) => defHttp.post({ url: '/device/instance', params });

/**
 * 设备接入网关状态
 * @param id 设备接入网关id
 * @returns
 */
export const queryGatewayState = (id: string) =>
  defHttp.get({ url: `/gateway/device/${id}/detail` }, { isTransformResponse: false });

/**
 * 网络组件状态
 * @param id 网络组件id
 * @returns
 */
export const queryNetworkState = (id: string) =>
  defHttp.get({ url: `/network/config/${id}` }, { isTransformResponse: false });

/**
 * 产品状态
 * @param id 产品id
 * @returns
 */
export const queryProductState = (id: string) =>
  defHttp.get({ url: `/device/product/${id}` }, { isTransformResponse: false });

/**
 * 产品配置
 * @param id 产品id
 * @returns
 */
export const queryProductConfig = (id: string) =>
  defHttp.get({ url: `/device/product/${id}/config-metadata` }, { isTransformResponse: false });

/**
 * 设备配置
 * @param id 设备id
 * @returns
 */
export const queryDeviceConfig = (id: string) =>
  defHttp.get({ url: `/device/instance/${id}/config-metadata` }, { isTransformResponse: false });

/**
 * 查询协议
 * @param type
 * @param transport
 * @returns
 */
export const queryProtocolDetail = (type: string, transport: string) =>
  defHttp.get({ url: `/protocol/${type}/transport/${transport}` });

/**
 * 网络组件启用
 * @param id 网络组件ID
 * @returns
 */
export const startNetwork = (id: string) => defHttp.post({ url: `/network/config/${id}/_start` });

/**
 * 启用网关
 * @param id 网关id
 * @returns
 */
export const startGateway = (id: string) => defHttp.post({ url: `/gateway/device/${id}/_startup` });

/**
 * 网关详情
 * @param id 网关id
 * @returns
 */
export const getGatewayDetail = (id: string) => defHttp.get({ url: `/gateway/device/${id}` });

/*
 * 获取单位列表
 * @returns 单位列表
 */
export const getUnit = () => defHttp.get<UnitType[]>({ url: `/protocol/units` });

/**
 * 执行功能
 * @param deviceId 设备id
 * @param functionId 功能id
 * @param data
 * @returns
 */
export const executeFunctions = (deviceId: string, functionId: string, data: any) =>
  defHttp.post({
    url: `/device/invoked/${deviceId}/function/${functionId}`,
    data
  });

/**
 * 读取属性
 * @param deviceId 设备id
 * @param data
 * @returns
 */
export const readProperties = (deviceId: string, data: any) =>
  defHttp.post({ url: `/device/instance/${deviceId}/properties/_read`, data });

/**
 * 设置属性
 * @param deviceId 设备id
 * @param data
 * @returns
 */
export const settingProperties = (deviceId: string, data: any) =>
  defHttp.put({ url: `/device/instance/${deviceId}/property`, data });

/**
 * 设备功能-执行
 * @param id 设备id
 * @param action
 * @param data
 * @returns
 */
export const execute = (id: string, action: string, data: any) =>
  defHttp.post({ url: `/device/invoked/${id}/function/${action}`, data }, { isTransformResponse: false });

/**
 * 查询通道列表不分页
 * @param data
 * @returns
 */
export const queryChannelNoPaging = (data: any) => defHttp.post({ url: `data-collect/channel/_query/no-paging`, data });

/**
 * 查询采集器列表不分页
 * @param data
 * @returns
 */
export const queryCollectorNoPaging = (data: any) => defHttp.post({ url: `/data-collect/collector/_query/no-paging`, data });

/**
 * 查询点位列表不分页
 * @param data
 * @returns
 */
export const queryPointNoPaging = (data: any) => defHttp.post({ url: `/data-collect/point/_query/no-paging`, data });

/**
 * 查询映射列表
 * @param thingType
 * @param thingId
 * @param params
 * @returns
 */
export const queryMapping = (thingType: string, thingId: any, params?: any) =>
  defHttp.get({
    url: `/things/collector/${thingType}/${thingId}/_query`,
    params
  });

/**
 * 删除映射
 * @param thingType
 * @param thingId
 * @param data
 * @returns
 */
export const removeMapping = (thingType: string, thingId: any, data?: any) =>
  defHttp.post({
    url: `/things/collector/${thingType}/${thingId}/_delete`,
    data
  });

/**
 * 映射树
 * @param data
 * @returns
 */
export const treeMapping = (data?: any) => defHttp.post({ url: `/data-collect/channel/_all/tree`, data });

/**
 * 保存映射
 * @param thingId
 * @param provider
 * @param data
 * @returns
 */
export const saveMapping = (thingId: any, provider: string, data?: any) =>
  defHttp.put({ url: `/things/collector/device/${thingId}/${provider}`, data });

/**
 * 查询边缘网关通道
 * @param deviceId
 * @param data
 * @returns
 */
export const edgeChannel = (deviceId: string, data?: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/data-collector-channel-list/invoke`,
    data
  });

/**
 * 查询边缘网关采集器
 * @param deviceId
 * @param data
 * @returns
 */
export const edgeCollector = (deviceId: string, data?: any) =>
  defHttp.post({ url: `/edge/operations/${deviceId}/data-collector-list/invoke`, data }, { isTransformResponse: false });

/**
 * 查询边缘网关点位
 * @param deviceId
 * @param data
 * @returns
 */
export const edgePoint = (deviceId: string, data?: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/data-collector-point-list/invoke`,
    data
  });

/**
 *
 * @param deviceId
 * @param data
 * @returns
 */
export const getEdgeMap = (deviceId: string, data?: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/device-collector-list/invoke`,
    data
  });

/**
 *
 * @param deviceId
 * @param data
 * @returns
 */
export const removeEdgeMap = (deviceId: string, data?: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/device-collector-delete/invoke`,
    data
  });

/**
 *
 * @param deviceId
 * @param data
 * @returns
 */
export const treeEdgeMap = (deviceId: string, data?: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/data-collector-channel-tree/invoke`,
    data
  });

/**
 *
 * @param deviceId
 * @param data
 * @returns
 */
export const saveEdgeMap = (deviceId: string, data?: any) =>
  defHttp.post({
    url: `/edge/operations/${deviceId}/device-collector-save/invoke`,
    data
  });

/**
 * 查询属性详情
 * @param deviceId
 * @param params
 * @returns
 */
export const getPropertyData = (deviceId: string, params: Record<string, unknown>) =>
  defHttp.get({
    url: `/device/instance/${deviceId}/properties/_query`,
    params
  });

/**
 * 聚合查询设备属性
 * @param deviceId
 * @param data
 * @returns
 */
export const getPropertiesInfo = (deviceId: string, data: Record<string, unknown>) =>
  defHttp.post({ url: `/device/instance/${deviceId}/agg/_query`, data });

/**
 * 聚合查询设备属性
 * @param deviceId
 * @param data
 * @returns
 */
export const getPropertiesList = (deviceId: string, property: string, data: Record<string, unknown>) =>
  defHttp.post({
    url: `/device/instance/${deviceId}/property/${property}/_query`,
    data
  });

/**
 * 获取指定协议
 * @param id
 * @param transport
 * @returns
 */
export const getProtocal = (id: string, transport: string) => defHttp.get({ url: `/protocol/${id}/transport/${transport}` });

export const metadataMapById = (type: 'device' | 'product', productId: string, data: any[]) =>
  defHttp.patch({ url: `/device/metadata/mapping/${type}/${productId}`, data });

export const getMetadataMapById = (type: 'device' | 'product', productId: string) =>
  defHttp.get({ url: `/device/metadata/mapping/${type}/${productId}` });

/**
 * 规则属性
 */
export const saveDeviceVirtualProperty = (productId: string, deviceId: string, data: any[]) =>
  defHttp.patch({
    url: `/virtual/property/product/${productId}/${deviceId}/_batch`,
    data
  });

export const getProtocolMetadata = (id: string, transport: string) =>
  defHttp.get({ url: `/protocol/${id}/${transport}/metadata` });

/**
 * 获取产品解析规则
 * @param productId
 * @returns
 */
export const productCode = (productId: string) => defHttp.get({ url: `/device/transparent-codec/${productId}` });

export const queryDeviceVirtualProperty = (productId: string, deviceId: string, propertyId: string) =>
  defHttp.get({
    url: `/virtual/property/device/${productId}/${deviceId}/${propertyId}`
  });

/**
 * 保存产品解析规则
 * @param productId
 * @returns
 */
export const saveProductCode = (productId: string, data: Record<string, unknown>) =>
  defHttp.post({ url: `/device/transparent-codec/${productId}`, data });
/**
 * 获取设备解析规则
 * @param productId
 * @param deviceId
 * @returns
 */
export const deviceCode = (productId: string, deviceId: string) =>
  defHttp.get({ url: `device/transparent-codec/${productId}/${deviceId}` });
/**
 * 保存设备解析规则
 * @param productId
 * 查询设备日志
 * @param deviceId
 * @param data
 * @returns
 */
export const saveDeviceCode = (productId: string, deviceId: string, data: Record<string, unknown>) =>
  defHttp.post({
    url: `/device/transparent-codec/${productId}/${deviceId}`,
    data
  });
/**
 * 编码测试
 * @param data
 * @returns
 */
export const testCode = (data: Record<string, unknown>) =>
  defHttp.post({ url: `/device/transparent-codec/decode-test`, data });
/**
 * 删除设备解析规则
 * @param productId
 * @param deviceId
 * @returns
 */
export const delDeviceCode = (productId: string, deviceId: string) =>
  defHttp.delete({ url: `/device/transparent-codec/${productId}/${deviceId}` });
/**
 * 删除产品解析规则
 * @param productId
 * @returns
 */
export const delProductCode = (productId: string) => defHttp.delete({ url: `/device/transparent-codec/${productId}` });
export const queryLog = (deviceId: string, data: Record<string, unknown>) => {
  delete data.terms;
  return defHttp.post({ url: `/device/instance/${deviceId}/logs`, data }, { isTransformResponse: false });
};

/**
 * 查询设备日志类型
 * @returns
 */
export const queryLogsType = () => defHttp.get({ url: `/dictionary/device-log-type/items` });

export const getDeviceNumber = (data?: any) => defHttp.post<number>({ url: '/device-instance/_count', data });

/**
 * 导入映射设备
 * @param productId
 * @param data
 */
export const importDeviceByPlugin = (productId: string, data: any[]) =>
  defHttp.post({ url: `/device/instance/plugin/${productId}/import`, data });

export const metadateMapById = (productId: string, data: any[]) =>
  defHttp.put({ url: `/device/metadata/mapping/product/${productId}`, data });

export const getMetadateMapById = (productId: string) =>
  defHttp.get({ url: `/device/metadata/mapping/product/${productId}` });

export const getInkingDevices = (data: string[]) => defHttp.post({ url: '/plugin/mapping/device/_all', data });

/**
 * 获取设备物模型规则TS
 * @param deviceId 设备ID
 * @returns
 */
export const queryTypescript = (deviceId: string) => defHttp.get({ url: `/device/${deviceId}/virtual-property.d.ts` });

/**
 * 获取产品物模型规则TS
 * @param productId 产品ID
 * @returns
 */
export const queryProductTs = (productId: string) => defHttp.get({ url: `/product/${productId}/virtual-property.d.ts` });