imobile_for_reactnative/NativeModule/interfaces/iServer/SService.ts

iMobile for ReactNative，是SuperMap iMobile推出的一款基于React-Native框架的移动应用开发工具。基于该开发工具，用户可以使用JavaScript开发语言，开发出在Android和IOS操作系统下运行的原生移动GIS应用，入门门槛低，一次开发，处处运行。

import { request } from '../utils'
import { NativeModules, NativeEventEmitter, EmitterSubscription } from 'react-native'
import * as URL from './url'
import {
  HttpRequest,
  UrlHeader,
  ServiceRequestParams,
  ServiceInfoParams,
  ServiceData,
  ServiceDatasource,

  DataServiceResponse,
  ServicePutResponse,
  RecordInfo,
  ResultDataBase,
  ServiceInfo,
} from './types'
import { EventConst } from '../../constains/index'
import { QueryParamToStr, SetUrlParams } from './UrlUtils'
import { getServerUrl, getCookie } from './SOnline'
import { TOnlineDataType } from './types'
import { DatasetInfo } from '../data/SData'
import { SOnline } from '.'
const _SService = NativeModules.SService
const nativeEvt = new NativeEventEmitter(_SService)
const SIPortalService = NativeModules.SIPortalService
const SOnlineService = NativeModules.SOnlineService

export type CoordinationType = 'iportal' | 'online'

const HttpResponseException = {
  succeed: false,
}

const ResultDataException = {
  total: 0,
  content: [],
}


/** 发布服务结果 */
export interface PushlishResult {
  /** 是否发布成功 */
  succeed: boolean,
  /** 结果信息 */
  customResult?: string,
  /** 若失败，返回错误信息 */
  error?: any,
}

/** 服务数据源查询结果 */
export interface ServiceDatasources {
  /** 所含数据源名称的数组 */
  datasourceNames: string[],
  /** 所含数据源地址的数组 */
  childUriList: string[],
  /** 所含数据源个数 */
  datasourceCount: number,
}

/**************************************************************数据服务API***************************************************************************/

/**
 * 根据数据id发布服务
 * @param id 数据id
 * @param dataType 数据的类型
 * @returns 返回发布服务结果
 */
export async function publishService(id: number, dataType: TOnlineDataType, serviceType?: string): Promise<PushlishResult> {
  let type
  if (serviceType) {
    type = serviceType
  } else if (dataType === 'UDB') {
    type = 'RESTDATA'
  } else if (dataType === 'WORKSPACE') {
    type = 'RESTMAP,RESTDATA'
  } else {
    return { succeed: false }
  }
  let url = SetUrlParams(getServerUrl() + URL.PubllishService[0], [id, type])
  let headers = {}
  const cookie = await getCookie()
  if (cookie) {
    headers = {
      cookie: cookie,
    }
  }
  const result = await request(encodeURI(url), URL.PubllishService[1], {
    headers: headers,
    body: true,
  })

  return result

  // const publishResults: PushlishResult[] = []
  // if (result.succeed && result.customResult) {
  //   const dataServiceIds = result.customResult.split(',')
  //   for (const dataServiceId of dataServiceIds) {
  //     const publishResultUrl = SetUrlParams(getServerUrl() + URL.GetPubllishDataService[0], [id, dataServiceId])
  //     let publishResult
  //     let overTime = 0 // 防止发布服务获取结果超时,返回undefined
  //     while (!publishResult && overTime < 10) {
  //       publishResult = await request(encodeURI(publishResultUrl), URL.GetPubllishDataService[1], {
  //         headers: headers,
  //         // body: null,
  //       })
  //       overTime++
  //     }
  //     if (publishResult) {
  //       publishResult.customResult = dataServiceId
  //     } else if (overTime === 10) {
  //       publishResult = {
  //         succeed: false,
  //         error: 'timeout',
  //       }
  //     }
  //     publishResults.push(publishResult)
  //   }

  //   return publishResults
  // } else {
  //   return [result]
  // }
}

/**
 * 根据数据id获取服务信息
 * @param dataId 数据id
 * @param dataServiceId 服务ID
 * @returns 返回服务信息
 */
