layer/layerRec/dynamicRecord.js

'use strict';
const attribRecord = require('./attribRecord.js')();
const shared = require('./shared.js')();
const placeholderFC = require('./placeholderFC.js')();
const layerInterface = require('./layerInterface.js')();
const dynamicFC = require('./dynamicFC.js')();
const attribFC = require('./attribFC.js')();
/**
 * @class DynamicRecord
 */
class DynamicRecord extends attribRecord.AttribRecord {
    // TODO are we still using passthrough stuff?
    get _layerPassthroughBindings () {
        // TEST STATUS none
        return ['setOpacity', 'setVisibility', 'setVisibleLayers', 'setLayerDrawingOptions'];
    }
    get _layerPassthroughProperties () {
        // TEST STATUS none
        return ['visibleAtMapScale', 'visible', 'spatialReference', 'layerInfos', 'supportsDynamicLayers'];
    }
    get layerType () { return shared.clientLayerType.ESRI_DYNAMIC; }
    /**
     * Create a layer record with the appropriate geoApi layer type.  Layer config
     * should be fully merged with all layer options defined (i.e. this constructor
     * will not apply any defaults).
     * @param {Object} layerClass    the ESRI api object for dynamic layers
     * @param {Object} esriRequest   the ESRI api object for making web requests with proxy support
     * @param {Object} apiRef        object pointing to the geoApi. allows us to call other geoApi functions
     * @param {Object} config        layer config values
     * @param {Object} esriLayer     an optional pre-constructed layer
     * @param {Function} epsgLookup  an optional lookup function for EPSG codes (see geoService for signature)
     */
    constructor (layerClass, esriRequest, apiRef, config, esriLayer, epsgLookup) {
        // TEST STATUS basic
        super(layerClass, esriRequest, apiRef, config, esriLayer, epsgLookup);
        this.ArcGISDynamicMapServiceLayer = layerClass;
        // TODO what is the case where we have dynamic layer already prepared
        //      and passed in? Generally this only applies to file layers (which
        //      are feature layers).
        // TODO figure out controls on config
        // TODO worry about placeholders. WORRY. how does that even work here?
        this._proxies = {};
    }
    /**
     * Return a proxy interface for a child layer
     *
     * @param {Integer} featureIdx    index of child entry (leaf or group)
     * @return {Object}               proxy interface for given child
     */
    getChildProxy (featureIdx) {
        // TEST STATUS basic
        // TODO verify we have integer coming in and not a string
        // in this case, featureIdx can also be a group index
        if (this._proxies[featureIdx.toString()]) {
            return this._proxies[featureIdx.toString()];
        } else {
            // throw new Error(`attempt to get non-existing child proxy. Index ${featureIdx}`);
            // to handle the case of a structured legend needing a proxy for a child prior to the
            // layer loading, we treat an unknown proxy request as that case and return
            // a proxy loaded with a placeholder.
            // TODO how to pass in a name? add an optional second parameter? expose a "set name" on the proxy?
            const pfc = new placeholderFC.PlaceholderFC(this, '');
            const tProxy = new layerInterface.LayerInterface(pfc); // specificially no controls at this point.
            tProxy.convertToPlaceholder(pfc);
            this._proxies[featureIdx.toString()] = tProxy;
            return tProxy;
        }
    }
    // TODO I think we need to override getProxy to return a special Dynamic proxy.
    //      Need to figure out how visibility works (i.e. layer is invisible or just empty visibleChildren array)
    //      Might also need to manage the root children somehow (i.e. the layerEntries from the config)
    // TODO docs
    getFeatureCount (featureIdx) {
        // TEST STATUS basic
        // point url to sub-index we want
        // TODO might change how we manage index and url
        return super.getFeatureCount(this._layer.url + '/' + featureIdx);
    }
    /**
    * Triggers when the layer loads.
    *
    * @function onLoad
    */
    onLoad () {
        // TEST STATUS basic
        super.onLoad();
        const supportsDynamic = this._layer.supportsDynamicLayers;
        const controlBanlist = ['reload', 'snapshot', 'boundingBox'];
        if (!supportsDynamic) {
            controlBanlist.push('opacity');
        }
        // strip any banned controls from a controls array
        // array is modified
        const banControls = controls => {
            controlBanlist.forEach(bc => {
                const idx = controls.indexOf(bc);
                if (idx > -1) {
                    controls.splice(idx, 1);
                }
            });
            // a bit redundant. useful if we are passing in an anonymous array.
            return controls;
        };
        // don't worry about structured legend. the legend part is separate from
        // the layers part. we just load what we are told to. the legend module
        // will handle the structured part.
        // NOTE for now, the only relevant properties to be propagated
        //      from parent to child are .state and .controls .
        //      .outfields does not make sense as chilren can have different fields.
        //      We assume the objects at the layer level (index -1) are fully defaulted.
        //      All other missing items assigned from parent item.
        // subconfig lookup. initialize with the layer root (-1), then add
        // in anything provided in the initial config.
        const subConfigs = {
            '-1': {
                config: {
                    state: this.config.state,
                    controls: banControls(this.config.controls.concat())
                },
                defaulted: true
            }
        };
        this.config.layerEntries.forEach(le => {
            subConfigs[le.index.toString()] = {
                config: le,
                defaulted: false
            };
        });
        // subfunction to either return a stored sub-config, or
        // derive a new subconfig from the parent config.
        // both params integers in string format.
        const fetchSubConfig = (id, parentId) => {
            if (subConfigs[id]) {
                const subC = subConfigs[id];
                if (!subC.defaulted) {
                    // get any missing properties from parent
                    const parent = subConfigs[parentId].config;
                    // TODO verify if we need to check for controls array of .length === 0.
                    //      I am assuming an empty array a valid setting (i.e. no controls should be shown)
                    if (!subC.config.controls) {
                        // we can assume parent.controls has already been ban-scraped
                        subC.config.controls = parent.controls.concat();
                    } else {
                        // ensure we dont have any bad controls lurking
                        banControls(subC.config.controls);
                    }
                    if (!subC.config.state) {
                        // copy all
                        subC.config.state = Object.assign({}, parent.state);
                    } else {
                        // selective inheritance
                        Object.keys(parent.state).forEach(stateKey => {
                            // be aware of falsey logic here.
                            if (!subC.config.state.hasOwnProperty(stateKey)) {
                                subC.config.state[stateKey] = parent.state[stateKey];
                            }
                        });
                    }
                    if (!subC.config.hasOwnProperty('outfields')) {
                        subC.config.outfields = '*';
                    }
                    subC.defaulted = true;
                }
                return subC.config;
            } else {
                // no config at all. direct copy properties from parent
                // we can assume parent.controls has already been ban-scraped
                const newConfig = {
                    state: Object.assign({}, subConfigs[parentId].config.state),
                    controls: subConfigs[parentId].config.controls.concat(),
                    outfields: '*'
                };
                subConfigs[id] = {
                    config: newConfig,
                    defaulted: true
                };
                return newConfig;
            }
        };
        // this subfunction will recursively crawl a dynamic layerInfo structure.
        // it will generate proxy objects for all groups and leafs under the
        // input layerInfo.
        // it also collects and returns an array of leaf nodes so each group
        // can store it and have fast access to all leaves under it.
        const processLayerInfo = (layerInfo, treeArray, parentId) => {
            const sId = layerInfo.id.toString();
            const subConfig = fetchSubConfig(sId, parentId.toString());
            if (layerInfo.subLayerIds && layerInfo.subLayerIds.length > 0) {
                // group
                // TODO probably need some placeholder magic going on here too
                // TODO do we need to apply any config state?
                // TODO figure out control lists, whats available, whats disabled.
                //      supply on second and third parameters
                let group;
                if (this._proxies[sId]) {
                    // we have a pre-made proxy (structured legend)
                    // TODO might need to pass controls array into group proxy
                    group = this._proxies[sId];
                } else {
                    // set up new proxy
                    group = new layerInterface.LayerInterface(this, subConfig.controls);
                    this._proxies[sId] = group;
                }
                group.convertToDynamicGroup(this, sId, subConfig.name || layerInfo.name || '');
                const treeGroup = { id: layerInfo.id, childs: [] };
                treeArray.push(treeGroup);
                // process the kids in the group.
                // store the child leaves in the internal variable
                layerInfo.subLayerIds.forEach(slid => {
                    group._childLeafs = group._childLeafs.concat(
                        processLayerInfo(this._layer.layerInfos[slid], treeGroup.childs, sId));
                });
                return group._childLeafs;
            } else {
                // leaf
                // TODO figure out control lists, whats available, whats disabled.
                //      supply on second and third parameters.
                //      might need to steal from parent, since auto-gen may not have explicit
                //      config settings.
                // TODO since we are doing placeholder, might want to not provide controls array yet.
                let leaf;
                const pfc = new placeholderFC.PlaceholderFC(this, layerInfo.name);
                if (this._proxies[sId]) {
                    // we have a pre-made proxy (structured legend)
                    // TODO might need to pass controls array into leaf proxy
                    leaf = this._proxies[sId];
                    leaf.updateSource(pfc);
                } else {
                    // set up new proxy
                    leaf = new layerInterface.LayerInterface(null, subConfig.controls);
                    leaf.convertToPlaceholder(pfc);
                    this._proxies[sId] = leaf;
                }
                treeArray.push({ id: layerInfo.id });
                return [leaf];
            }
        };
        this._childTree = []; // public structure describing the tree
        if (this.config.layerEntries) {
            this.config.layerEntries.forEach(le => {
                if (!le.stateOnly) {
                    processLayerInfo(this._layer.layerInfos[le.index], this._childTree, -1);
                }
            });
        }
        // trigger attribute load and set up children bundles.
        // TODO do we need an options object, with .skip set for sub-layers we are not dealing with?
        //      we currently (sort-of) have the list of things included -- the keys of the
        //      subConfigs object. we would need to iterate layerInfos again and find keys
        //      not in subConfigs.
        //      Alternate: add new option that is opposite of .skip.  Will be more of a
        //                 .only, and we won't have to derive a "skip" set from our inclusive
        //                 list
        //      Furthermore: skipping / being effecient might not really matter here anymore.
        //                   back in the day, loadLayerAttribs would actually load everything.
        //                   now it just sets up promises that dont trigger until someone asks for
        //                   the information.
        const attributeBundle = this._apiRef.attribs.loadLayerAttribs(this._layer);
        const initVis = [];
        // converts server type string to client type string
        const serverLayerTypeToClientLayerType = serverType => {
            switch (serverType) {
                case 'Feature Layer':
                    return shared.clientLayerType.ESRI_FEATURE;
                case 'Raster Layer':
                    return shared.clientLayerType.ESRI_RASTER;
                default:
                    throw new Error('Unexpected layer type in serverLayerTypeToClientLayerType', serverType);
            }
        };
        // idx is a string
        attributeBundle.indexes.forEach(idx => {
            // if we don't have a defaulted sub-config, it means the attribute leaf is not present
            // in our visible tree structure.
            const subC = subConfigs[idx];
            if (subC && subC.defaulted) {
                // TODO need to worry about Raster Layers here.  DynamicFC is based off of
                //      attribute things.
                const dFC = new dynamicFC.DynamicFC(this, idx, attributeBundle[idx], subC.config);
                this._featClasses[idx] = dFC;
                if (subC.config.state.visibility) {
                    initVis.push(parseInt(idx)); // store for initial visibility
                }
                // if we have a proxy watching this leaf, replace its placeholder with the real data
                const leafProxy = this._proxies[idx];
                if (leafProxy) {
                    // TODO update controls array?
                    // trickery involving symbology.
                    // the UI is binding to the object that was set up in the leaf placeholder.
                    // so we cannot just make a new one.
                    // we need to inject the placeholder symbology object into our new DynamicFC.
                    // then we can aysnch update it with real symbols, and the UI is still
                    // pointing at the same array in memory.
                    dFC._symbolBundle = leafProxy.symbology;
                    leafProxy.convertToDynamicLeaf(dFC);
                }
                // load real symbols into our source
                dFC.loadSymbology();
                // update asynchronous values
                dFC.getLayerData().then(ld => {
                    dFC.layerType = serverLayerTypeToClientLayerType(ld.layerType);
                    if (dFC.layerType === shared.clientLayerType.ESRI_FEATURE) {
                        dFC.geomType = ld.geometryType;
                    }
                });
                this.getFeatureCount(idx).then(fc => {
                    dFC.featureCount = fc;
                });
            }
        });
        // need to do a post ban-sweep on control arrays. dynamic groups are not allowed
        // to have opacity. if we had removed above, children of groups would have also
        // lost opacity.
        // a lovely pyramid of doom.
        Object.keys(this._proxies).forEach(sId => {
            const proxy = this._proxies[sId];
            if (!proxy.isPlaceholder && proxy.layerType === shared.clientLayerType.ESRI_GROUP) {
                const poIdx = proxy.availableControls.indexOf('opacity');
                if (poIdx > -1) {
                    proxy.availableControls.splice(poIdx, 1);
                    // TODO test if we need to adjust subconfigs, or if it's all the same pointer
                    if (subConfigs[sId].config.controls.indexOf('opacity') > -1) {
                        console.log('HEEEY HEYYY WE HAVE A CONFIG OPACITY GROUP, ADD CODE TO REMOVE IT');
                    }
                }
            }
        });
        if (initVis.length === 0) {
            initVis.push(-1); // esri code for set all to invisible
        }
        this._layer.setVisibleLayers(initVis);
    }
    // override to add child index parameter
    zoomToScale (childIdx, map, lods, zoomIn, zoomGraphic = false) {
        // TEST STATUS none
        // get scale set from child, then execute zoom
        return this._featClasses[childIdx].getScaleSet().then(scaleSet => {
            return this._zoomToScaleSet(map, lods, zoomIn, scaleSet, zoomGraphic);
        });
    }
    isOffScale (childIdx, mapScale) {
        // TEST STATUS none
        return this._featClasses[childIdx].isOffScale(mapScale);
    }
    isQueryable (childIdx) {
        // TEST STATUS none
        return this._featClasses[childIdx].queryable;
    }
    // TODO if we need this back, may need to implement as getChildGeomType.
    //      appears this ovverrides the LayerRecord.getGeomType function, which returns
    //      undefined, and that is what we want on the DynamicRecord level (as dynamic layer)
    //      has no geometry.
    //      Currently, all child requests for geometry go through the proxy,
    //      so could be this child-targeting version is irrelevant.
    /*
    getGeomType (childIdx) {
        // TEST STATUS none
        return this._featClasses[childIdx].geomType;
    }
    */
    getChildTree () {
        if (this._childTree) {
            return this._childTree;
        } else {
            throw new Error('Called getChildTree before layer is loaded');
        }
    }
    /**
     * Get the best user-friendly name of a field. Uses alias if alias is defined, else uses the system attribute name.
     *
     * @param {String} attribName     the attribute name we want a nice name for
     * @param {String}  childIndex    index of the child layer whos attributes we are looking at
     * @return {Promise}              resolves to the best available user friendly attribute name
     */
    aliasedFieldName (attribName, childIndex) {
        // TEST STATUS none
        return this._featClasses[childIndex].aliasedFieldName(attribName);
    }
    /**
     * Retrieves attributes from a layer for a specified feature index
     * @param {String}  childIndex  index of the child layer to get attributes for
     * @return {Promise}            promise resolving with formatted attributes to be consumed by the datagrid and esri feature identify
     */
    getFormattedAttributes (childIndex) {
        // TEST STATUS none
        return this._featClasses[childIndex].getFormattedAttributes();
    }
    /**
     * Check to see if the attribute in question is an esriFieldTypeDate type.
     *
     * @param {String} attribName     the attribute name we want to check if it's a date or not
     * @param {String}  childIndex    index of the child layer whos attributes we are looking at
     * @return {Promise}              resolves to true or false based on the attribName type being esriFieldTypeDate
     */
    checkDateType (attribName, childIndex) {
        // TEST STATUS none
        return this._featClasses[childIndex].checkDateType(attribName);
    }
    /**
    * Returns attribute data for a child layer.
    *
    * @function getAttribs
    * @param {String} childIndex  the index of the child layer
    * @returns {Promise}          resolves with a layer attribute data object
    */
    getAttribs (childIndex) {
        // TEST STATUS none
        return this._featClasses[childIndex].getAttribs();
    }
    /**
    * Returns layer-specific data for a child layer
    *
    * @function getLayerData
    * @param {String} childIndex  the index of the child layer
    * @returns {Promise}          resolves with a layer data object
    */
    getLayerData (childIndex) {
        // TEST STATUS none
        return this._featClasses[childIndex].getLayerData();
    }
    getFeatureName (childIndex, objId, attribs) {
        // TEST STATUS none
        return this._featClasses[childIndex].getFeatureName(objId, attribs);
    }
    getSymbology (childIndex) {
        // TEST STATUS basic
        return this._featClasses[childIndex].getSymbology();
    }
    /**
    * Run a query on a dynamic layer, return the result as a promise.
    * @function identify
    * @param {Object} opts additional argumets like map object, clickEvent, etc.
    * @returns {Object} an object with identify results array and identify promise resolving when identify is complete; if an empty object is returned, it will be skipped
    */
    identify (opts) {
        // TEST STATUS none
        // TODO caller must pass in layer ids to interrogate.  geoApi wont know what is toggled in the legend.
        //      param is opts.layerIds, array of integer for every leaf to interrogate.
        // TODO add full documentation for options parameter
        // bundles results from all leaf layers
        const identifyResults = [];
        // create an results object for every leaf layer we are inspecting
        opts.layerIds.forEach(leafIndex => {
            // TODO fix these params
            // TODO legendEntry.name, legendEntry.symbology appear to be fast links to populate the left side of the results
            //      view.  perhaps it should not be in this object anymore?
            // TODO see how the client is consuming the internal pointer to layerRecord.  this may also now be
            //      directly available via the legend object.
            const identifyResult =
                new shared.IdentifyResult('legendEntry.name', 'legendEntry.symbology', 'EsriFeature', this,
                    leafIndex, 'legendEntry.master.name'); // provide name of the master group as caption
            identifyResults[leafIndex] = identifyResult;
        });
        opts.tolerance = this.clickTolerance;
        const identifyPromise = this._apiRef.layer.serverLayerIdentify(this._layer, opts)
            .then(clickResults => {
                const hitIndexes = []; // sublayers that we got results for
                // transform attributes of click results into {name,data} objects
                // one object per identified feature
                //
                // each feature will have its attributes converted into a table
                // placeholder for now until we figure out how to signal the panel that
                // we want to make a nice table
                clickResults.forEach(ele => {
                    // NOTE: the identify service returns aliased field names, so no need to look them up here.
                    //       however, this means we need to un-alias the data when doing field lookups.
                    // NOTE: ele.layerId is what we would call featureIdx
                    hitIndexes.push(ele.layerId);
                    // get metadata about this sublayer
                    this.getLayerData(ele.layerId).then(lData => {
                        const identifyResult = identifyResults[ele.layerId];
                        if (lData.supportsFeatures) {
                            const unAliasAtt = attribFC.AttribFC.unAliasAttribs(ele.feature.attributes, lData.fields);
                            // TODO traditionally, we did not pass fields into attributesToDetails as data was
                            //      already aliased from the server. now, since we are extracting field type as
                            //      well, this means things like date formatting might not be applied to
                            //      identify results. examine the impact of providing the fields parameter
                            //      to data that is already aliased.
                            identifyResult.data.push({
                                name: ele.value,
                                data: this.attributesToDetails(ele.feature.attributes),
                                oid: unAliasAtt[lData.oidField],
                                symbology: [{
                                    svgcode: this._apiRef.symbology.getGraphicIcon(unAliasAtt, lData.renderer)
                                }]
                            });
                        }
                        identifyResult.isLoading = false;
                    });
                });
                // set the rest of the entries to loading false
                identifyResults.forEach(identifyResult => {
                    if (hitIndexes.indexOf(identifyResult.requester.featureIdx) === -1) {
                        identifyResult.isLoading = false;
                    }
                });
            });
        return {
            identifyResults: identifyResults.filter(identifyResult => identifyResult), // collapse sparse array
            identifyPromise
        };
    }
    // TODO docs
    getChildName (index) {
        // TEST STATUS none
        // TODO revisit logic. is this the best way to do this? what are the needs of the consuming code?
        // TODO restructure so WMS can use this too?
        // will not use FC classes, as we also need group names
        return this._layer.layerInfos[index].name;
    }
}
module.exports = () => ({
    DynamicRecord
});