hvac-web/src/api/index.ts

import qs from 'qs';

import { request } from '@/utils';

import type {
  AddInterface,
  AgreementUpdate,
  AllDevicesList,
  BatchUpdate,
  CustomParameters,
  DeviceBindQuery,
  DeviceGroup,
  DeviceGroupItem,
  DeviceGroupListQuery,
  DeviceParamGroup,
  DeviceParams,
  DevicesList,
  DevicesListItemData,
  DeviceTypeCount,
  DevWorkHisDataQuery,
  DevWorkHistoryData,
  DevWorkRealTimeData,
  DictTypeData,
  DictTypeDataParams,
  EquipmentDetailsItem,
  EquipmentInformationForm,
  EquipmentTypeItem,
  EquipmentUpdateForm,
  GatewayBody,
  GatewayInformation,
  GatewayInterface,
  GatewayLinkProtocolQuery,
  GatewayListItemData,
  GatewayModelInfo,
  GatewayParameterBody,
  GatewayParameterItemData,
  GetListItem,
  GroupingList,
  GroupingListData,
  GroupRegions,
  InterfaceData,
  ListEquipmentParametersItemData,
  ListInfo,
  ListInterfaces,
  ListPhysicalInterfaces,
  MonitoringForm,
  MonitorPointInfo,
  OutdooForm,
  ParameterVerification,
  ParamValueListAutomaticData,
  ParamValueListAutomaticQuery,
  PostProtocolPage,
  PostProtocolPageItem,
  PostProtocolPageItemData,
  ProtocolBaseInfo,
  ProtocolGatewayListListItem,
  ProtocolItemData,
  ProtocolList,
  ProtocolListData,
  ProtocolListItem,
  ProtocolListQuery,
  ProtocolParamData,
  ProtocolParamInfo,
  ProtocolParamSearchParams,
  ProtocolReset,
  ProtocolStandardParamData,
  ProtocolStandardParamQuery,
  RegionQuery,
  RegionsPointsItem,
  SerialNumberItem,
  SerialNumberItemData,
  SubmitSorting,
  VerificationAgreement,
  VerificationEquipment,
} from '@/types';

/**
 * 获取认证授权服务 url
 */
const apiUaa = (path: string, params?: unknown) => {
  const apiUrl = params ? `${path}?${qs.stringify(params)}` : path;
  return `/api-uaa${apiUrl}`;
};

/**
 * 获取系统服务 url
 */
const apiSys = (path: string, params?: unknown) => {
  const apiUrl = params ? `${path}?${qs.stringify(params)}` : path;
  return `/api-sys${apiUrl}`;
};

/**
 * 获取业务服务 url
 */
const apiBiz = (path: string, params?: unknown) => {
  const apiUrl = params ? `${path}?${qs.stringify(params)}` : path;
  return `/api-biz${apiUrl}`;
};

// ----- 认证授权服务 -----

// 登录和注销

export const loginUser = async () => {
  const params = {
    grant_type: 'password',
    username: 'admin1',
    password: 'admin',
  };

  await request(apiUaa('/oauth/token', params), {
    method: 'POST',
    headers: {
      Authorization: 'Basic ' + btoa('unimat:unimat'),
    },
  });
};

export const logoutUser = async () => {
  await request(apiUaa('/oauth/remove/token'));
};

export const refreshUser = async () => {
  await request(apiUaa('/oauth/token'));
};

// ----- 系统服务 -----

// 环境监控-区域

