Source: src/modules/system/system.js

  1. var _system_reload_page = null;
  2. var _system_reload_messages = null;
  4. /**
  5.  * Implements hook_install().
  6.  */
  7. function system_install() {
  9.   // Remove any old forms from local storage, then purge the form expiration tracker.
  10.   for (var form_id in Drupal.cache_expiration.forms) {
  11.     if (!Drupal.cache_expiration.forms.hasOwnProperty(form_id)) { continue; }
  12.     drupalgap_form_local_storage_delete(form_id);
  13.   }
  14.   Drupal.cache_expiration.forms = {};
  15.   window.localStorage.setItem('cache_expiration', JSON.stringify(Drupal.cache_expiration));
  17. }
  19. /**
  20.  * Implements hook_block_info().
  21.  * @return {Object}
  22.  */
  23. function system_block_info() {
  24.     // System blocks.
  25.     var blocks = {
  26.       'main': {
  27.         'delta': 'main',
  28.         'module': 'system'
  29.       },
  30.       messages: {
  31.         delta: 'messages',
  32.         module: 'system'
  33.       },
  34.       'logo': {
  35.         'delta': 'logo',
  36.         'module': 'system'
  37.       },
  38.       logout: {
  39.         delta: 'logout',
  40.         module: 'system'
  41.       },
  42.       'title': {
  43.         'delta': 'title',
  44.         'module': 'system'
  45.       },
  46.       'powered_by': {
  47.         'delta': 'powered_by',
  48.         'module': 'system'
  49.       },
  50.       'help': {
  51.         'delta': 'help',
  52.         'module': 'system'
  53.       }
  54.     };
  55.     // Make additional blocks for each system menu.
  56.     var system_menus = menu_list_system_menus();
  57.     for (var menu_name in system_menus) {
  58.         if (!system_menus.hasOwnProperty(menu_name)) { continue; }
  59.         var menu = system_menus[menu_name];
  60.         var block_delta = menu.menu_name;
  61.         blocks[block_delta] = {
  62.           name: block_delta,
  63.           delta: block_delta,
  64.           module: 'menu'
  65.         };
  66.     }
  67.     return blocks;
  68. }
  70. /**
  71.  * Implements hook_block_view().
  72.  * @param {String} delta
  73.  * @return {String}
  74.  */
  75. function system_block_view(delta) {
  76.   try {
  77.     switch (delta) {
  78.       case 'main':
  79.         // This is the main content block, it is required to be in a theme's
  80.         // region for the content of a page to show up (nodes, users, taxonomy,
  81.         // comments, etc). Depending on the menu link router, we need to route
  82.         // this through the appropriate template files and functions.
  83.         return drupalgap_render_page();
  84.         break;
  85.       case 'messages':
  86.         // If there are any messages waiting to be displayed, render them, then
  87.         // clear out the messages array.
  88.         var html = '';
  89.         if (drupalgap.messages.length == 0) { return html; }
  90.         for (var index in drupalgap.messages) {
  91.             if (!drupalgap.messages.hasOwnProperty(index)) { continue; }
  92.             var msg = drupalgap.messages[index];
  93.             html += '<div class="messages ' + msg.type + '">' +
  94.               msg.message +
  95.             '</div>';
  96.         }
  97.         drupalgap.messages = [];
  98.         return html;
  99.         break;
  100.       case 'logo':
  101.         if (drupalgap.settings.logo) {
  102.           return '<div class="logo">' +
  103.             l(theme('image', {'path': drupalgap.settings.logo}), '') +
  104.           '</div>';
  105.         }
  106.         return '';
  107.         break;
  108.       case 'logout':
  109.         if (Drupal.user.uid) { return theme('logout'); }
  110.         return '';
  111.         break;
  112.       case 'title':
  113.         var title_id = system_title_block_id(drupalgap_path_get());
  114.         return '<h1 id="' + title_id + '" class="page-title"></h1>';
  115.         break;
  116.       case 'powered_by':
  117.         return '<p style="text-align: center;">' + t('Powered by') + ': ' +
  118.           l('DrupalGap', 'http://www.drupalgap.org', {InAppBrowser: true}) +
  119.         '</p>';
  120.         break;
  121.       case 'help':
  122.         return l('Help', 'http://www.drupalgap.org/support');
  123.         break;
  124.       default:
  125.         return '';
  126.         break;
  127.     }
  128.   }
  129.   catch (error) { console.log('system_block_info - ' + error); }
  130. }
  132. /**
  133.  * Implements hook_menu().
  134.  * @return {Object}
  135.  */
  136. function system_menu() {
  137.     var items = {
  138.       'dashboard': {
  139.         'title': t('Dashboard'),
  140.         'page_callback': 'system_dashboard_page'
  141.       },
  142.       'error': {
  143.         'title': t('Error'),
  144.         'page_callback': 'system_error_page'
  145.       },
  146.       'offline': {
  147.         'title': t('Offline'),
  148.         'page_callback': 'system_offline_page'
  149.       },
  150.       '401': {
  151.         title: '401 - ' + t('Not Authorized'),
  152.         page_callback: 'system_401_page'
  153.       },
  154.       '404': {
  155.         title: '404 - ' + t('Not Found'),
  156.         page_callback: 'system_404_page'
  157.       }
  158.     };
  159.     items['_reload'] = {
  160.       title: t('Reloading') + '...',
  161.       page_callback: 'system_reload_page',
  162.       pageshow: 'system_reload_pageshow'
  163.     };
  164.     return items;
  165. }
  167. /**
  168.  * Page callback for the 401 page.
  169.  * @param {String} path
  170.  * @return {String}
  171.  */
  172. function system_401_page(path) {
  173.   return t('Sorry, you are not authorized to view this page.');
  174. }
  176. /**
  177.  * Page callback for the 404 page.
  178.  * @param {String} path
  179.  * @return {String}
  180.  */
  181. function system_404_page(path) {
  182.   return t('Sorry, the page you requested was not found.');
  183. }
  185. /**
  186.  * The page callback for the reload page.
  187.  * @return {String}
  188.  */
  189. function system_reload_page() {
  190.   try {
  191.     // Set aside any messages, then return an empty page.
  192.     var messages = drupalgap_get_messages();
  193.     if (!empty(messages)) {
  194.       _system_reload_messages = messages.slice();
  195.       drupalgap_set_messages([]);
  196.     }
  197.     return '';
  198.   }
  199.   catch (error) { console.log('system_reload_page - ' + error); }
  200. }
  202. /**
  203.  * The pageshow callback for the reload page.
  204.  */
  205. function system_reload_pageshow() {
  206.   try {
  207.     // Set any messages that were set aside.
  208.     if (_system_reload_messages && !empty(_system_reload_messages)) {
  209.       for (var i = 0; i < _system_reload_messages.length; i++) {
  210.         drupalgap_set_message(
  211.           _system_reload_messages[i].message,
  212.           _system_reload_messages[i].type
  213.         );
  214.       }
  215.       _system_reload_messages = null;
  216.     }
  217.     drupalgap_loading_message_show();
  218.   }
  219.   catch (error) { console.log('system_reload_pageshow - ' + error); }
  220. }
  222. /**
  223.  * Implements hook_system_drupalgap_goto_post_process().
  224.  * @param {String} path
  225.  */
  226. function system_drupalgap_goto_post_process(path) {
  227.   try {
  229.     // To reload the "current" page, grab the path we have been requested to
  230.     // reload, clear out our global reference to it, then go!
  231.     // @see https://github.com/signalpoint/DrupalGap/issues/254
  232.     if (path == '_reload') {
  233.       if (!_system_reload_page) { return; }
  234.       var path = '' + _system_reload_page;
  235.       _system_reload_page = null;
  236.       drupalgap_loading_message_show();
  237.       drupalgap_goto(path, { reloadPage: true });
  238.     }
  240.   }
  241.   catch (error) {
  242.     console.log('system_drupalgap_goto_post_process - ' + error);
  243.   }
  244. }
  246. /**
  247.  * Page callback for the dashboard page.
  248.  * @return {Object}
  249.  */
  250. function system_dashboard_page() {
  251.   try {
  252.     var content = {};
  253.     content.site_info = {
  254.       markup: '<h4 style="text-align: center;">' +
  255.         Drupal.settings.site_path +
  256.       '</h4>'
  257.     };
  258.     content.welcome = {
  259.       markup: '<h2 style="text-align: center;">' +
  260.         t('Welcome to DrupalGap') +
  261.       '</h2>' +
  262.       '<p style="text-align: center;">' +
  263.         t('The open source application development kit for Drupal!') +
  264.       '</p>'
  265.     };
  266.     if (drupalgap.settings.logo) {
  267.       content.logo = {
  268.         markup: '<center>' +
  269.                  theme('image', {path: drupalgap.settings.logo}) +
  270.                '</center>'
  271.       };
  272.     }
  273.     content.get_started = {
  274.       theme: 'button_link',
  275.       text: t('Getting Started Guide'),
  276.       path: 'http://www.drupalgap.org/get-started',
  277.       options: {InAppBrowser: true}
  278.     };
  279.     content.support = {
  280.       theme: 'button_link',
  281.       text: t('Support'),
  282.       path: 'http://www.drupalgap.org/support',
  283.       options: {InAppBrowser: true}
  284.     };
  285.     return content;
  286.   }
  287.   catch (error) { console.log('system_dashboard_page - ' + error); }
  288. }
  290. /**
  291.  * The page callback for the error page.
  292.  * @return {Object}
  293.  */
  294. function system_error_page() {
  295.     var content = {
  296.       info: {
  297.         markup: '<p>' + t('An unexpected error has occurred!') + '</p>'
  298.       }
  299.     };
  300.     return content;
  301. }
  303. /**
  304.  * Call back for the offline page.
  305.  * @return {Object}
  306.  */
  307. function system_offline_page() {
  308.   try {
  309.     var content = {
  310.       'message': {
  311.         'markup': '<h2>' + t('Failed Connection') + '</h2>' +
  312.           '<p>' + t("Oops! We couldn't connect to") + ':</p>' +
  313.           '<p>' + Drupal.settings.site_path + '</p>'
  314.       },
  315.       'try_again': {
  316.         'theme': 'button',
  317.         'text': t('Try Again'),
  318.         'attributes': {
  319.           'onclick': 'javascript:offline_try_again();'
  320.         }
  321.       },
  322.       'footer': {
  323.         'markup': '<p>' +
  324.           t("Check your device's network settings and try again.") +
  325.         '</p>'
  326.       }
  327.     };
  328.     return content;
  329.   }
  330.   catch (error) { console.log('system_offline_page - ' + error); }
  331. }
  333. /**
  334.  * When the 'try again' button is clicked, check for a connection and if it has
  335.  * one make a call to system connect then go to the front page, otherwise just
  336.  * inform user the device is still offline.
  337.  * @return {*}
  338.  */
  339. function offline_try_again() {
  340.   try {
  341.     var connection = drupalgap_check_connection();
  342.     if (drupalgap.online) {
  343.       system_connect({
  344.         success: function() {
  345.           drupalgap_goto('');
  346.         }
  347.       });
  348.     }
  349.     else {
  350.       var msg = t('Sorry, no connection found!') + ' (' + connection + ')';
  351.       drupalgap_alert(msg, {
  352.           title: 'Offline'
  353.       });
  354.       return false;
  355.     }
  356.   }
  357.   catch (error) { console.log('offline_try_again - ' + error); }
  358. }
  360. /**
  361.  * Returns an array of region names defined by the system that themes must use.
  362.  * We do this so Core and Contrib Modules can use these regions for UI needs.
  363.  * @return {Array}
  364.  */
  365. function system_regions_list() {
  366.     var regions = ['header', 'content', 'footer'];
  367.     return regions;
  368. }
  370. /**
  371.  * Add default buttons to a form and set its prefix.
  372.  * @param {Object} form
  373.  * @param {Object} form_state
  374.  * @return {Object}
  375.  */
  376. function system_settings_form(form, form_state) {
  377.   try {
  378.     // Add submit button to form if one isn't present.
  379.     if (!form.elements.submit) {
  380.       form.elements.submit = {
  381.         type: 'submit',
  382.         value: t('Save configuration')
  383.       };
  384.     }
  385.     // Add cancel button to form if one isn't present.
  386.     if (!form.buttons.cancel) {
  387.       form.buttons['cancel'] = drupalgap_form_cancel_button();
  388.     }
  389.     // Attach submit handler.
  390.     form.submit.push('system_settings_form_submit');
  391.     return form;
  392.   }
  393.   catch (error) { console.log('system_settings_form - ' + error); }
  394. }
  396. /**
  397.  * Execute the system_settings_form.
  398.  * @param {Object} form
  399.  * @param {Object} form_state
  400.  */
  401. function system_settings_form_submit(form, form_state) {
  402.   try {
  403.     if (form_state.values) {
  404.       for (var variable in form_state.values) {
  405.           if (!form_state.values.hasOwnProperty(variable)) { continue; }
  406.           var value = form_state.values[variable];
  407.           variable_set(variable, value);
  408.       }
  409.     }
  410.   }
  411.   catch (error) { console.log('system_settings_form_submit - ' + error); }
  412. }
  414. /**
  415.  * Returns the block id used on the system's title block.
  416.  * @param {String} path
  417.  * @return {String}
  418.  */
  419. function system_title_block_id(path) {
  420.   try {
  421.     var id = 'drupalgap_page_title_' + drupalgap_get_page_id(path);
  422.     return id;
  423.   }
  424.   catch (error) { console.log('system_title_block_id - ' + error); }
  425. }
  427. /**
  428.  * The default access callback function for the logout block. Allows the block
  429.  * to only be shown when a user is viewing their own profile.
  430.  * @param {Object} options
  431.  * @return {Boolean}
  432.  */
  433. function system_logout_block_access_callback(options) {
  434.   try {
  435.     var args = arg(null, options.path);
  436.     if (
  437.       args &&
  438.       args.length == 2 &&
  439.       args[0] == 'user' &&
  440.       args[1] == Drupal.user.uid
  441.     ) { return true; }
  442.     return false;
  443.   }
  444.   catch (error) {
  445.     console.log('system_logout_block_access_callback - ' + error);
  446.   }
  447. }