MapGIS Client for JavaScript API

import BaseServer from '../../BaseServer'
import { Zondy } from '../../../base'
import { FetchMethod } from '../../../base/enum'

/**
 * ArcGIS的GeometryServer服务
 * @class ArcGISGeometryServer
 * @moduleEx ServiceModule
 * @extends BaseServer
 * @param {Object} options 构造参数
 * @param {String} [options.url = 无] 服务基地址
 */
class ArcGISGeometryServer extends BaseServer {
  constructor(options) {
    super(options)
  }

  /**
   * 缓冲分析
   * @param options 查询参数
   * @param {Geometry} [options.geometries] 要计算的几何，必填
   * @param {SpatialReference} [options.inSR] 原始参考系，必填
   * @param {Number} [options.distances] 缓冲半径，必填
   * @param {SpatialReference} [options.outSR] 输出参考系，优先级bufferSR>outSR>inSR
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   * @param {SpatialReference} [options.bufferSR] 缓冲分析参考系，优先级bufferSR>outSR>inSR
   * @param {String} [options.unit] 单位
   * @param {String} [options.callback]
   */
  bufferAnalyse(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      geometries: {
        type: 'Object',
        required: true,
        process(geometries) {
          return `&geometries=${JSON.stringify(geometries)}`
        }
      },
      inSR: {
        type: 'String',
        required: true
      },
      distances: {
        type: 'Number',
        required: true
      },
      outSR: {
        type: 'String'
      },
      unit: {
        type: 'String'
      },
      bufferSR: {
        type: 'String'
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/buffer?f=json`
      }
    )
  }

  /**
   * 几何裁剪
   * @param options 查询参数
   * @param {Object} [options.cutter] 裁剪几何的线对象，必填
   * @param {Object} [options.target] 被裁剪的线或多边形对象，必填
   * @param {String} [options.sr] 被裁剪的线或多边形对象的坐标系，必填
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   */
  cutGeometry(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      cutter: {
        type: 'Object',
        required: true,
        process(geometries) {
          return `&cutter=${JSON.stringify(geometries)}`
        }
      },
      target: {
        type: 'Object',
        required: true,
        process(geometries) {
          return `&target=${JSON.stringify(geometries)}`
        }
      },
      sr: {
        type: 'String',
        required: true
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/cut?f=json`
      }
    )
  }

  /**
   * 求差计算
   * @param options 查询参数
   * @param {Object} [options.geometries] 要求差的多边形集合，必填
   * @param {Object} [options.geometry] 被求差的几何，必填
   * @param {String} [options.sr] 几何的坐标系，必填
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   */
  calculateDifference(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      geometries: {
        type: 'Object',
        required: true,
        process(geometries) {
          return `&geometries=${JSON.stringify(geometries)}`
        }
      },
      geometry: {
        type: 'Object',
        required: true,
        process(geometry) {
          return `&geometry=${JSON.stringify(geometry)}`
        }
      },
      sr: {
        type: 'String',
        required: true
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/difference?f=json`
      }
    )
  }

  /**
   * 计算距离
   * @param options 查询参数
   * @param {Object} [options.geometry1] 要计算距离的多边形1，必填
   * @param {Object} [options.geometry2] 要计算距离的多边形2，必填
   * @param {String} [options.sr] 几何的坐标系，必填
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   * @param {String} [options.distanceUnit] 单位
   */
  calculateDistance(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      geometry1: {
        type: 'Object',
        required: true,
        process(geometry1) {
          return `&geometry1=${JSON.stringify(geometry1)}`
        }
      },
      geometry2: {
        type: 'Object',
        required: true,
        process(geometry2) {
          return `&geometry2=${JSON.stringify(geometry2)}`
        }
      },
      sr: {
        type: 'String',
        required: true
      },
      distanceUnit: {
        type: 'String'
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/distance?f=json`
      }
    )
  }

  /**
   * 求交计算
   * @param options 查询参数
   * @param {Object} [options.geometries] 要求交的几何集合，必填
   * @param {Object} [options.geometry] 被求交的几何，必填
   * @param {String} [options.sr] 被求交的几何的坐标系，必填
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   */
  calculateIntersect(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      geometries: {
        type: 'Object',
        required: true,
        process(geometries) {
          return `&geometries=${JSON.stringify(geometries)}`
        }
      },
      geometry: {
        type: 'Object',
        required: true,
        process(geometry) {
          return `&geometry=${JSON.stringify(geometry)}`
        }
      },
      sr: {
        type: 'String',
        required: true
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/intersect?f=json`
      }
    )
  }

  /**
   * 计算拓扑关系
   * @param options 查询参数
   * @param {Object} [options.geometries1] 被求交的几何的坐标系，必填
   * @param {Object} [options.geometries2] 被求交的几何的坐标系，必填
   * @param {String} [options.sr] 几何的坐标系，必填
   * @param {String} [options.relation] 设置拓扑关系，必填
   * @param {Object} [options.relationParam] 必填
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   */
  calculateTopologyRelation(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      geometries1: {
        type: 'Object',
        required: true,
        process(geometries1) {
          return `&geometries1=${JSON.stringify(geometries1)}`
        }
      },
      geometries2: {
        type: 'Object',
        required: true,
        process(geometries2) {
          return `&geometries2=${JSON.stringify(geometries2)}`
        }
      },
      sr: {
        type: 'String',
        required: true
      },
      relation: {
        type: 'String',
        required: true
      },
      relationParam: {
        type: 'String',
        required: true
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/relation?f=json`
      }
    )
  }

  /**
   * @function ArcGISFeatureServer.prototype.simplifyGeometry
   * @description 化简几何，后端接口/igs/rest/services/system/arcgis/GeometryServer/simplify
   * @param options 查询参数
   * @param {Object} [options.geometries] 要化简的几何对象，必填
   * @param {String} [options.sr] 几何对象的坐标系，必填
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   */
  simplifyGeometry(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      geometries: {
        type: 'Object',
        required: true,
        process(geometries) {
          return `&geometries=${JSON.stringify(geometries)}`
        }
      },
      sr: {
        type: 'String',
        required: true
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/simplify?f=json`
      }
    )
  }

  /**
   * 求并
   * @param options 查询参数
   * @param {Object} [options.geometries] 要合并的几何对象，必填
   * @param {String} [options.sr] 几何对象的坐标系，必填
   * @param {Function} [options.success] 查询成功回调函数，若使用Promise方式则不必填写
   * @param {Function} [options.failure] 查询失败回调函数，若使用Promise方式则不必填写
   */
  calculateUnion(options) {
    // 设置PATH PARAMETERS校验
    const checkPathOpts = {}

    // 设置QUERY PARAMETERS校验
    const checkQueryOpts = {
      geometries: {
        type: 'Object',
        required: true,
        process(geometries) {
          return `&geometries=${JSON.stringify(geometries)}`
        }
      },
      sr: {
        type: 'String',
        required: true
      }
    }

    options.method = FetchMethod.get
    // 调用基类的查询信息方法
    return this._queryByParameters(
      options,
      checkPathOpts,
      checkQueryOpts,
      // 拼装返回基地址
      function (url) {
        return `${url}/union?f=json`
      }
    )
  }
}

Zondy.Service.ArcGISGeometryServer = ArcGISGeometryServer
export default ArcGISGeometryServer