api.js

/**
 * Implements hook_add_page_to_dom_alter().
 */
function hook_add_page_to_dom_alter(attributes, options) {

  // Use this hook to make alterations to a page's attributes or options before it is added to the DOM.

  // @param {Object} attributes
  // The page attributes on a page before it is added to the DOM.

  // @param {Object} options
  // The page options object containing the rendered html, the menu link object, and the internal page id.

  // Add a custom class to the page indicating the device size. Place
  // empty spaces around the class name so we don't collide with others.
  var size = null;
  var width = $(window).width();
  if (width <= 414) { size = 'small'; }
  else if (width < 1024) { size = 'medium'; }
  else { size = 'large'; }
  attributes.class += ' ' + size + ' ';

  // Add a custom class to a particular route.
  if (drupalgap_router_path_get() == 'channel/%') {
    attributes.class += ' foo-bar ';
  }

}

/**
 * When a form submission for an entity is assembling the entity json object to
 * send to the server, some form element fields need to be assembled in unique
 * ways to match the entity's structure in Drupal. Modules that implement fields
 * can use this hook to properly assemble the item value (by delta) and return
 * it.
 * @param {Object} entity_type
 * @param {String} bundle
 * @param {String} form_state_value
 * @param {Object} field
 * @param {Object} instance
 * @param {String} langcode
 * @param {Number} delta
 * @param {Object} field_key Set the 'value' string property on this object to
 *                           use a custom property name on the field value.
 *                           Defaults to 'value'.
 *                           Set the 'use_key' boolean property on this object
 *                           to false to not use a key when assembling the
 *                           result into the field. Defaults to true.
 *                           Set the 'use_wrapper' boolean property on this
 *                           object to false to not use the default wrapper
 *                           placed around the result object. Defaults to true.
 *                           Set the 'use_delta' boolean property to false when
 *                           a delta value is not needed. Defaults to true.
 * @param {Object} form
 *
 * @return {*}
 */
function hook_assemble_form_state_into_field(entity_type, bundle,
  form_state_value, field, instance, langcode, delta, field_key, form) {
  try {
    // Listed below are example use cases. Each show how to assemble the result,
    // and what the resulting field object will look like when assembled by the
    // DrupalGap Forms API. We'll use a field machine name of 'field_my_field'
    // in all of the examples.
    
    // Optional helpful values.
    // Grab the form element's name, the form id, and the element's id.
    // var element_name = field_key.name;
    // var form_id = field_key.form_id;
    // var element_id = field_key.element_id;

    // Example 1 - Here's a simple example using all the defaults.
    var result = {
      foo: 'bar'
    };
    return result;
    // This in turn gets assembled by the DG FAPI.
    // {
    //   /* ... other entity values and fields ... */
    //   field_my_field: {
    //     und: [
    //       { value: { foo: "bar" } }
    //     ]
    //   }
    // }
    
    // Example 2 - Setting the 'value' property.
    field_key.value = "foo";
    var result = "bar";
    return result;
    // {
    //   /* ... other entity values and fields ... */
    //   field_my_field: {
    //     und: [
    //       { foo: "bar" }
    //     ]
    //   }
    // }
    
    // Example 3 - Setting the 'use_key' to false.
    field_key.use_key = false;
    var result = "bar";
    return result;
    // {
    //   /* ... other entity values and fields ... */
    //   field_my_field: {
    //     und: ["bar"]
    //   }
    // }
    
    // Example 4 - Setting the 'use_delta' to false.
    field_key.use_delta = false;
    var result = "bar";
    return result;
    // {
    //   /* ... other entity values and fields ... */
    //   field_my_field: {
    //     und: ["bar"]
    //   }
    // }
    
    // Example 5 - Setting the 'use_delta' and 'use_wrapper' to false.
    field_key.use_delta = false;
    field_key.use_wrapper = false;
    var result = "bar";
    return result;
    // {
    //   /* ... other entity values and fields ... */
    //   field_my_field: {
    //     und: "bar"
    //   }
    // }
  }
  catch (error) {
    console.log('hook_assemble_form_state_into_field - ' + error);
  }
}