export async function getServiceDetail(dataId: number, dataServiceId: number): Promise<PushlishResult> {
  let headers = {}
  const cookie = await getCookie()
  if (cookie) {
    headers = {
      cookie: cookie,
    }
  }
  const publishResults: PushlishResult[] = []
  const publishResultUrl = SetUrlParams(getServerUrl() + URL.GetPubllishDataService[0], [dataId, dataServiceId])
  let publishResult
  let overTime = 0 // 防止发布服务获取结果超时,返回undefined
  while (!publishResult && overTime < 10) {
    publishResult = await request(encodeURI(publishResultUrl), URL.GetPubllishDataService[1], {
      headers: headers,
      // body: null,
    })
    overTime++
  }
  if (publishResult) {
    publishResult.customResult = dataServiceId
  } else if (overTime === 10) {
    publishResult = {
      succeed: false,
      error: 'timeout',
    }
  }
  return publishResult
}

/**
 * 取消发布服务
 * @param serviceID 服务ID
 * @returns 返回删除结果
 */
export async function unPublishService(serviceID: string): Promise<boolean> {
  // let url = getServerUrl() + SetUrlParams(getServerUrl() + URL.DeleteService[0], [serviceID])
  // let headers = {}
  // const cookie = await getCookie()
  // if (cookie) {
  //   headers = {
  //     cookie: cookie,
  //   }
  // }

  // url = encodeURI(url)
  // const result = await request(encodeURI(url), URL.DeleteService[1], {
  //   headers: headers,
  // })
  // return result
  const userType = SOnline._getUserType()
  if (userType === 'common_user') {
    return SOnlineService.deleteServiceWithServiceId(serviceID)
  } else if (userType === 'iPortal_common_user') {
    return SIPortalService.deleteMyService(serviceID)
  }
  return false
}

// /**
//  * 取消发布服务
//  * @param serviceID 数据文件名
//  * @param name 服务名
//  * @returns 返回取消发布结果
//  */
// export async function unPublishService(serviceID: string, name: string): Promise<PushlishResult[]> {
//   let url = getServerUrl() + SetUrlParams(getServerUrl() + URL.UnPubllishService[0], [serviceID, name])
//   let headers = {}
//   const cookie = await getCookie()
//   if (cookie) {
//     headers = {
//       cookie: cookie,
//     }
//   }

//   url = encodeURI(url)
//   const result = await request(encodeURI(url), URL.UnPubllishService[1], {
//     headers: headers,
//   })
//   return result
// }

/**
 * 设置服务公开私有
 * @param id 服务id
 * @param isPublic 是否公开
 * @returns 返回是否设置成功
 */
export async function setServicesShareConfig(id: string, isPublic: boolean): Promise<boolean> {
  let url = getServerUrl() + URL.ShareService[0]
  let headers = {}
  const cookie = await getCookie()
  if (cookie) {
    headers = {
      cookie: cookie,
    }
  }
  let entities: any[]
  if (isPublic) {
    entities = [
      {
        entityType: 'USER',
        entityName: 'GUEST',
        permissionType: 'READ',
      },
    ]
  } else {
    entities = []
  }
  url = encodeURI(url)
  let result = await request(url, URL.ShareService[1], {
    headers: headers,
    body: {
      ids: [id],
      entities: entities,
    },
  })
  return result.succeed
}

/**
 * 根据查询条件，获取匹配的所有服务
 * @param params 服务查询参数
 * @returns 返回服务查询结果数组
 */
export async function getAllServices(params: ServiceRequestParams): Promise<ResultDataBase<ServiceInfo>[]> {
  try {
    const url = getServerUrl() + URL.GetAllService[0] + QueryParamToStr(params)
    const headers: UrlHeader = {}
    const cookie = await getCookie()
    if (cookie) {
      headers.cookie = cookie
    }
    return request(url, URL.GetAllService[1], {
      headers: headers,
    })
  } catch (e) {
    return []
  }
}

/**
 * 根据数据服务初始化数据源
 * 传入数据服务，在工作空间中找到对应数据源，并把数据服务记录到对应数据集中
 * @param serviceDatas 数据源 以及数据源中数据集对应的服务地址url的集合
 * @returns 返回是否设置成功
 */
export async function initDatasourceWithService(serviceDatas: ServiceDatasource[]): Promise<boolean> {
  try {
    return await _SService.initDatasourceWithService(serviceDatas)
  } catch (e) {
    return false
  }
}

