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');
define('STANFORD_CAPX_ENCRYPT_PROFILE', 'stanford_capx_aes_ssl');

/**
 * 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 Configure 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_features_api().
 *
 * Define the components that we want to make exportable, in this case
 * CFE Entities.
 */
function stanford_capx_features_api() {
  return array(
    'capx_cfe' => array(
      'name' => 'CAPx Mappers & Importers',
      // CANNOT implement file as it conflicts with entity API.
      // 'file' => drupal_get_path('module', 'stanford_capx') . '/stanford_capx.features.inc',
      'feature_source' => TRUE,
      // Can't seem to get the below setting to work. Ctools is not loading it
      // and the default hook never gets fired.
      // 'default_file' => FEATURES_DEFAULTS_INCLUDED,
      'default_hook' => 'default_capx_cfe',
    ),
  );
}

/**
 * Something is wrong here.
 *
 * This is a patch up function for duplication on the component array.
 */
function stanford_capx_features_api_alter(&$components) {

  // It seems that the Entity API is fighting with me and is duplicating my
  // efforts here. Pop off my items in the array.

  if (!isset($components['capx_cfe'])) {
    return;
  }

  foreach ($components['capx_cfe'] as $key => $value) {
    if (is_array($value)) {
      $components['capx_cfe'][$key] = array_pop($value);
    }
  }

}

/**
 * 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...

  // Exportables / Presets
  // ---------------------------------------------------------------------------

  $items['admin/config/capx/preset/export/%/%'] = array(
    'title' => 'Export Configuration',
    'page callback' => 'stanford_capx_preset_export',
    'page arguments' => array(5, 6),
    'access arguments' => array(
      'capx advanced administrator',
    ),
    'type' => MENU_CALLBACK,
  );

  $items['admin/config/capx/preset/revert/%/%'] = array(
    'title' => 'Export Configuration',
    'page callback' => 'stanford_capx_preset_revert',
    'page arguments' => array(5, 6),
    'access arguments' => array(
      'capx advanced administrator',
    ),
    'type' => MENU_CALLBACK,
  );

  $items['admin/config/capx/preset/import'] = array(
    'title' => 'Import Configuration',
    'page callback' => 'stanford_capx_preset_import',
    'access arguments' => array(
      'capx advanced administrator',
    ),
    'type' => MENU_CALLBACK,
  );

  // 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', 240),
    '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', 240),
    '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
// /////////////////////////////////////////////////////////////////////////////

// FEATURES & CTOOLS
// /////////////////////////////////////////////////////////////////////////////

/**
 * Implements hook_features_export().
 */
function stanford_capx_features_export($data, &$export, $module_name) {
  $pipe = array();

  $export['dependencies']['stanford_capx'] = 'stanford_capx';
  foreach ($data as $component) {
    $export['features']['stanford_capx'][$component] = $component;
  }

  return $pipe;
}

// 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);

  // If profile is not an array that means it is no longer in the API and should
  // be an orphan.
  if (!is_array($profile)) {
    watchdog('stanford_capx_profile_force_update', "Could not fetch information from the API.", array(), WATCHDOG_INFO);
    drupal_set_message(t("FAILED to update. Could not fetch information from the API. Please check that the profile exists."), 'error');
    drupal_goto();
    return;
  }

  // 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;
  }
}

// IMPORT / EXPORT / PRESETS
// /////////////////////////////////////////////////////////////////////////////

/**
 * [stanford_capx_preset_export description]
 * @param  [type] $type         [description]
 * @param  [type] $machine_name [description]
 * @return [type]               [description]
 */
function stanford_capx_preset_export($type, $machine_name) {
  $output = array();
  $code = "";
  $cfe = capx_cfe_load_by_machine_name($machine_name, $type);

  // Failed to load. Show a 404.
  if (!$cfe) {
    drupal_not_found();
    return;
  }

  $object_title = $cfe->title;
  if (is_array($cfe->settings)) {
    foreach ($cfe->settings as $key => $v) {
      unset($cfe->{$key});
    }
  }
  $code = entity_export('capx_cfe', $cfe);
  unset($cfe->uid);
  unset($cfe->created);
  unset($cfe->changed);

  $output['ctools'] = drupal_get_form('ctools_export_form', $code, $object_title);
  return $output;
}

/**
 * [stanford_capx_exportables_import description]
 * @return [type] [description]
 */
function stanford_capx_preset_import() {
  $output = array();
  $output['import'] = drupal_get_form('stanford_capx_preset_import_form');
  return $output;
}

/**
 * [stanford_capx_preset_import_form description]
 * @param [type] $form       [description]
 * @param [type] $form_state [description]
 */
function stanford_capx_preset_import_form($form, &$form_state) {

  $form['code'] = array(
    '#title' => t('Code'),
    '#description' => t('Paste the code from the export in to this field.'),
    '#type' => 'textarea',
    '#rows' => 20,
    '#default_value' => isset($form_state['values']['code']) ? $form_state['values']['code'] : "",
  );

  $form['override'] = array(
    '#type' => 'checkbox',
    '#title' => t('Replace existing.'),
    '#description' => t('Check this box to override an existing preset on import.'),
  );

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Submit'),
  );

  return $form;
}

/**
 * Validate a few items before saving.
 * @param [type] $form       [description]
 * @param [type] $form_state [description]
 */