/**
 * When the app is first loading up, DrupalGap checks to see if the device has a connection, if it does then this hook
 * is called. If DrupalGap doesn't have a connection, then hook_device_offline() is called. Implementations of
 * hook_deviceready() need to return true if they'd like DrupalGap to continue, or return false if you'd like DrupalGap
 * to NOT continue. If DrupalGap continues, it will perform a System Connect resource call then go to the App's front
 * page. This is called during DrupalGap's "deviceready" implementation for PhoneGap. Note, the Drupal.user object is
 * not initialized at this point, and will always be an anonymous user.
 */
function hook_deviceready() {}

/**
 * When someone calls drupalgap_has_connection(), this hook has an opportunity to set drupalgap.online to true or false.
 * The value of drupalgap.online is returned to anyone who calls drupalgap_has_connection(), including DrupalGap core.
 */
function hook_device_connection() {

  // If it is Saturday, take the app offline and force the user to go outside and play.
  var d = new Date();
  if (d.getDay() == 6) { drupalgap.online = false; }

}

/**
 * Called during app startup if the device does not have a connection. Note, the Drupal.user object is ot initialized at
 * this point, and will always be an anonymous user.
 */
function hook_device_offline() {

  // Even though we're offline, let's just go to the front page.
  drupalgap_goto('');

}

/**
 * Take action when the user presses the "back" button. This includes the soft,
 * hardware and browser back buttons. The browser back button is only available
 * in web app mode, the hardware back button is typically only on compiled
 * Android devices, whereas the soft back button actually appears within the UX
 * of the app.
 * @param {String} from
 * @param {String} to
 * @see http://docs.drupalgap.org/7/Widgets/Buttons/Back_Button
 */
function hook_drupalgap_back(from, to) {

  // When the user navigates from the front page to the login page, show them
  // a message (a toast).
  if (from == drupalgap.settings.front && to == 'user/login') {
    drupalgap_toast('Please login to continue');
  }

}

/**
 * Each time a page is navigated to within the app, drupalgap_goto() is called.
 * Use this hook to do some preprocessing before drupalgap_goto() gets started.
 * @param {String} path The current page path.
 */
function hook_drupalgap_goto_preprocess(path) {
  try {
    // Pre process the front page.
    if (path == drupalgap.settings.front) {
      drupalgap_alert(t('Preprocessing the front page!'));
    }
  }
  catch (error) {
    console.log('hook_drupalgap_goto_preprocess - ' + error);
  }
}

/**
 * Each time a page is navigated to within the app, drupalgap_goto() is called.
 * Use this hook to do some post processing after drupalgap_goto() has finished.
 * @param {String} path The current page path.
 */
function hook_drupalgap_goto_post_process(path) {
  try {
    // Post process the front page.
    if (path == drupalgap.settings.front) {
      drupalgap_alert(t('Post processing the front page!'));
    }
  }
  catch (error) {
    console.log('hook_drupalgap_goto_post_process - ' + error);
  }
}

/**
 * Called after a successful services API call to a Drupal site. Do not call
 * any services from within your implementation, you may run into an infinite
 * loop in your code. See http://drupalgap.org/project/force_authentication for
 * example usage.
 * @deprecated - use hook_services_postprocess() instead.
 */
function hook_services_success(url, data) { }

/**
 * A hook used to declare custom block information.
 */
function hook_block_info() {}

/**
 * A hook used to render custom blocks.
 */
function hook_block_view(delta, region) {
}

/**
 * A hook used to handle a 404 in the app.
 */
function hook_404(router_path) {}

/**
 * Implements hook_entity_pre_build_content().
 */
function hook_entity_pre_build_content(entity, entity_type, bundle) {

  // Change some weights on nodes with a date field.
  if (entity_type == 'node' && typeof entity.field_date !== 'undefined') {
    entity.body.weight = 0;
    entity.field_date.weight = 1;
  }
}

/**
 * Implements hook_entity_post_build_content().
 */
function hook_entity_post_build_content(entity, entity_type, bundle) {

}

/**
 * Implements hook_entity_pre_render_content().
 * Called before drupalgap_entity_render_content() assembles the entity.content
 * string. Use this to make modifications to an entity before its' content is rendered.
 */
function hook_entity_pre_render_content(entity, entity_type, bundle) {
  try {

    // Remove access to the date field on all nodes.
    if (entity_type == 'node' && typeof entity.field_date !== 'undefined') {
      entity.field_date.access = false;
    }

  }
  catch (error) {
    console.log('hook_entity_pre_render_content - ' + error);
  }
}