/**
 * 设置数据集关联的在线服务url，可把普通图层，设置为数据服务图层
 * @param dataInfo    数据源和数据集名称
 * @param serviceData 在线服务数据信息
 * @returns 返回是否设置成功
 */
export async function setDataService(dataInfo: DatasetInfo, serviceData: ServiceData): Promise<boolean> {
  try {
    return await _SService.setDataService(dataInfo, serviceData)
  } catch (e) {
    return false
  }
}

/**
 * 查询服务
 * @param params 查询服务条件
 * @returns 返回符合条件的服务列表
 */
export async function getServices(params: ServiceRequestParams): Promise<ResultDataBase<ServiceInfo>[]> {
  try {
    const url = getServerUrl() + URL.GetAllService[0] + QueryParamToStr(params)
    const headers: UrlHeader = {}
    const cookie = await getCookie()
    if (cookie) {
      headers.cookie = cookie
    }
    return request(url, URL.GetAllService[1], {
      headers: headers,
    })
  } catch (e) {
    return []
  }
}

/**
 * 根据服务ID，查询指定服务
 * @param serviceId 服务id
 * @returns 返回指定服务
 */
export async function getService(serviceId: string): Promise<ResultDataBase<ServiceInfo> | null> {
  try {
    const url = SetUrlParams(getServerUrl() + URL.GetService[0], [serviceId])
    const headers: UrlHeader = {}
    const cookie = await getCookie()
    if (cookie) {
      headers.cookie = cookie
    }
    return request(url, URL.GetService[1], {
      headers: headers,
    })
  } catch (e) {
    return null
  }
}

/**
 * 查询我的服务
 * @param params 服务查询参数
 * @returns 返回服务查询结果数组
 */
export async function getMyServices(params: HttpRequest): Promise<ResultDataBase<ServiceInfo>[]> {
  try {
    const url = getServerUrl() + URL.GetUserService[0] + QueryParamToStr(params)
    const headers: UrlHeader = {}
    const cookie = await getCookie()
    if (cookie) {
      headers.cookie = cookie
    }

    return request(url, URL.GetUserService[1], {
      headers: headers,
    })
  } catch (e) {
    return []
  }
}

/**
 * 修改指定服务
 * @param serviceId 服务ID
 * @param params    要修改的服务内容
 * @returns         返回服务修改结果
 */
export async function putService(serviceId: string, params: ServiceInfoParams): Promise<ServicePutResponse> {
  try {
    const url = SetUrlParams(getServerUrl() + URL.PutService[0], [serviceId])
    params.authorizeSetting[0].permissionType = "READWRITE"
    const headers: UrlHeader = {}
    const cookie = await getCookie()
    if (cookie) {
      headers.cookie = cookie
    }
    return request(url, URL.PutService[1], {
      headers: headers,
      body: params,
    })
  } catch (e) {
    return HttpResponseException
  }
}

/**
 * 获取服务中的数据源 或 数据源中的数据集，
 * 若有datasourceName，则查询数据源中的数据集，
 * 若没有datasourceName，则查询数据源。
 * @param linkUrl         服务地址
 * @param datasourceName  要查询的数据源名称（可选）
 * @returns               返回数据源结果，若为null，则查询失败
 */
export async function getServiceData(linkUrl: string, datasourceName?: string): Promise<ServiceDatasources | null> {
  try {
    let url = linkUrl
    if (datasourceName) {
      url = url + '/data/datasources/' + datasourceName + '/datasets.json'
    } else {
      url = url + '/data/datasources.json'
    }

    const headers: UrlHeader = {}
    const cookie = await getCookie()
    if (cookie) {
      headers.cookie = cookie
    }

    return request(url, 'GET', {
      headers: headers,
    })
  } catch (e) {
    return null
  }
}

/**
 * 向iServer服务器中添加对象。
 * @param datasetUrl 指定的数据服务地址
 * @param serviceName 服务名称
 * @param dataSourceName 待添加对象数据源。
 * @param dataSetName 待添加对象数据集。
 * @param geoID 待添加对象。
 * @returns 返回是否添加成功
 */
export async function addFeature(datasetUrl: string, serviceName: string, dataSourceName: string, dataSetName: string, geoID: number): Promise<boolean> {
  try {
    return await _SService.addFeature(datasetUrl, serviceName, dataSourceName, dataSetName, geoID)
  } catch (e) {
    return false
  }
}

