stanford_capx.module

<?php
/**
 * @file
 * @author [author]
 */

// Make sure this is loaded.
require_once "includes/autoloader.php";
require_once "includes/vendor/autoload.php";

require_once "stanford_capx.entity.hooks.inc";
require_once "stanford_capx.forms.inc";
require_once "stanford_capx.blocks.inc";
require_once "stanford_capx.theme.inc";
require_once "stanford_capx.docs.inc";
require_once "stanford_capx.views.inc";
require_once "stanford_capx.pages.inc";


use CAPx\Drupal\Importer\EntityImporterBatch;
use CAPx\Drupal\Processors\EntityProcessor;

use CAPx\Drupal\Mapper\EntityMapper;
use CAPx\Drupal\Mapper\FieldCollectionMapper;

use CAPx\Drupal\Util\CAPx;
use CAPx\Drupal\Util\CAPxMapper;
use CAPx\Drupal\Util\CAPxImporter;
use CAPx\Drupal\Util\CAPxConnection;
use CAPx\Drupal\Organizations\Orgs;

// No mapping into these entity types.
global $CAP_RESTRICTED_ENTITY_TYPES;
$CAP_RESTRICTED_ENTITY_TYPES = array(
  'capx_cfe',
  'capx_cfe_type',
  'file',
  'comment',
  'taxonomy_vocabulary',
  'field_collection_item',
  'redirect',
  'wysiwyg_profile',
  'menu_link',
);

global $CAP_RESTRICTED_FIELD_PROPERTIES;
$CAP_RESTRICTED_FIELD_PROPERTIES = array(
  'format',
  'attributes',
);

define('STANFORD_CAPX_FILE_PATH', 'private://stanford_capx');
define('STANFORD_CAPX_SCHEMA_FILE', 'schema.json');

/**
 * Implements hook_help().
 */
function stanford_capx_help($path, $arg) {
  switch ($path) {
    case 'admin/capx':
      return '<p>' . t('Contact %email', array('%email' => l(t('email'), 'mailto:no-reply@stanford.edu'))) . '</p>';
  }
}

/**
 * Implements hook_permission().
 */
function stanford_capx_permission() {
  return array(
    'administer capx' => array(
      'title' => t('Administer CAPx'),
      'description' => t('Administer and configure CAPx settings.'),
    ),
    // 'capx administer importers' => array(
    //   'title' => t('Administer CAPx Importers'),
    //   'description' => t('Administer and configure CAPx importers.'),
    // ),
    // 'capx administer mappers' => array(
    //   'title' => t('Administer CAPx Mappers'),
    //   'description' => t('Administer and configure CAPx mappers.'),
    // ),
    'capx advanced administrator' => array(
      'title' => t('Administer Advanced CAPx settings'),
      'description' => t('Administer and Ccnfigure CAPx advanced settings.'),
    ),
  );
}

/**
 * Implements hook_node_access().
 */
function stanford_capx_node_access($node, $op, $account) {
  // Returning nothing from this function would have the same effect.
  $access = NODE_ACCESS_IGNORE;

  // Disable deletion of nodes synced from CAP.
  if ($op == 'delete' && isset($node->capx) && !empty($node->capx['sync'])) {
    $access = NODE_ACCESS_DENY;
  }

  return $access;
}

/**
 * Implments hook_views_api().
 */
function stanford_capx_views_api() {
  return array("version" => "3.0");
}

/**
 * Implements hook_menu().
 */