/**
 * Called after drupalgap_entity_render_content() assembles the entity.content
 * string. Use this to make modifications to the HTML output of the entity's
 * content before it is displayed.
 */
function hook_entity_post_render_content(entity, entity_type, bundle) {
  try {
    if (entity.type == 'article') {
      entity.content += '<p>' + t('Example text on every article!') + '</p>';
    }
  }
  catch (error) {
    console.log('hook_entity_post_render_content - ' + error);
  }
}

/**
 * Implements hook_entity_view_alter().
 * Called immediately before a page is rendered and injected into its waiting
 * container. Use this hook to modifications to the build object by adding or
 * editing render arrays (widgets) on the build object.
 */
function hook_entity_view_alter(entity_type, entity_id, mode, build) {
  try {
    if (entity_type == 'user' && mode == 'view') {
      if (entity_id == Drupal.user.uid) {
        build['foo'] = { markup: '<p>Extra stuff when viewing own user profile...</p>' };
        build['volume'] = {
          theme: 'range',
          attributes: {
            min: '0',
            max: '11',
            value: '11',
            'data-theme': 'b'
          }
        };
      }
      else {
        build['bar'] = { markup: '<p>Viewing some other profile...</p>' };
      }
    }
  }
  catch (error) { console.log('hook_entity_view_alter - ' + error); }
}

/**
 * Implements hook_field_info_instance_add_to_form().
 * Used by modules that provide custom fields to operate on a form or its
 * elements before the form gets saved to local storage. This allows extra
 * data be attached to the form that way things like hook_field_widget_form(),
 * which takes place at render time, can have access to any extra data it may
 * need.
 * @param {String} entity_type
 * @param {String} bundle
 * @param {Object} form
 * @param {Object} entity
 * @param {Object} element
 */
function hook_field_info_instance_add_to_form(entity_type, bundle, form, entity, element) {
  try {
    // Attach a value_callback to the element so we can manually build its form
    // state value.
    element.value_callback = 'example_field_value_callback';
  }
  catch (error) { console.log('hook_field_info_instance_add_to_form - ' + error); }
}

/**
 * Implements hook_field_formatter_view().
 * @param {String} entity_type
 * @param {Object} entity
 * @param {Object} field
 * @param {Object} instance
 * @param {String} langcode
 * @param {Object} items
 * @param {Object} display
 */
function hook_field_formatter_view(entity_type, entity, field, instance, langcode, items, display) {
  try {
    
    // Use this hook to render a field's content on an entity. Use dpm() to
    // inspect the incoming arguments. The arguments contain field display
    // settings from Drupal.
    
    //console.log(entity_type);
    //console.log(entity);
    //console.log(field);
    //console.log(instance);
    //console.log(langcode);
    //console.log(items);
    //console.log(display);
    
    // Iterate over each item, and place a widget onto the render array.
    var content = {};
    for (var delta in items) {
        if (!items.hasOwnProperty(delta)) { continue; }
        var item = items[delta];
        content[delta] = {
          markup: '<p>' + t('Hello!') + '</p>'
        };
    }
    return content;
  }
  catch (error) { console.log('hook_field_formatter_view - ' + error); }
}

/**
 * Implements hook_field_widget_form().
 * @param {Object} form
 * @param {Object} form_state
 * @param {Object} field
 * @param {Object} instance
 * @param {String} langcode
 * @param {Object} items
 * @param {Number} delta
 * @param {Object} element
 */
function hook_field_widget_form(form, form_state, field, instance, langcode, items, delta, element) {
  try {
    // Use this hook to provide field widgets for form element items. This hook
    // is called for each delta value on the field. Make modifications to the
    // items collection using the provided delta value. The object contained
    // within is a standard DrupalGap Forms API object, so you may assemble the
    // field (and any children widgets) as needed.
    
    // Very simple example, make the widget for the field a text field.
    items[delta].type = 'textfield';
  }
  catch (error) { console.log('hook_field_widget_form - ' + error); }
}

/**
 * Called after a form element is assembled. Use it to alter a form element.
 */
//function hook_form_element_alter(form, element, variables) { }

/**
 * Implements hook_entity_post_render_field().
 * Called after drupalgap_entity_render_field() assembles the field content
 * string. Use this to make modifications to the HTML output of the entity's
 * field before it is displayed. The field content will be inside of
 * reference.content, so to make modifications, change reference.content. For
 * more info: http://stackoverflow.com/questions/518000/is-javascript-a-pass-by-reference-or-pass-by-value-language
 */