function stanford_capx_preset_import_form_validate($form, &$form_state) {

  // Try to convert the code in to an object.
  $code = $form_state['values']['code'];
  $item = entity_import('capx_cfe', $code);
  $info = entity_get_info();
  $entities = array_keys($info);
  $bundles = array();
  foreach ($info as $entity) {
    if (isset($entity['bundles'])) {
      $keys = array_keys($entity['bundles']);
      $bundles = array_merge($bundles, $keys);
    }
  }

  // Does the code turn in to an object?
  if (!is_object($item)) {
    form_set_error('code', "Invalid code supplied. Please check the syntax.");
    return;
  }

  // Check for a couple of fields...
  if (!isset($item->type) || !isset($item->machine_name)) {
    form_set_error('code', "Missing properties type or machine name");
    return;
  }

  // It is one of our bundles?
  if (!in_array($item->type, array_keys($bundles))) {
    form_set_error('code', "Invalid bundle type.");
    return;
  }

  // Does it already exist?
  if (!$form_state['values']['override']) {
    $exists = capx_cfe_load_by_machine_name($item->machine_name, $item->type);
    if ($exists) {
      form_set_error("code", "Cannot import. Item already exists. Please check the override option to force import.");
      return;
    }
  }

  // If importing an importer one must check for the existance of the mapper.
  if ($item->type == "importer") {
    $mapper = capx_cfe_load_by_machine_name($item->settings['mapper'], "mapper");
    if (!$mapper) {
      form_set_error("code", "Could not find the mapper: " . $item->settings['mapper'] . ". Please import that item first.");
      return;
    }
  }

  // MAPPER Validation.
  if ($item->type == "mapper") {

    // If it is a mapper validate that the entity and bundle is available.
    $info = entity_get_info($item->settings['entity_type']);
    if (!$info) {
      form_set_error("code", "Mapper entity type does not exist.");
      return;
    }

    if (!isset($info['bundles']) || !in_array($item->settings['bundle_type'], array_keys($info['bundles']))) {
      form_set_error("code", $item->settings['bundle_type'] . " bundle type does not exist.");
      return;
    }

  }

  // If there are filters that are attached ensure the module is enabled.
  if (isset($item->filters) && !module_exists("capx_filters")) {
    form_set_error("code", "This importer includes filters. Please enable the capx_filters module before importing.");
    return;
  }

  // If there are filters that are attached ensure the module is enabled.
  if (isset($item->tamper) && !module_exists("capx_tamper")) {
    form_set_error("code", "This mapper includes tampers. Please enable the capx_tamper module before importing.");
    return;
  }

}

/**
 * [stanford_capx_preset_import_form_submit description]
 * @param [type] $form       [description]
 * @param [type] $form_state [description]
 */
function stanford_capx_preset_import_form_submit($form, &$form_state) {
  $code = $form_state['values']['code'];
  $item = entity_import('capx_cfe', $code);

  if (!is_object($item)) {
    drupal_set_message("Could not import item.", "error");
    return;
  }

  // entity_import does not actually save the item.
  // Check to see if this is a replace or a new item.
  $cfe = capx_cfe_load_by_machine_name($item->machine_name, $item->type);
  if ($cfe) {
    capx_cfe_delete($cfe);
  }

  capx_cfe_save($item);
  drupal_set_message("Item imported successfully", "status");

  $form_state['redirect'] = "admin/config/capx/mapper";
}

/**
 * [stanford_capx_preset_revert description]
 * @param [type] $type         [description]
 * @param [type] $machine_name [description]
 */
function stanford_capx_preset_revert($type, $machine_name) {
  $output = array();
  $code = "";
  $cfe = capx_cfe_load_by_machine_name($machine_name, $type);

  // Failed to load. Show a 404.
  if (!$cfe) {
    drupal_not_found();
    return;
  }

  $output['form'] = drupal_get_form("stanford_capx_preset_revert_form", $type, $machine_name);

  return $output;
}

/**
 * [stanford_capx_preset_revert_form description]
 * @param [type] $form         [description]
 * @param [type] $form_sate    [description]
 * @param [type] $type         [description]
 * @param [type] $machine_name [description]
 */
function stanford_capx_preset_revert_form($form, $form_sate, $type, $machine_name) {

  $cfe = capx_cfe_load_by_machine_name($machine_name, $type);
  $label = $cfe->title;

  // Always save a few of these values.
  $form['bundle_type'] = array(
    '#type' => 'value',
    '#value' => $type,
  );

  $form['machine_name'] = array(
    '#type' => 'value',
    '#value' => $machine_name,
  );

  $form['label'] = array(
    '#type' => 'value',
    '#value' => $label,
  );

  $confirm_question = t('Are you sure you want to revert %label?', array('%label' => $label));
  return confirm_form($form, $confirm_question, "admin/config/capx/$type");
}

/**
 * [stanford_capx_preset_revert_submit description]
 * @param [type] $form       [description]
 * @param [type] $form_state [description]
 */
function stanford_capx_preset_revert_form_submit($form, $form_state) {
  $type = $form_state['values']['bundle_type'];
  $machine_name = $form_state['values']['machine_name'];
  $label = $form_state['values']['label'];

  $cfe = capx_cfe_load_by_machine_name($machine_name, $type);
  capx_cfe_delete($cfe);

  watchdog($type, 'Reverted %label to the defaults.', array('%label' => $label), WATCHDOG_NOTICE);
  drupal_set_message(t('Reverted %label to the defaults.', array('%label' => $label)), 'status');
}