function stanford_capx_menu() {

  // Overview page.
  $items['admin/config/capx'] = array(
    'title' => 'CAPx',
    'page callback' => 'stanford_capx_admin_config',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  // Settings Page.
  $items['admin/config/capx/settings'] = array(
    'title' => 'Settings',
    'page callback' => 'stanford_capx_admin_config_settings',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => -9,
  );

  // Sync organizations callback.
  $items['admin/config/capx/organizations/sync'] = array(
    'title' => 'Organizations Sync',
    'page callback' => 'stanford_capx_organizations_sync',
    'access arguments' => array('administer capx'),
    'type' => MENU_CALLBACK,
  );

  // Help Page.
  $items['admin/config/capx/help'] = array(
    'title' => 'Help',
    'page callback' => 'stanford_capx_admin_config_help',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => 10,
  );

  // Data Browser.
  $items['admin/config/capx/data-browser'] = array(
    'title' => 'Data Browser',
    'page callback' => 'stanford_capx_admin_config_data_browser',
    'file' => 'stanford_capx.docs.inc',
    'access arguments' => array('administer capx'),
    'type' => MENU_SUGGESTED_ITEM,
    'weight' => 10,
  );


  // Mapper pages
  // ---------------------------------------------------------------------------

  $items['admin/config/capx/mapper'] = array(
    'title' => 'Map',
    'page callback' => 'stanford_capx_admin_config_mapper',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => -5,
  );

  $items['admin/config/capx/mapper/new'] = array(
    'title' => 'Create new mapping',
    'page callback' => 'stanford_capx_admin_config_mapper_new',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  $items['admin/config/capx/mapper/edit/%'] = array(
    'title' => 'Edit mapping',
    'page callback' => 'stanford_capx_admin_config_mapper_edit',
    'page arguments' => array(5),
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  $items['admin/config/capx/mapper/delete/%'] = array(
    'title' => 'Delete mapping',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('stanford_capx_admin_config_mapper_delete', 5),
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  // Importer pages
  // ---------------------------------------------------------------------------

  $items['admin/config/capx/importer'] = array(
    'title' => 'Import',
    'page callback' => 'stanford_capx_admin_config_import',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => -4,
  );

  $items['admin/config/capx/importer/new'] = array(
    'title' => 'Create new importer',
    'page callback' => 'stanford_capx_admin_config_import_new',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  $items['admin/config/capx/importer/edit/%'] = array(
    'title' => 'Edit importer',
    'page arguments' => array(5),
    'page callback' => 'stanford_capx_admin_config_import_edit',
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  $items['admin/config/capx/importer/delete/%'] = array(
    'title' => 'Delete Importer',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('stanford_capx_admin_config_importer_delete', 5),
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  $items['admin/config/capx/importer/sync/%'] = array(
    'title' => 'Sync Importer',
    'page callback' => 'stanford_capx_sync_importer',
    'page arguments' => array(5),
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  $items['admin/config/capx/importer/orphans/%'] = array(
    'title' => 'Orphanator Importer',
    'page callback' => 'stanford_capx_orphan_importer',
    'page arguments' => array(5),
    'access arguments' => array('administer capx'),
    'type' => MENU_NORMAL_ITEM,
  );

  $items['admin/config/capx/importer/sync-all'] = array(
    'title' => 'Sync All Importers',
    'page callback' => 'stanford_capx_sync_all_importers',
    'access arguments' => array('administer capx'),
    'type' => MENU_CALLBACK,
  );

  // Profile pages
  // ---------------------------------------------------------------------------

  // In views now...

  // MISC
  // ---------------------------------------------------------------------------

  $items['admin/config/capx/autocomplete/%'] = array(
    'title' => 'Autocomplete Callback Endpoint',
    'page callback' => 'stanford_capx_autocomplete',
    'page arguments' => array(4),
    'access arguments' => array('administer capx'),
    'type' => MENU_CALLBACK,
  );

  $items['admin/config/capx/profile-update/%/%'] = array(
    'title' => 'Force profile update callback',
    'page callback' => 'stanford_capx_profile_update',
    'page arguments' => array(4, 5),
    'access arguments' => array('administer capx'),
    'type' => MENU_CALLBACK,
  );

  $items['admin/config/capx/profile-sync/%/%'] = array(
    'title' => 'Profile synchronization settings change callback',
    'page callback' => 'stanford_capx_profile_sync_status',
    'page arguments' => array(4, 5),
    'access arguments' => array('administer capx'),
    'type' => MENU_CALLBACK,
  );

  return $items;
}

/**
 * Implements hook_flush_caches().
 */
function stanford_capx_flush_caches() {
  // Sort of hacky but this works...
  variable_del("stanford_capx_admin_messages");
  return array();
}

// Cron
// /////////////////////////////////////////////////////////////////////////////


/**
 * Implements hook_cron().
 */
function stanford_capx_cron() {

  // Call cron on all importers.
  $importers = CAPxImporter::loadAllImporters();
  foreach ($importers as $key => $importer) {
    $entity_importer = CAPxImporter::loadEntityImporter($importer->identifier());
    if ($entity_importer) {
      $entity_importer->cron();
    }
    else {
      $vars = array(
        '%name' => $importer->identifier(),
      );
      watchdog('There was an issue loading the importer with %name machine name.', $vars, WATCHDOG_ERROR);
    }
  }

}

/**
 * Implements hook_cron_queue_info().
 */
function stanford_capx_cron_queue_info() {

  // A queue process for importing/sync profiles.
  $queues['stanford_capx_profiles'] = array(
    'worker callback' => 'stanford_capx_cron_queue_callback',
    'time' => variable_get('stanford_capx_runtime_limit', 120),
    'skip on cron' => FALSE,
  );

  // A queue process for finding and removing orphans.
  $queues['stanford_capx_profile_orphans'] = array(
    'worker callback' => 'stanford_capx_cron_orphan_queue_callback',
    'time' => variable_get('stanford_capx_runtime_limit', 120),
    'skip on cron' => FALSE,
  );

  return $queues;
}

/**
 * Callback function.
 *
 * This function exists merely as a callback function as the static class
 * function was not able to be called directly.
 *
 * @param array $item
 *   An array of item information to process.
 */
function stanford_capx_cron_queue_callback($item) {
  EntityImporterBatch::queue($item);
}

/**
 * Callback function.
 *
 * Callback function for creating and running the orphan functionality.
 *
 * @param array $item
 *   An array of item information to process.
 *   $item['importer']
 *   $item['profiles']
 */
function stanford_capx_cron_orphan_queue_callback($item) {
  $orphanator = CAPxImporter::getEntityOrphanator($item['importer'], $item['profiles']);
  if (!$orphanator) {
    watchdog('stanford_capx_orphans', 'Could not load orphanator for %porter', array('%porter' => $item['importer']), WATCHDOG_WARNING);
    return FALSE;
  }
  $orphanator->execute();
}

/**
 * Passthrough function...
 * @return [type] [description]
 */
function stanford_capx_orgs_batch_finished($success, $results, $operations) {
  Orgs::syncOrganizationsBatchFinished($success, $results, $operations);
}

/**
 * Batch finished callback
 * @param  [type] $success    [description]
 * @param  [type] $results    [description]
 * @param  [type] $operations [description]
 * @return [type]             [description]
 */
function stanford_capx_importer_batch_finished($success, $results, $operations) {
  if ($success) {
    drupal_set_message(t("Sync successfully completed."), "status");
  }
  else {
    drupal_set_message(t("Sync failed. Please try again."), "error");
  }
}

/**
 * Batch finished callback.
 * @param  [type] $success    [description]
 * @param  [type] $results    [description]
 * @param  [type] $operations [description]
 * @return [type]             [description]
 */
function stanford_capx_orphan_check_batch_finished($success, $results, $operations) {
  if ($success) {
    drupal_set_message(t("Check for orphans completed."), "status");
  }
  else {
    drupal_set_message(t("Check for orphans failed. Please try again."), "error");
  }
}

// END CRON AND BATCH
// /////////////////////////////////////////////////////////////////////////////

// AUTOCOMPLETE
// /////////////////////////////////////////////////////////////////////////////

/**
 * Autocomplete callback endpoint for organizations.
 * @param  string $type the type of autocomplete callback we are looking up.
 * @param  string $string the string that is in the autocomplete field.
 * @return string
 *   Json results
 */
function stanford_capx_autocomplete($type, $string) {
  $matches = array();

  switch ($type) {
    case "orgs":
      $matches += stanford_capx_autocomplete_orgs($string);
      break;
  }

  return drupal_json_output($matches);
}

/**
 * Matches function for organization lookup.
 *
 * @param string $string
 *   $string the string that came from the autocomplete field.
 *
 * @return array
 *   An array of results
 */
function stanford_capx_autocomplete_orgs($string) {
  $matches = array();
  $items = array_map('trim', explode(',', $string));
  $last_item = array_pop($items);
  $prefix = implode(', ', $items);

  // Two ways to look up an org. By org code or by name.
  // Look for the exact code match.

  $byname = taxonomy_get_term_by_name($last_item);
  if (!empty($byname)) {
    $option = array_pop($byname);
    $value = !empty($prefix) ? $prefix . ', ' . $option->name : $option->name;
    $matches[$value] = '[' . $option->name . '] ' . t(ucwords($option->description));
  }

  // If we have an exact match lets not go any further.
  if ($matches) {
    return $matches;
  }

  $vocab = Orgs::getVocabulary();

  // Partial code lookup. eg: AAH for AAHH
  // Partial name lookup. eg: Busi for Business and Operations.

  $or = db_or()
    ->condition('name', db_like($last_item) . '%', 'LIKE')
    ->condition('description', db_like($last_item) . '%', 'LIKE');

  $query = db_select('taxonomy_term_data', 'ttd')
    ->fields('ttd', array('tid', 'name', 'description'))
    ->condition($or)
    ->execute()
    ->fetchAll();

  foreach ($query as $option) {
    $value = !empty($prefix) ? $prefix . ', ' . $option->name : $option->name;
    $matches[$value] = '[' . $option->name . '] ' . t(ucwords($option->description));
  }

  return $matches;
}

// END AUTOCOMPLETE
// /////////////////////////////////////////////////////////////////////////////


// SCHEMA (API)
// /////////////////////////////////////////////////////////////////////////////

/**
 * Implements hook_schema_load.
 * @param string $format the format type to return in.
 * @param bool $reset A boolean value to reset the cache or not.
 *
 * @return string
 *   The file's contents.
 */
function stanford_capx_schema_load($format = 'json', $reset = FALSE) {
  // If the directory doesn't exist, the file won't either.
  if (!stanford_capx_files_dir_exists()) {
    return FALSE;
  }

  $file = STANFORD_CAPX_FILE_PATH . "/" . STANFORD_CAPX_SCHEMA_FILE;

  // @TODO: Refresh automatically under some condition? Weekly?
  // If forcing a refesh or the schema hasn't been downloaded, download it!
  if ($reset || !file_exists($file)) {
    $file_contents = stanford_capx_schema_refresh();
  }
  else {
    $file_contents = file_get_contents($file);
  }

  if (empty($file_contents)) {
    return FALSE;
  }

  if ($format === 'object') {
    $file_contents = json_decode($file_contents);
  }
  elseif ($format === 'array') {
    $file_contents = json_decode($file_contents, TRUE);
  }
  return $file_contents;
}

/**
 * Refresh the schema with fresh information from the API.
 *
 * @return mixed
 *   FALSE if failed or a json string if success.
 */
function stanford_capx_schema_refresh() {
  $file = STANFORD_CAPX_FILE_PATH . "/" . STANFORD_CAPX_SCHEMA_FILE;

  // Ensure the modules' private files directory exists and is writable.
  if (stanford_capx_files_dir_exists()) {

    // Query the API for the profile schema as raw JSON.
    $client = CAPxConnection::getAuthenticatedHTTPClient();
    $response = $client->api('schema')->getRaw('profile');

    if (empty($response)) {
      drupal_set_message(t("Error: Something went wrong. Could not update schema information. Please contact your site administrator."), "error");
      return FALSE;
    }

    $schema = $response->getBody(TRUE);

    // Cache the result in a private file.
    if ($schema && !empty($schema)) {
      file_unmanaged_save_data($schema, $file, FILE_EXISTS_REPLACE);
    }
    drupal_set_message(t("Schema information refreshed"), "status");
    variable_set("capx_last_schema_sync", format_date(time()));
    return $schema;
  }
  return FALSE;
}

/**
 * Check to see if the private directory has been set up properly and is writable.
 *
 * @return bool
 *   TRUE if check passes FALSE if not
 */
function stanford_capx_files_dir_exists() {
  $dir = STANFORD_CAPX_FILE_PATH;

  // Ensure the modules' private files directory exists and is writable.
  if (variable_get('file_private_path', FALSE) && file_prepare_directory($dir, FILE_CREATE_DIRECTORY)) {
    return TRUE;
  }

  // Display an error to the user.
  $summary = t('The !directory must be configured for the CAPx module to work correctly.',
    array('!directory' => l(t('private files directory'), 'admin/config/media/file-system')));
  drupal_set_message($summary, 'error');

  return FALSE;
}

/**
 * Implements hook_init().
 *
 * Shows error messages to admin user on admin pages.
 */
function stanford_capx_init() {
  $path = current_path();
  if (user_access('administer capx') && path_is_admin($path) && $path != 'batch') {
    // We don't want to set message on some forms
    // submission because message get set before it's processed in the submit
    // handler and this can confuse a user if this mapper was the last one that
    // was affected by issue specified in the message.
    $forms = array(
      'stanford_capx_importer_form',
      'stanford_capx_mapper_form',
    );
    if (empty($_POST['form_id']) || !in_array($_POST['form_id'], $forms)) {
      $messages = variable_get('stanford_capx_admin_messages', array());
      foreach ($messages as $key => $message) {
        $formatted_message = format_string(
          $message['text'],
          isset($message['message_vars']) ? $message['message_vars'] : NULL
        );
        drupal_set_message($formatted_message, 'error', FALSE);
      }
    }
  }
}

/**
 * Sync profile page callback.
 *
 * Do profile synchronization in enforcing mode.
 *
 * @param int $profile_id
 *   Profile ID to sync.
 * @param string $importer
 *   Importer machine name.
 */
function stanford_capx_profile_update($profile_id, $importer) {

  $importer = CAPxImporter::loadEntityImporter($importer);
  if (!$importer || !$importer->valid()) {
    drupal_set_message(t('There was an error in importer validation.'));
    return FALSE;
  }

  $client = $importer->getClient();

  $profile = $client->api('profile')->get($profile_id);

  // Allow altering of the results.
  drupal_alter('capx_preprocess_profile_update', $profile, $importer);

  $mapper = $importer->getMapper();

  $processor = new EntityProcessor($mapper, $profile);
  $processor->setEntityImporter($importer);
  $processor->skipEtagCheck(TRUE);
  $processor->execute(TRUE);

  $message = $processor->getStatusMessage();

  drupal_set_message($message);

  // Log some information.
  watchdog('stanford_capx_profile_force_update', check_plain($message) . " | " . check_plain($profile['displayName']), array(), WATCHDOG_INFO);
  drupal_goto();
}

/**
 * Page callback for changing profile sync status.
 *
 * @param int $id
 *   Internal profile ID.
 *
 * @param string $sync
 *   Synchronization operation. One from 'enable', 'disable'.
 */
function stanford_capx_profile_sync_status($id, $sync) {
  $sync_value = NULL;
  $message = "";

  switch ($sync) {
    case 'enable':
      $sync_value = 1;
      $message = t("Automatic updates ENABLED for this profile.");
      break;

    case 'disable':
      $sync_value = 0;
      $message = t("Automatic updates DISABLED for this profile.");
      break;
  }

  if (isset($sync_value)) {
    db_update('capx_profiles')
      ->condition('id', $id)
      ->fields(array('sync' => $sync_value))
      ->execute();
  }

  drupal_set_message($message, "status");
  drupal_goto();
}

/**
 * Implements hook_form_BASE_FORM_ID_alter().
 */
function stanford_capx_form_user_profile_form_alter(&$form, &$form_state) {
  global $user;
  // Disable deletion of users synced from CAP.
  if ($user->uid != 1 && isset($form_state['user']->capx) && !empty($form_state['user']->capx['sync'])) {
    $form['actions']['cancel']['#disabled'] = TRUE;
  }
}

/**
 * Implements hook_form_BASE_FORM_ID_alter().
 */
function stanford_capx_form_taxonomy_form_term_alter(&$form, &$form_state) {
  global $user;
  // Disable deletion of taxonomy terms synced from CAP.
  if ($user->uid != 1 && isset($form_state['term']->capx) && !empty($form_state['term']->capx['sync'])) {
    $form['actions']['delete']['#disabled'] = TRUE;
  }
}