Reusable Accessible Mapping Platform

API Docs for: 5.3.1
Show:

File: src/js/RAMP/bootstrapper.js

  1. /*global require, window, dojoConfig, i18n, document, $, console, RAMP */
  2.  
  3. /**
  4. * Ramp module
  5. *
  6. * @module RAMP
  7. * @main RAMP
  8. */
  9.  
  10. /**
  11. * Bootstrapper class.
  12. * Starting point of RAMP, RAMP modules are loaded here and mapped to a function parameter
  13. * Phase X?: For mobile support, there can be a different mobileBootstrapper with only the mobile modules loaded
  14. *
  15. * ####Imports RAMP Modules:
  16. * {{#crossLink "Map"}}{{/crossLink}}  
  17. * {{#crossLink "BaseMapSelector"}}{{/crossLink}}  
  18. * {{#crossLink "Maptips"}}{{/crossLink}}  
  19. * {{#crossLink "Datagrid"}}{{/crossLink}}  
  20. * {{#crossLink "Navigation"}}{{/crossLink}}  
  21. * {{#crossLink "FilterManager"}}{{/crossLink}}  
  22. * {{#crossLink "BookmarkLink"}}{{/crossLink}}  
  23. * {{#crossLink "Url"}}{{/crossLink}}  
  24. * {{#crossLink "FeatureHighlighter"}}{{/crossLink}}  
  25. * {{#crossLink "RAMP"}}{{/crossLink}}  
  26. * {{#crossLink "GlobalStorage"}}{{/crossLink}}  
  27. * {{#crossLink "GUI"}}{{/crossLink}}  
  28. * {{#crossLink "EventManager"}}{{/crossLink}}  
  29. * {{#crossLink "AdvancedToolbar"}}{{/crossLink}}  
  30. * {{#crossLink "Util"}}{{/crossLink}}  
  31. * {{#crossLink "Prototype"}}{{/crossLink}}  
  32. * {{#crossLink "FunctionMangler"}}{{/crossLink}}  
  33. * {{#crossLink "LayerLoader"}}{{/crossLink}}  
  34. * 
  35. * @class Bootstrapper
  36. * @static
  37. *
  38. * @uses dojo/parser
  39. * @uses dojo/on
  40. * @uses dojo/topic
  41. * @uses dojo/request/script
  42. * @uses dojo/request/xhr
  43. */
  44.  
  45. require([
  46. /* Dojo */
  47.     "dojo/parser", "dojo/on", "dojo/topic", "dojo/request/script", "dojo/request/xhr",
  48.     "esri/config", "esri/urlUtils",
  49.  
  50. /* RAMP */
  51.     "ramp/map", "ramp/basemapSelector", "ramp/maptips", "ramp/datagrid",
  52.     "ramp/navigation", "ramp/filterManager", "ramp/imageExport", "ramp/bookmarkLink",
  53.     "utils/url", "ramp/featureHighlighter",
  54.     "ramp/ramp", "ramp/globalStorage", "ramp/gui", "ramp/eventManager",
  55.     "ramp/advancedToolbar", "ramp/geoSearch",
  56.     "ramp/theme", "ramp/layerLoader", "ramp/dataLoaderGui", "ramp/dataLoader", "ramp/stepItem",
  57.     
  58. /* Utils */
  59.     "utils/util",
  60.  
  61. /* Plugins */
  62.     "utils/prototype!", "utils/functionMangler!", "dojo/domReady!"],
  63.  
  64.     function (
  65.     /* Dojo */
  66.     parser, dojoOn, topic, requestScript, xhr,
  67.     esriConfig, esriUrlUtils,
  68.  
  69.     /* RAMP */
  70.     RampMap, BasemapSelector, Maptips, Datagrid, NavWidget, FilterManager, ImageExport,
  71.     BookmarkLink, Url, FeatureHighlighter,
  72.     Ramp, GlobalStorage, gui, EventManager, AdvancedToolbar, GeoSearch,
  73.     theme, LayerLoader, DataLoadedGui, DataLoader, StepItem,
  74.  
  75.     /* Utils */
  76.         UtilMisc
  77.     ) {
  78.         "use strict";
  79.  
  80.         /**
  81.         * loadPlugin takes a plugin file and loads it into the DOM.
  82.         * Creates a dynamic script tag to load the script at runtime.
  83.         *
  84.         * @method loadPlugin
  85.         * @private
  86.         * @param {String} pluginName, the file name of the plugin to be loaded (should be in the plugins folder)
  87.         */
  88.         function loadPlugin(pluginName) {
  89.             var head = document.getElementsByTagName('head')[0],
  90.                 script = document.createElement('script');
  91.             script.type = 'text/javascript';
  92.             script.src = dojoConfig.fullPluginPath + pluginName;
  93.             console.log('loading plugin: ' + script.src);
  94.             head.appendChild(script);
  95.         }
  96.  
  97.         function initializeMap() {
  98.             /* Start - RAMP Events, after map is loaded */
  99.  
  100.             // this split exists solely to separate out the parts that IE9 is
  101.             // bad at handling there is a DOM race condition somewhere in here,
  102.             // we've given up on trying to find it
  103.             function guiInits() {
  104.                 //initialize the filter
  105.                 FilterManager.init();
  106.  
  107.                 // Initialize the advanced toolbar and tools.
  108.                 if (RAMP.config.advancedToolbar.enabled) {
  109.                     AdvancedToolbar.init();
  110.                 }
  111.  
  112.                 Datagrid.init();
  113.                 theme.tooltipster();
  114.  
  115.                 //start loading the layers
  116.                 RAMP.startupLayers.forEach(function (layer) {
  117.                     LayerLoader.loadLayer(layer);
  118.                 });
  119.             }
  120.  
  121.             topic.subscribe(EventManager.Map.INITIAL_BASEMAP_LOADED, function () {
  122.                 console.log("map - >> first update-end; init the rest");
  123.  
  124.                 // Only initialize the bookmark link after all the UI events of all other modules have
  125.                 // finished loading
  126.                 // IMPORTANT: for now, only basemapselector and filtermanager have a UI complete event
  127.                 // but in the future, if other modules start publishing their own UI complete events, it needs
  128.                 // to be subscribe to here so BookmarkLink will not attempt to call the module before its GUI
  129.                 // has finished rendering
  130.                 UtilMisc.subscribeAll(
  131.                     [
  132.                         EventManager.BasemapSelector.UI_COMPLETE,
  133.                         EventManager.FilterManager.UI_COMPLETE
  134.                     ], function () {
  135.                         BookmarkLink.subscribeAndUpdate();
  136.  
  137.                         //initialize the map export after everything is done
  138.                         ImageExport.init();
  139.  
  140.                         DataLoadedGui.init();
  141.                         //RampMap.zoomToLayerScale();
  142.                     });
  143.                 // Added current level so slider will know how to adjust the position
  144.                 var currentLevel = (RampMap.getMap().__LOD.level) ? RampMap.getMap().__LOD.level : 0;
  145.  
  146.                 NavWidget.init(currentLevel);
  147.                 FeatureHighlighter.init();
  148.  
  149.                 Maptips.init();
  150.  
  151.                 //Apply listeners for basemap gallery
  152.                 BasemapSelector.init();
  153.  
  154.                 if (RAMP.flags.brokenWebBrowser || RAMP.flags.ie10client) {
  155.                     console.log('delaying for IE9 and IE10 to catch up with the group');
  156.                     window.setTimeout(guiInits, 2000);
  157.                 } else {
  158.                     guiInits();
  159.                 }
  160.  
  161.             });
  162.  
  163.             RampMap.init();
  164.             NavWidget.construct();
  165.  
  166.             // a workaround for bug#3460; ideally each module's ui component would call tooltipster on its own; probably a good idea would to implement this when working on mobile view
  167.             theme.tooltipster();
  168.  
  169.             /* End - RAMP Events */
  170.         }
  171.         /* End - Bootstrapper functions */
  172.  
  173.         // Check to make sure the console exists, redefines it to the no-op function
  174.         // if it does not (e.g. in IE when the debugger is not on)
  175.         UtilMisc.checkConsole();
  176.  
  177.         // Once all of our modules are loaded and the DOM is ready:
  178.  
  179.         // call the parser to create the dijit layout dijits
  180.         parser.parse();
  181.  
  182.         //To hold values from RAMP service
  183.  
  184.         var lang = $("html").attr("lang"),
  185.             configFile,
  186.             defJson;
  187.  
  188.         if (lang !== "en" && lang !== "fr") {
  189.             lang = "en";
  190.         }
  191.  
  192.         RAMP.locale = lang;
  193.  
  194.         i18n.init(
  195.         {
  196.             lng: lang + "-CA",
  197.             load: "current",
  198.             fallbackLng: false
  199.         });
  200.  
  201.         //loading config object from JSON file
  202.         configFile = (lang === "fr") ? "config.fr.json" : "config.en.json";
  203.  
  204.         // Request the JSON config file
  205.         defJson = xhr(configFile, {
  206.             handleAs: "json"
  207.         });
  208.  
  209.         defJson.then(
  210.             function (fileConfig) {
  211.                 //there is no need to convert the result to an object.  it comes through pre-parsed
  212.                 if (!RAMP.configServiceURL) {
  213.                     //no config service.  we just use the file provided
  214.                     configReady(fileConfig);
  215.                 } else {
  216.                     //get additional config stuff from the config service.  mash it into our primary object
  217.  
  218.                     // pull smallkeys from URL
  219.                     var siteURL = new Url(require.toUrl(document.location)),
  220.                         smallkeys = siteURL.queryObject.keys;
  221.  
  222.                     if (!smallkeys || smallkeys === "") {
  223.                         //no keys.  no point hitting the service.  jump to next step
  224.                         configReady(fileConfig);
  225.                     } else {
  226.                         //TODO verify endpoint is correct
  227.                         var serviceUrl = RAMP.configServiceURL + "docs/" + $("html").attr("lang") + "/" + smallkeys,
  228.                             defService = requestScript.get(serviceUrl, { jsonp: 'callback', timeout: 5000 });
  229.  
  230.                         //Request the JSON snippets from the RAMP Config Service
  231.  
  232.                         //NOTE: XHR cannot be used here for cross domain purposes (primarily when running thru visual studio).
  233.                         //      we use request/script instead to get the config as jsonp
  234.                         //      we may consider looking into ways to mitiate the cross domain issue (Aly had some ideas)
  235.  
  236.                         defService.then(
  237.                             function (serviceContent) {
  238.                                 console.log(serviceContent);
  239.  
  240.                                 //we are expecting an array of JSON config fragments
  241.                                 //merge each fragment into the file config
  242.  
  243.                                 serviceContent.forEach(function (configFragment) {
  244.                                     UtilMisc.mergeRecursive(fileConfig, configFragment);
  245.                                 });
  246.  
  247.                                 //fragments are now in fileConfig.  carry on.
  248.                                 configReady(fileConfig);
  249.                             },
  250.                             function (error) {
  251.                                 console.log("An error occurred: " + error);
  252.                             }
  253.                         );
  254.                     }
  255.                 }
  256.             },
  257.             function (error) {
  258.                 console.log("An error occurred when retrieving the JSON Config: " + error);
  259.             }
  260.         );
  261.  
  262.         /**
  263.         * once the config file has been retrieved, proceed with the loading of the site
  264.         *
  265.         * @method configReady
  266.         * @private
  267.         * @param {Object} configObject the configuration object
  268.         */
  269.         function configReady(configObject) {
  270.             var pluginConfig,
  271.                 advancedToolbarToggle = $("li.map-toolbar-item #advanced-toggle").parent(),
  272.                 brokenWebBrowser = document.getElementsByTagName('html')[0].className.indexOf('dj_ie9') > -1,
  273.                 annoyingWebBrowser = document.getElementsByTagName('html')[0].className.indexOf('dj_ie10') > -1;
  274.  
  275.             console.log("Bootstrapper: config loaded");
  276.  
  277.             GlobalStorage.init(configObject);
  278.             GlobalStorage.defineProjections(window.proj4);
  279.             GeoSearch.init();
  280.  
  281.             esriConfig.defaults.io.proxyUrl = RAMP.config.proxyUrl;
  282.             // try to avoid the proxy if possible, but this will cause network errors if CORS is not allowed by the target server
  283.             esriConfig.defaults.io.corsDetection = !brokenWebBrowser;
  284.                 // really IE9???  (╯°□°）╯︵ ┻━┻
  285.             if (brokenWebBrowser && RAMP.config.exportProxyUrl !== undefined) {
  286.                 esriUrlUtils.addProxyRule({ proxyUrl: RAMP.config.exportProxyUrl, urlPrefix: RAMP.config.exportMapUrl });
  287.             }
  288.             RAMP.flags.brokenWebBrowser = brokenWebBrowser;
  289.             RAMP.flags.ie10client = annoyingWebBrowser;
  290.  
  291.             // Show or remove advanced toolbar toggle based on the config value
  292.             if (RAMP.config.advancedToolbar.enabled) {
  293.                 advancedToolbarToggle.removeClass("wb-invisible");
  294.             } else {
  295.                 advancedToolbarToggle.remove();
  296.             }
  297.  
  298.             pluginConfig = RAMP.config.plugins;
  299.             if (pluginConfig) {
  300.                 pluginConfig.map(function (pName) { loadPlugin(pName); });
  301.             }
  302.  
  303.             // apply defaulting of extents (must be done prior to bookmark link updates)
  304.             RampMap.applyExtentDefaulting();
  305.  
  306.             // Modify the config based on the url
  307.             // needs to do this before the gui loads because the gui module
  308.             // also reads from the config
  309.             BookmarkLink.updateConfig(window.location.pathname.split("/").last());
  310.  
  311.             //other initilizations must wait until our extents have been projected to our active basemap
  312.             topic.subscribe(EventManager.Map.EXTENTS_REPROJECTED, function () {
  313.                 // Initialize the map only after the gui loads
  314.                 // if we do it beforehand, the map extent may get messed up since
  315.                 // the available screen size may still be changing (e.g. due to fullscreen
  316.                 // or subpanel closing)
  317.                 topic.subscribe(EventManager.GUI.UPDATE_COMPLETE, function () {
  318.                     // Create the panel that the bookmark link sits in
  319.                     // can only do this after the gui loads
  320.                     BookmarkLink.createUI();
  321.  
  322.                     LayerLoader.init();
  323.                     initializeMap();
  324.                 });
  325.  
  326.                 gui.load(null, null, function () { });
  327.                 
  328.                 Ramp.loadStrings();
  329.             });
  330.  
  331.             //project extents to basemap
  332.             RampMap.projectConfigExtents();
  333.         }
  334.     });
  335.  
  336.