/**
 * 向指定的数据服务地址添加对象。
 * @param fullUrl 指定的数据服务地址，如：http://192.168.120.139:8090/iserver/services/data-China400/rest/data/datasources/China400/datasets/City_R。
 * @param dataSourceName 待添加对象数据源。
 * @param dataSetName 待添加对象数据集。
 * @param geoID 待添加对象。
 * @returns 返回是否添加成功
 */
export async function addFeatureFullUrl(fullUrl: string, dataSourceName: string, dataSetName: string, geoID: number): Promise<boolean> {
  try {
    return await _SService.addFeatureFullUrl(fullUrl, dataSourceName, dataSetName, geoID)
  } catch (e) {
    return false
  }
}

/**
 * 根据指定的对象ID数组删除iServer服务器中的对象。
 * @param strUrl 数据服务地址。
 * @param serviceName 服务名称。
 * @param datasourceName 数据源名。
 * @param datasetName 数据集名。
 * @param featureIDs 对象ID数组。
 * @returns 返回是否删除成功
 */
export async function deleteFeature(datasetUrl: string, serviceName: string, dataSourceName: string, dataSetName: string, featureIDs: number[]): Promise<boolean> {
  try {
    return await _SService.deleteFeature(datasetUrl, serviceName, dataSourceName, dataSetName, featureIDs)
  } catch (e) {
    return false
  }
}

/**
 * 指定数据服务地址下的对象。
 * @param fullUrl 指定的数据服务地址，如：http://192.168.120.139:8090/iserver/services/data-China400/rest/data/datasources/China400/datasets/City_R。
 * @param featureIDs 对象ID数组。
 * @returns 返回是否删除成功
 */
export async function deleteFeatureFullUrl(fullUrl: string, featureIDs: number[]): Promise<boolean> {
  try {
    return await _SService.deleteFeatureFullUrl(fullUrl, featureIDs)
  } catch (e) {
    return false
  }
}

/**
 * 根据指定的对象ID数组删除iServer服务器中的对象。
 * @param strUrl 数据服务地址。
 * @param serviceName 服务名称。
 * @param datasourceName 数据源名。
 * @param datasetName 数据集名。
 * @param featureID 要修改的对象ID。
 * @returns 返回是否修改成功
 */
export async function modifyFeature(datasetUrl: string, serviceName: string, dataSourceName: string, dataSetName: string, featureID: number): Promise<boolean> {
  try {
    return await _SService.modifyFeature(datasetUrl, serviceName, dataSourceName, dataSetName, featureID)
  } catch (e) {
    return false
  }
}

/**
 * 向数据服务中添加数据集
 * @param datasetUrl    数据服务地址。
 * @param serviceName   服务名称。
 * @param dataInfo      数据源数据集名称
 * @param datasetType   数据集类型
 * @returns 
 */
export async function addDataset(datasetUrl: string, serviceName: string, dataInfo: DatasetInfo, datasetType: number): Promise<boolean> {
  try {
    return await _SService.addDataset(datasetUrl, serviceName, dataInfo.datasourceName, dataInfo.datasetName, datasetType)
  } catch (e) {
    return false
  }
}

/**
 * 通过复制指定数据源中的指定数据集向服务中添加数据集。
 * @param strUrl 数据服务地址。
 * @param serviceName 服务名称。
 * @param desDataInfo     目标数据源数据集名称
 * @param srcDataInfo     源数据源数据集名称
 * @returns 返回是否添加成功
 */
export async function addDatasetWithDatasource(datasetUrl: string, serviceName: string, desDataInfo: DatasetInfo, srcDataInfo: DatasetInfo): Promise<boolean> {
  try {
    return await _SService.addDatasetWithDatasource(datasetUrl, serviceName, desDataInfo.datasourceName, desDataInfo.datasetName, srcDataInfo.datasourceName, srcDataInfo.datasetName)
  } catch (e) {
    return false
  }
}

/**
 * 删除数据集。
 * @param strUrl      数据服务地址。
 * @param serviceName 服务名称。
 * @param dataInfo    数据源数据集名称
 * @returns 返回是否删除成功
 */
export async function deleteDataset(datasetUrl: string, serviceName: string, dataInfo: DatasetInfo): Promise<boolean> {
  try {
    return await _SService.deleteDataset(datasetUrl, serviceName, dataInfo.datasourceName, dataInfo.datasetName)
  } catch (e) {
    return false
  }
}

