layer/layerRec/attribRecord.js

  1. 'use strict';
  3. const layerRecord = require('./layerRecord.js')();
  4. const attribFC = require('./attribFC.js')();
  6. /**
  7.  * @class AttribRecord
  8.  */
  9. class AttribRecord extends layerRecord.LayerRecord {
  10.     // this class has functions common to layers that have attributes
  12.     get clickTolerance () { return this._tolerance; }
  14.     /**
  15.      * Create a layer record with the appropriate geoApi layer type.  Layer config
  16.      * should be fully merged with all layer options defined (i.e. this constructor
  17.      * will not apply any defaults).
  18.      * @param {Object} layerClass    the ESRI api object for the layer
  19.      * @param {Object} esriRequest   the ESRI api object for making web requests with proxy support
  20.      * @param {Object} apiRef        object pointing to the geoApi. allows us to call other geoApi functions.
  21.      * @param {Object} config        layer config values
  22.      * @param {Object} esriLayer     an optional pre-constructed layer
  23.      * @param {Function} epsgLookup  an optional lookup function for EPSG codes (see geoService for signature)
  24.      */
  25.     constructor (layerClass, esriRequest, apiRef, config, esriLayer, epsgLookup) {
  26.         super(layerClass, apiRef, config, esriLayer, epsgLookup);
  28.         this._esriRequest = esriRequest;
  29.         this._tolerance = this.config.tolerance;
  30.     }
  32.     /**
  33.      * Get the best user-friendly name of a field. Uses alias if alias is defined, else uses the system attribute name.
  34.      *
  35.      * @param {String} attribName     the attribute name we want a nice name for
  36.      * @return {Promise}              resolves to the best available user friendly attribute name
  37.      */
  38.     aliasedFieldName (attribName) {
  39.         return this._featClasses[this._defaultFC].aliasedFieldName(attribName);
  40.     }
  42.     /**
  43.      * Retrieves attributes from a layer for a specified feature index
  44.      * @return {Promise}            promise resolving with formatted attributes to be consumed by the datagrid and esri feature identify
  45.      */
  46.     getFormattedAttributes () {
  47.         return this._featClasses[this._defaultFC].getFormattedAttributes();
  48.     }
  50.     checkDateType (attribName) {
  51.         return this._featClasses[this._defaultFC].checkDateType(attribName);
  52.     }
  54.     /**
  55.     * Returns attribute data for this layer.
  56.     *
  57.     * @function getAttribs
  58.     * @returns {Promise}         resolves with a layer attribute data object
  59.     */
  60.     getAttribs () {
  61.         return this._featClasses[this._defaultFC].getAttribs();
  62.     }
  64.     /**
  65.     * Returns layer-specific data for this Record
  66.     *
  67.     * @function getLayerData
  68.     * @returns {Promise}         resolves with a layer data object
  69.     */
  70.     getLayerData () {
  71.         return this._featClasses[this._defaultFC].getLayerData();
  72.     }
  74.     getFeatureName (objId, attribs) {
  75.         return this._featClasses[this._defaultFC].getFeatureName(objId, attribs);
  76.     }
  78.     fetchGraphic (objId, ignoreLocal = false) {
  79.         return this._featClasses[this._defaultFC].fetchGraphic(objId, ignoreLocal);
  80.     }
  82.     getFeatureCount (url) {
  83.         if (url) {
  84.             // wrapping server call in a function, as we regularly encounter sillyness
  85.             // where we need to execute the count request twice.
  86.             // having a function (with finalTry flag) lets us handle the double-request
  87.             const esriServerCount = (layerUrl, finalTry = false) => {
  88.                 // extract info for this service
  89.                 const defService = this._esriRequest({
  90.                     url: `${layerUrl}/query`,
  91.                     content: {
  92.                         f: 'json',
  93.                         where: '1=1',
  94.                         returnCountOnly: true,
  95.                         returnGeometry: false
  96.                     },
  97.                     callbackParamName: 'callback',
  98.                     handleAs: 'json',
  99.                 });
  101.                 return new Promise(resolve => {
  102.                     defService.then(serviceResult => {
  103.                         if (serviceResult && (typeof serviceResult.error === 'undefined') &&
  104.                             (typeof serviceResult.count !== 'undefined')) {
  105.                             // we got a row count
  106.                             resolve(serviceResult.count);
  107.                         } else if (!finalTry) {
  108.                             // do a second attempt
  109.                             resolve(esriServerCount(layerUrl, true));
  110.                         } else {
  111.                             // tells the app it failed
  112.                             resolve(-1);
  113.                         }
  114.                     }, error => {
  115.                         // failed to load service info.
  116.                         // TODO any tricks to avoid duplicating the error case in both blocks?
  117.                         if (!finalTry) {
  118.                             // do a second attempt
  119.                             resolve(esriServerCount(layerUrl, true));
  120.                         } else {
  121.                             // tells the app it failed
  122.                             console.warn(error);
  123.                             resolve(-1);
  124.                         }
  125.                     });
  126.                 });
  127.             };
  129.             return esriServerCount(url);
  131.         } else {
  132.             // file based layer.  count local features
  133.             return Promise.resolve(this._layer.graphics.length);
  134.         }
  135.     }
  137.     /**
  138.      * Transforms esri key-value attribute object into key value array with format suitable
  139.      * for consumption by the details pane.
  140.      *
  141.      * @param  {Object} attribs      attribute key-value mapping, potentially with aliases as keys
  142.      * @param  {Array} fields        optional. fields definition array for layer. no aliasing done if not provided
  143.      * @return {Array}               attribute data transformed into a list, with potential field aliasing applied
  144.      */
  145.     attributesToDetails (attribs, fields) {
  146.         // TODO make this extensible / modifiable / configurable to allow different details looks for different data
  147.         // simple array of text mapping for demonstration purposes. fancy grid formatting later?
  148.         return Object.keys(attribs)
  149.             .map(key => {
  150.                 const fieldType = fields ? fields.find(f => f.name === key) : null;
  151.                 return {
  152.                     key: attribFC.AttribFC.aliasedFieldNameDirect(key, fields), // need synchronous variant of alias lookup
  153.                     value: attribs[key],
  154.                     type: fieldType ? fieldType.type : fieldType
  155.                 };
  156.             });
  157.     }
  158. }
  160. module.exports = () => ({
  161.     AttribRecord
  162. });