Reusable Accessible Mapping Platform

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