/**
 * 删除数据集。
 * @param fullUrl 要删除的数据集地址，，如：http://192.168.120.1:8090/iserver/services/data-world/rest/data/datasources/World/datasets/Lakes。
 * @returns 返回是否删除成功
 */
export async function deleteDatasetFullUrl(fullUrl: string): Promise<boolean> {
  try {
    return await _SService.deleteDatasetFullUrl(fullUrl)
  } catch (e) {
    return false
  }
}

/**
 * 下载到本地
 * @param datasetUrl      服务数据集地址
 * @param dataSourceName  存入本地数据源名称
 * @returns 返回是否调用成功
 */
export async function downloadToLocal(datasetUrl: string, dataSourceName: string): Promise<boolean> {
  try {
    return await _SService.downloadToLocal(datasetUrl, dataSourceName)
  } catch (e) {
    return false
  }
}

/**
 * 直接读取在线数据集
 * @param datasetUrl  服务数据集地址
 * @param fromIndex   读取数据集集合的起始点
 * @param toIndex     读取数据集集合的结束点
 * @returns           返回下载的recordset数据信息
 */
export async function downloadRecordset(datasetUrl: string, fromIndex: number, toIndex: number): Promise<RecordInfo[]> {
  try {
    return await _SService.downloadRecordset(datasetUrl, fromIndex, toIndex)
  } catch (e) {
    return []
  }
}

/**
 * 更新到本地
 * @param datasetUrl   服务数据集地址
 * @param dataInfo     数据源数据集名称
 * @returns            返回是否调用成功
 */
export function updateToLocal(datasetUrl: string, dataInfo: DatasetInfo): Promise<boolean> {
  return _SService.updateToLocal(datasetUrl, dataInfo.datasourceName, dataInfo.datasetName)
}

/**
 * 上传到服务器
 * @param datasetUrl   服务数据集地址
 * @param dataInfo     数据源数据集名称
 * @returns            返回是否调用成功
 */
export async function uploadToService(datasetUrl: string, dataInfo: DatasetInfo): Promise<boolean> {
  try {
    return await _SService.uploadToService(datasetUrl, dataInfo.datasourceName, dataInfo.datasetName)
  } catch (e) {
    return false
  }
}

/** 数据服务下载监听 */
let dataServiceDownloadHandler: EmitterSubscription | null | undefined = null
/** 数据服务更新监听 */
let dataServiceUpdateHandler: EmitterSubscription | null | undefined = null
/** 数据服务上传监听 */
let dataServiceUploadHandler: EmitterSubscription | null | undefined = null
/**
 * 设置数据服务监听
 * @param handlers
 */
export async function addDataServiceListener(handlers: {
  downloadHandler?: (result: DataServiceResponse) => void,
  updateHandler?: (result: DataServiceResponse) => void,
  uploadHandler?: (result: DataServiceResponse) => void,
}) {
  try {
    removeDataServiceListener()
    dataServiceDownloadHandler = handlers?.downloadHandler && nativeEvt.addListener(EventConst.ONLINE_DATA_SERVICE_DOWNLOAD, result => {
      if (typeof handlers.downloadHandler === "function") {
        handlers.downloadHandler(result)
      }
    })
    dataServiceUpdateHandler = handlers?.updateHandler && nativeEvt.addListener(EventConst.ONLINE_DATA_SERVICE_UPDATE, result => {
      if (typeof handlers.updateHandler === "function") {
        handlers.updateHandler(result)
      }
    })
    dataServiceUploadHandler = handlers?.updateHandler && nativeEvt.addListener(EventConst.ONLINE_DATA_SERVICE_UPLOAD, result => {
      if (typeof handlers.uploadHandler === "function") {
        handlers.uploadHandler(result)
      }
    })

  } catch (e) {
    console.error(e)
  }
}

/** 移除数据服务监听 */
function removeDataServiceListener() {
  if (dataServiceDownloadHandler) {
    dataServiceDownloadHandler.remove()
    dataServiceDownloadHandler = null
  }
  if (dataServiceUpdateHandler) {
    dataServiceUpdateHandler.remove()
    dataServiceUpdateHandler = null
  }
  if (dataServiceUploadHandler) {
    dataServiceUploadHandler.remove()
    dataServiceUploadHandler = null
  }
}