function hook_entity_post_render_field(entity, field_name, field, reference) {
  if (field_name == 'field_my_image') {
    reference.content += '<h2>' + entity.title + '</h2>';
  }
}

/**
 * Implements hook_form_alter().
 * This hook is used to make alterations to existing forms.
 */
function hook_form_alter(form, form_state, form_id) {
  // Change the description of the name element on the user login form
  if (form_id == 'user_login_form') {
    form.elements['name'].description = t('Enter your login name');
  }
}

/**
 * Implements hook_image_path_alter().
 * Called after drupalgap_image_path() assembles the image path. Use this hook
 * to make modifications to the image path. Return the modified path, or false
 * to allow the default path to be generated.
 */
function hook_image_path_alter(src) { }

/**
 * Implements hook_install().
 * This hook is used by modules that need to execute custom code when the module
 * is loaded. Note, the Drupal.user object is not initialized at this point, and
 * always appears to be an anonymous user.
 */
function hook_install() { }

/**
 * Implements hook_locale().
 * Used to declare language code .json files that should be loaded by DrupalGap.
 * @see http://drupalgap.org/translate
 */
function hook_locale() {
  // Tell DrupalGap to load our custom Spanish and Italian language files
  // located here:
  //   app/modules/custom/my_module/locale/es.json
  //   app/modules/custom/my_module/locale/it.json
  return ['es', 'it'];
}

/**
 * Implements hook_menu()
 * This hook is used to declare menu paths for custom pages.
 */
function hook_menu() {
  try {
    var items = {};
    items['hello_world'] = {
      title: t('Hello World'),
      page_callback: 'my_module_hello_world_page'
    };
    return items;
  }
  catch (error) { console.log('hook_menu - ' + error); }
}

function hook_mvc_model() {
  var models = {};
  return models;
}
function hook_mvc_view() {}
function hook_mvc_controller() {}

/**
 * Implements hook_node_page_view_alter_TYPE().
 * @param {Object} node The fully loaded node object.
 * @param {Object} options The options object, containing the success callback.
 */
function hook_node_page_view_alter_TYPE(node, options) {
  try {

    // Use this hook to completely take over the content that is shown when a
    // user views a certain content type's page within the app. Pass your
    // content (render array or html string) to the sucess callback provided in
    // options to have it automatically injected in the page.

    var content = {};
    content['my_markup'] = {
      markup: '<p>'+t('Click below to see the node!')+'</p>'
    };
    content['my_collapsible'] = {
      theme: 'collapsible',
      header: node.title,
      content: node.content
    };
    options.success(content);

  }
  catch (error) { console.log('hook_node_page_view_alter_TYPE() - ' + error); }
}

/**
 * Implements hook_page_build().
 * @param {Object} output The page build output object.
 */
function hook_page_build(output) {
  try {
    // Remove all titles from article node pages.
    if (output.node && output.node.type == 'article') {
      delete output.title;
    }
  }
  catch (error) { console.log('hook_page_build - ' + error); }
}

/**
 * Implements hook_preprocess_page().
 * Take action before the page is processed and shown to the user.
 * @param {Object} variables The page variables.
 */
function hook_preprocess_page(variables) {
  try {

  }
  catch (error) {
    console.log('hook_preprocess_page - ' + error);
  }
}

/**
 * Implements hook_post_process_page().
 * Take action after the page is processed and shown to the user.
 * @param {Object} variables The page variables.
 */
function hook_post_process_page(variables) {
  try {

  }
  catch (error) {
    console.log('hook_post_process_page - ' + error);
  }
}

/**
 * Implements hook_views_exposed_filter().
 * @param {Object} form
 * @param {Object} form_state
 * @param {Object} element
 * @param {Object} filter
 * @param {Object} field
 */
function hook_views_exposed_filter(form, form_state, element, filter, field) {
  try {
    
    // This hook is used to assemble the form element for an exposed filter.
    // Make modifications to the element JSON object to control how it is used
    // on the form. The element comes prepopulated with some basic values. The
    // majority of the data you need to assemble the field should be contained
    // within the filter and field JSON objects, so use dpm() to insepct them
    // and assemble your filter's element.
    
    //dpm(filter);
    //dpm(field);
    
  }
  catch (error) { console.log('hook_views_exposed_filter - ' + error); }
}