export const addRegion = async (params: RegionQuery) => {
  await request(apiBiz('/region/add'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const regionUpdate = async (params: RegionQuery) => {
  await request(apiBiz('/region/update'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const regionDelete = async (id: number) => {
  await request(apiBiz(`/region/delete/${id}`), {
    method: 'POST',
  });
};

export const getGroupRegions = async (devGroupId: number) => {
  const data = await request<GroupRegions[]>(apiBiz(`/region/groupRegions/${devGroupId}`), {
    method: 'POST',
  });
  return data;
};

export const getRegionsPointsData = async (devGroupId: number) => {
  const data = await request<RegionsPointsItem[]>(apiBiz(`/region/pointsData/${devGroupId}`), {
    method: 'POST',
  });
  return data;
};

// 环境监控-监测点

export const addMonitorPoint = async (params: MonitoringForm) => {
  await request(apiBiz('/monitorPoint/add'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const deleteMonitorPoint = async (id: number) => {
  await request(apiBiz(`/monitorPoint/delete/${id}`), {
    method: 'POST',
  });
};

export const updateMonitorPoint = async (params: MonitoringForm) => {
  await request(apiBiz('/monitorPoint/update'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const updateRegionMonitorPoint = async (params: OutdooForm) => {
  await request(apiBiz('/region/monitorPoint/update'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const getMonitorPointInfo = async (id: number) => {
  const data = await request<MonitorPointInfo>(apiBiz(`/monitorPoint/info/${id}`));
  return data;
};

// 字典类型表
export const getDictTypeData = async (params: DictTypeDataParams) => {
  const data = await request<DictTypeData[]>(apiSys('/sysDictType/typeAndData/', params));
  return data;
};

// ----- 业务服务 -----

// 设备组列表

export const getPageList = async () => {
  const data = await request<DeviceGroupItem[]>(apiBiz('/deviceGroup/getList'), {
    method: 'POST',
  });
  return data;
};

// 设备列表

export const deviceAdd = async (equipmentInformationForm: EquipmentInformationForm) => {
  const data = await request<number>(apiBiz('/device/add'), {
    method: 'POST',
    body: JSON.stringify(equipmentInformationForm),
  });
  return data;
};

export const getDeviceGroupList = async (params: DeviceGroupListQuery) => {
  const data = await request<DeviceGroup[]>(apiBiz('/deviceGroup/getDeviceGroupList'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
  return data;
};

export const addDeviceBind = async (params: DeviceBindQuery) => {
  await request(apiBiz('/device/bind'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const deviceDeletion = async (ids: number[]) => {
  await request(apiBiz('/device/delete/batch'), {
    method: 'POST',
    body: JSON.stringify(ids),
  });
};

export const equipmentDetails = async (id: number) => {
  const data = await request<EquipmentDetailsItem>(apiBiz(`/device/getBasicInfo/${id}`), {
    method: 'POST',
  });
  return data;
};

export const queryDevicesList = async (devicesList: DevicesList) => {
  const data = await request<DevicesListItemData>(apiBiz('/device/getPageList'), {
    method: 'POST',
    body: JSON.stringify(devicesList),
  });
  return data;
};

export const noPaginationDevicesList = async () => {
  const data = await request<AllDevicesList[]>(apiBiz('/device/getList'), {
    method: 'POST',
  });
  return data;
};

export const getDeviceListSimple = async (deviceId: number) => {
  const data = await request<DeviceParams[]>(apiBiz(`/device/listSimple/${deviceId}`));
  return data;
};

export const getDeviceParams = async (deviceId: number, isProcessData: boolean) => {
  const data = await request<DeviceParamGroup[]>(apiBiz('/device/protocolParamVerify '), {
    method: 'POST',
    body: JSON.stringify({
      deviceId,
      isProcessData,
    }),
  });

  return data;
};

// 设备工况

export const getDevWorkTypeCount = async (deviceGroupId: number, deviceTypes: number[]) => {
  const data = await request<DeviceTypeCount[]>(apiBiz('/deviceCondition/getTypeCount'), {
    method: 'POST',
    body: JSON.stringify({
      deviceGroupId,
      deviceTypes,
    }),
  });

  return data;
};

export const getDevWorkRealTimeData = async (deviceIds: number[], deviceParamCode: string[]) => {
  const data = await request<DevWorkRealTimeData[]>(apiBiz('/deviceCondition/getRTDList'), {
    method: 'POST',
    body: JSON.stringify({
      deviceIds,
      deviceParamCode,
    }),
  });

  return data;
};

export const getDevWorkHistoryData = async (params: DevWorkHisDataQuery) => {
  const data = await request<DevWorkHistoryData[]>(apiBiz('/deviceCondition/getHisList'), {
    method: 'POST',
    body: JSON.stringify(params),
  });

  return data;
};

// 设备网关

export const deviceGatewayUpdate = async (equipmentUpdateForm: EquipmentUpdateForm[]) => {
  await request(apiBiz('/deviceGateway/update'), {
    method: 'POST',
    body: JSON.stringify(equipmentUpdateForm),
  });
};

// 设备协议参数验证

export const postParameterVerification = async (deviceId: number) => {
  const data = await request<ParameterVerification[]>(apiBiz('/protocolParamVerify/list'), {
    method: 'POST',
    body: JSON.stringify(deviceId),
  });
  return data;
};

// 设备参数分组

export const equipmentParametersList = async (groupingList: GroupingList[]) => {
  await request(apiBiz('/deviceParamGroup/update/batch'), {
    method: 'POST',
    body: JSON.stringify(groupingList),
  });
};

export const queryEquipmentParametersList = async (deviceId: number) => {
  const data = await request<GroupingListData[]>(apiBiz('/deviceParamGroup/getList'), {
    method: 'POST',
    body: JSON.stringify({ deviceId }),
  });
  return data;
};

// 设备参数关系表

export const submitSortingList = async (submitSorting: SubmitSorting[]) => {
  await request(apiBiz('/deviceParamGroupRel/update/batch'), {
    method: 'POST',
    body: JSON.stringify(submitSorting),
  });
};

//  设备自定义参数表

export const submitCustomParameters = async (customParameters: CustomParameters[]) => {
  await request(apiBiz('/protocolParamCustomDev/update/batch'), {
    method: 'POST',
    body: JSON.stringify(customParameters),
  });
};

// 网关基本信息

export const addGateway = async () => {
  await request(apiBiz('/gateway/add'));
};

export const gatewayDelete = async (id: number) => {
  await request(apiBiz(`/gateway/delete/${id}`), {
    method: 'POST',
  });
};

export const getAllGatewayList = async () => {
  const data = await request<SerialNumberItem[]>(apiBiz('/gateway/getGtwLinkList'), {
    method: 'POST',
  });
  return data;
};

export const validateGatewayInfo = async (registerGatewayForm: VerificationEquipment) => {
  const data = await request<GatewayInformation>(apiBiz('/gateway/validate', registerGatewayForm), {
    method: 'POST',
  });
  return data;
};

export const gatewayList = async (gatewayBody: GatewayBody) => {
  const data = await request<GatewayListItemData>(apiBiz('/gateway/getPageList'), {
    method: 'POST',
    body: JSON.stringify(gatewayBody),
  });
  return data;
};

// 网关通讯

export const gatewayLinkAdd = async (addInterface: AddInterface) => {
  await request(apiBiz('/gatewayLink/add'), {
    method: 'POST',
    body: JSON.stringify(addInterface),
  });
};

export const addGatewayLinkBatchUpdate = async (params: BatchUpdate[]) => {
  await request(apiBiz('/gatewayLink/batchUpdate'), {
    method: 'POST',
    body: JSON.stringify({ gatewayLinks: params }),
  });
};

export const gatewayLinkDelete = async (id: number) => {
  await request(apiBiz(`/gatewayLink/delete/${id}`), {
    method: 'POST',
  });
};

export const gatewayLinkGetList = async (gatewayId: number) => {
  const data = await request<InterfaceData[]>(apiBiz(`/gatewayLink/getList/${gatewayId}`), {
    method: 'POST',
  });
  return data;
};

export const gatewayLinkUpdate = async (agreementUpdate: AgreementUpdate) => {
  await request(apiBiz('/gatewayLink/update'), {
    method: 'POST',
    body: JSON.stringify(agreementUpdate),
  });
};

// 网关型号

export const getGatewayModelInfo = async (id: number) => {
  const data = await request<GatewayModelInfo>(apiBiz(`/gatewayModel/info/${id}`));
  return data;
};

export const getGatewayModelInterfaces = async (id: number) => {
  const data = await request<GatewayInterface[]>(apiBiz(`/gatewayModel/interfaces/${id}`), {
    method: 'POST',
  });
  return data;
};

// 网关物理接口协议

export const obtainListPhysicalInterfaces = async (id: number) => {
  const data = await request<ListPhysicalInterfaces[]>(apiBiz(`/gatewayInterfaceProtocol/getProtocols/${id}`));
  return data;
};

// 网关型号物理接口

export const obtainListInterfaces = async (id: number) => {
  const data = await request<ListInterfaces[]>(apiBiz(`/gatewayPhysicalInterface/getInterfaces/${id}`));
  return data;
};

// 网关接口协议

export const getParamValueListAutomatic = async (params: ParamValueListAutomaticQuery) => {
  const data = await request<ParamValueListAutomaticData[]>(apiBiz('/gatewayLinkProtocol/getParamValueListAutomatic'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
  return data;
};

export const getAllGatewayLinkProtocol = async <T>(params: GatewayLinkProtocolQuery) => {
  const data = await request<T>(apiBiz('/gatewayLinkProtocol/getLinkParams'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
  return data;
};

export const gatewayLinkProtocolList = async <T>(protocolListItem: ProtocolListItem) => {
  const data = await request<T>(apiBiz('/gatewayLinkProtocol/getParamPageList'), {
    method: 'POST',
    body: JSON.stringify(protocolListItem),
  });
  return data;
};

export const gatewayLinkProtocolGatewayList = async (protocolGatewayListListItem: ProtocolGatewayListListItem) => {
  const data = await request<ListEquipmentParametersItemData>(
    apiBiz('/gatewayLinkProtocol/getParamPageListByGateway'),
    {
      method: 'POST',
      body: JSON.stringify(protocolGatewayListListItem),
    },
  );
  return data;
};

export const gatewayLinkList = async (id: number) => {
  const data = await request<VerificationAgreement[]>(apiBiz(`/gatewayLinkProtocol/getProtocolInfoList/${id}`), {
    method: 'POST',
  });
  return data;
};

export const gatewayLinkProtocolReset = async (protocolReset: ProtocolReset) => {
  await request(apiBiz('/gatewayLinkProtocol/reset'), {
    method: 'POST',
    body: JSON.stringify(protocolReset),
  });
};

export const postProtocolCandidatesList = async (protocolList: ProtocolList, gatewayId: number) => {
  const data = await request<ProtocolItemData>(apiBiz(`/gatewayLinkProtocol/getProtocolCandidates/${gatewayId}`), {
    method: 'POST',
    body: JSON.stringify(protocolList),
  });
  return data;
};

export const gatewayParameterList = async (gatewayParameterBody: GatewayParameterBody) => {
  const data = await request<GatewayParameterItemData>(apiBiz('/gatewayLinkProtocol/getParamValuePageList'), {
    method: 'POST',
    body: JSON.stringify(gatewayParameterBody),
  });
  return data;
};

// 组织网关

export const orgGatewayRegister = async (gatewayId: number) => {
  await request(apiBiz('/orgGateway/register'), {
    method: 'POST',
    body: JSON.stringify({ gatewayId }),
  });
};

export const orgGatewayUnregister = async (gatewayId: number) => {
  await request(apiBiz(`/orgGateway/unregister/${gatewayId}`), {
    method: 'POST',
  });
};

export const orgGatewaySerialNumber = async (protocolList: ProtocolList) => {
  const data = await request<SerialNumberItemData>(apiBiz('/orgGateway/getGatewayPageList'), {
    method: 'POST',
    body: JSON.stringify(protocolList),
  });
  return data;
};

// 协议标准参数

export const getProtocolStandardParamList = async (params: ProtocolStandardParamQuery) => {
  const data = await request<ProtocolStandardParamData>(apiBiz('/protocolStandardParam/getPageList'), {
    method: 'POST',
    body: JSON.stringify(params),
  });

  return data;
};

// 协议参数

export const addProtocolParam = async (params: Partial<ProtocolParamInfo>) => {
  await request(apiBiz('/protocolParamInfo/add'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const getProtocolParamList = async (params: ProtocolParamSearchParams) => {
  const data = await request<ProtocolParamData>(apiBiz('/protocolParamInfo/getPageList'), {
    method: 'POST',
    body: JSON.stringify(params),
  });

  return data;
};

export const batchDeleleProtocolParam = async (params: number[]) => {
  await request(apiBiz('/protocolParamInfo/batchDeleleByIds'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

// 协议基本信息

export const addProtocolBaseInfo = async (params: Partial<ProtocolBaseInfo>) => {
  const data = await request<number>(apiBiz('/protocolBaseInfo/add'), {
    method: 'POST',
    body: JSON.stringify(params),
  });

  return data;
};

export const downloadProtocolTemplate = async (fileName: string) => {
  const blob = await request<Blob>(apiBiz(`/protocolBaseInfo/downloadTemplate/${fileName}`));
  return blob;
};

export const uploadUserProtocol = async (protocolType: string, file: Blob) => {
  const formData = new FormData();
  formData.append('file', file);

  const data = await request<Pick<ProtocolBaseInfo, 'id' | 'protocolName' | 'protocolType'>>(
    apiBiz('/protocolBaseInfo/uploadUserTemplate/', { protocolType }),
    {
      method: 'POST',
      body: formData,
    },
  );

  return data;
};

export const reUploadUserProtocol = async (protocolType: string, id: number, file: Blob) => {
  const formData = new FormData();
  formData.append('file', file);

  const data = await request<Pick<ProtocolBaseInfo, 'id' | 'protocolName' | 'protocolType'>>(
    apiBiz('/protocolBaseInfo/resetConfiguration/', { protocolType, id }),
    {
      method: 'POST',
      body: formData,
    },
  );

  return data;
};

export const downloadUserProtocol = async (id: number) => {
  const blob = await request<Blob>(apiBiz('/protocolBaseInfo/downloadUserProtocol/', { id }));
  return blob;
};

/**
 * @deprecated
 */
export const getUploadProtocol = async (protocolType: string, protocolName: string) => {
  const data = await request<ProtocolBaseInfo>(
    apiBiz('/protocolBaseInfo/findUploadProtocolBaseInfo/', {
      protocolType,
      protocolName,
    }),
  );

  return data;
};

export const getProtocolBaseInfo = async (id: number) => {
  const data = await request<ProtocolBaseInfo>(apiBiz(`/protocolBaseInfo/info/${id}`));
  return data;
};

export const updateProtocolBaseInfo = async (params: Partial<ProtocolBaseInfo>) => {
  await request(apiBiz('/protocolBaseInfo/update'), {
    method: 'POST',
    body: JSON.stringify(params),
  });
};

export const deleteProtocolBaseInfo = async (id: number) => {
  await request(apiBiz(`/protocolBaseInfo/delete/${id}`), {
    method: 'POST',
  });
};

export const completeProtocolConfig = async (id: number) => {
  await request(apiBiz(`/protocolBaseInfo/completeConfiguration/${id}`), {
    method: 'POST',
  });
};

export const getProtocolList = async (params: ProtocolListQuery) => {
  const data = await request<ProtocolListData>(apiBiz('/protocolBaseInfo/getPageList'), {
    method: 'POST',
    body: JSON.stringify(params),
  });

  return data;
};

// 协议参数表

export const postProtocolPageList = async (postProtocolPage: PostProtocolPage) => {
  const data = await request<PostProtocolPageItemData>(apiBiz('/protocolParamInfo/page/list'), {
    method: 'POST',
    body: JSON.stringify(postProtocolPage),
  });
  return data;
};

export const postProtocolGetList = async (getListItem: GetListItem) => {
  const data = await request<PostProtocolPageItem[]>(apiBiz('/protocolParamInfo/getList'), {
    method: 'POST',
    body: JSON.stringify(getListItem),
  });
  return data;
};

// 全局参数

export const groupList = async (listInfo: ListInfo) => {
  const data = await request<EquipmentTypeItem[]>(apiBiz('/deviceGlobalData/getList'), {
    method: 'POST',
    body: JSON.stringify(listInfo),
  });
  return data;
};