Reusable Accessible Mapping Platform

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