farm_plan.module

<?php

/**
 * @file
 * Farm plan - A farm plan entity type.
 */

// Include Features code.
include_once 'farm_plan.features.inc';

/****************************************************************
 * Drupal hooks
 * **************************************************************/

/**
 * Implements hook_permission().
 */
function farm_plan_permission() {
  $perms = array(
    'administer farm_plan module' => array(
      'title' => t('Administer farm plan module'),
      'description' => t('Gives full access to everything in the farm plan module.'),
      'restrict access' => TRUE,
    ),
    'administer farm_plan types' => array(
      'title' => t('Administer farm plan types'),
      'restrict access' => TRUE,
    ),
    'view farm plans' => array(
      'title' => t('View farm plans'),
      'description' => t('Allows users to view the full list of farm plans.'),
    ),
  );

  // Add permissions for each farm_plan type.
  foreach (farm_plan_types() as $farm_plan_type) {
    $type = $farm_plan_type->type;
    $ops = array('view', 'edit', 'delete');
    $scopes = array('any', 'own');
    $perms += array(
      "create $type farm plans" => array(
        'title' => t('Create new %type_name farm plans', array('%type_name' => $farm_plan_type->label)),
      ),
    );
    foreach ($ops as $op) {
      foreach ($scopes as $scope) {
        $perms += array(
          "$op $scope $type farm plans" => array(
            'title' => drupal_ucfirst($op) . ' ' . $scope . ' ' . t('%type_name farm plans', array('%type_name' => $farm_plan_type->label)),
          ),
        );
      }
    }
  }

  return $perms;
}

/**
 * Implements hook_menu().
 */
function farm_plan_menu() {
  $items = array();

  $items['farm/plan/add'] = array(
    'title' => 'Add plan',
    'page callback' => 'farm_plan_add_types_page',
    'access callback' => 'farm_plan_add_access',
    'file' => 'farm_plan.pages.inc',
  );
  foreach (farm_plan_types() as $type => $info) {
    $items['farm/plan/add/' . $type] = array(
      'title' => 'Add ' . $info->label,
      'page callback' => 'farm_plan_add',
      'page arguments' => array(3),
      'access callback' => 'farm_plan_access',
      'access arguments' => array('create', 3),
      'file' => 'farm_plan.pages.inc',
    );
  }

  $farm_plan_uri = 'farm/plan/%farm_plan';
  $farm_plan_uri_argument_position = 2;

  $items[$farm_plan_uri] = array(
    'title callback' => 'entity_label',
    'title arguments' => array('farm_plan', $farm_plan_uri_argument_position),
    'page callback' => 'farm_plan_view',
    'page arguments' => array($farm_plan_uri_argument_position),
    'access callback' => 'farm_plan_access',
    'access arguments' => array('view', $farm_plan_uri_argument_position),
    'file' => 'farm_plan.pages.inc',
  );

  $items[$farm_plan_uri . '/view'] = array(
    'title' => 'Plan',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );

  $items[$farm_plan_uri . '/delete'] = array(
    'title' => 'Delete plan',
    'title callback' => 'farm_plan_label',
    'title arguments' => array($farm_plan_uri_argument_position),
    'page callback' => 'drupal_get_form',
    'page arguments' => array('farm_plan_delete_form', $farm_plan_uri_argument_position),
    'access callback' => 'farm_plan_access',
    'access arguments' => array('update', $farm_plan_uri_argument_position),
    'file' => 'farm_plan.pages.inc',
  );

  $items[$farm_plan_uri . '/edit'] = array(
    'title' => 'Settings',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('farm_plan_form', $farm_plan_uri_argument_position),
    'access callback' => 'farm_plan_access',
    'access arguments' => array('update', $farm_plan_uri_argument_position),
    'file' => 'farm_plan.pages.inc',
    'type' => MENU_LOCAL_TASK,
    'context' => MENU_CONTEXT_PAGE | MENU_CONTEXT_INLINE,
    'weight' => 100,
  );

  // Form for removing a record from a plan.
  // This is the same as the form for deleting records (below), but it will not
  // delete records. It will only unlink them from the plan.
  $items[$farm_plan_uri . '/%/%/remove'] = array(
    'title' => 'Remove record',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('farm_plan_record_remove_form', $farm_plan_uri_argument_position, 3, 4),
    'access callback' => 'farm_plan_access',
    'access arguments' => array('update', $farm_plan_uri_argument_position),
    'file' => 'farm_plan.pages.inc',
    'type' => MENU_CALLBACK,
  );

  // Form for deleting a record from a plan.
  // This is the same as the form for removing records (above), but it also
  // gives the option to delete the record.
  $items[$farm_plan_uri . '/%/%/delete'] = array(
    'title' => 'Remove record',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('farm_plan_record_delete_form', $farm_plan_uri_argument_position, 3, 4),
    'access callback' => 'farm_plan_access',
    'access arguments' => array('update', $farm_plan_uri_argument_position),
    'file' => 'farm_plan.pages.inc',
    'type' => MENU_CALLBACK,
  );

  // Plan type delete form.
  $items['admin/config/farm/plan-types/%farm_plan_type/delete'] = array(
    'title' => 'Delete',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('farm_plan_type_form_delete_confirm', 4),
    'access arguments' => array('administer farm_plan types'),
    'weight' => 1,
    'type' => MENU_NORMAL_ITEM,
    'file' => 'farm_plan.admin.inc',
  );

  return $items;
}

/**
 * Implements hook_entity_info().
 */
function farm_plan_entity_info() {
  $return = array(
    'farm_plan' => array(
      'label' => t('Farm plan'),
      'entity class' => 'FarmPlan',
      'controller class' => 'FarmPlanController',
      'base table' => 'farm_plan',
      'fieldable' => TRUE,
      'entity keys' => array(
        'id' => 'id',
        'bundle' => 'type',
        'label' => 'name',
      ),
      'bundle keys' => array(
        'bundle' => 'type',
      ),
      'bundles' => array(),
      'load hook' => 'farm_plan_load',
      'view modes' => array(
        'full' => array(
          'label' => t('Default'),
          'custom settings' => FALSE,
        ),
      ),
      'label callback' => 'entity_class_label',
      'uri callback' => 'entity_class_uri',
      'module' => 'farm_plan',
      'access callback' => 'farm_plan_access',
    ),
  );
  $return['farm_plan_type'] = array(
    'label' => t('Farm plan type'),
    'entity class' => 'FarmPlanType',
    'controller class' => 'FarmPlanTypeController',
    'base table' => 'farm_plan_type',
    'fieldable' => FALSE,
    'bundle of' => 'farm_plan',
    'exportable' => TRUE,
    'entity keys' => array(
      'id' => 'id',
      'name' => 'type',
      'label' => 'label',
    ),
    'module' => 'farm_plan',
    // Enable the entity API admin UI.
    'admin ui' => array(
      'path' => 'admin/config/farm/plan-types',
      'file' => 'farm_plan.admin.inc',
      'controller class' => 'FarmPlanTypeUIController',
    ),
    'access callback' => 'farm_plan_type_access',
  );

  return $return;
}

/**
 * Implements hook_entity_info_alter().
 */
function farm_plan_entity_info_alter(&$entity_info) {
  foreach (farm_plan_types() as $type => $info) {
    $entity_info['farm_plan']['bundles'][$type] = array(
      'label' => $info->label,
      'admin' => array(
        'path' => 'admin/config/farm/plan-types/manage/%farm_plan_type',
        'real path' => 'admin/config/farm/plan-types/manage/' . $type,
        'bundle argument' => 5,
      ),
    );
  }
}

/**
 * Implements hook_entity_property_info_alter().
 */
function farm_plan_entity_property_info_alter(&$info) {
  $properties = &$info['farm_plan']['properties'];
  $properties['name'] = array(
    'label' => t('Name'),
    'description' => t('The name of the plan.'),
    'setter callback' => 'entity_property_verbatim_set',
    'schema field' => 'name',
  );
  $properties['type'] = array(
    'label' => t('Farm plan type'),
    'type' => 'token',
    'description' => t('The farm plan type.'),
    'setter callback' => 'entity_property_verbatim_set',
    'access callback' => 'farm_plan_properties_access',
    'options list' => 'farm_plan_type_get_names',
    'required' => TRUE,
    'schema field' => 'type',
  );
  $properties['uid'] = array(
    'label' => t('Owner'),
    'type' => 'user',
    'description' => t('The owner of the plan.'),
    'setter callback' => 'entity_property_verbatim_set',
    'access callback' => 'farm_plan_properties_access',
    'required' => TRUE,
    'schema field' => 'uid',
  );
  $properties['created'] = array(
    'label' => t('Created'),
    'type' => 'date',
    'description' => t('The timestamp when the plan was created.'),
    'setter callback' => 'entity_property_verbatim_set',
    'access callback' => 'farm_plan_properties_access',
    'required' => TRUE,
    'schema field' => 'created',
  );
  $properties['changed'] = array(
    'label' => t('Changed'),
    'type' => 'date',
    'description' => t('The timestamp when the plan was last modified.'),
    'setter callback' => 'entity_property_verbatim_set',
    'access callback' => 'farm_plan_properties_access',
    'required' => TRUE,
    'schema field' => 'changed',
  );
  $properties['active'] = array(
    'label' => t('Active'),
    'description' => t('Whether the plan is active.'),
    'setter callback' => 'entity_property_verbatim_set',
    'access callback' => 'farm_plan_properties_access',
    'schema field' => 'active',
    'type' => 'boolean',
  );
}

/**
 * Implements hook_field_extra_fields().
 */
function farm_plan_field_extra_fields() {
  $farm_plan_types = farm_plan_types();
  $extra_fields = array(
    'farm_plan' => array(),
  );
  foreach ($farm_plan_types as $type) {
    $extra_fields['farm_plan'][$type->type] = array(
      'form' => array(

        // Add plan name field to field UI.
        'name' => array(
          'label' => t('Name'),
          'description' => t('The name of the plan.'),
          'weight' => -10,
        ),
      ),
    );
  }
  return $extra_fields;
}

/**
 * Implements hook_entity_view().
 */
function farm_plan_entity_view($entity, $type, $view_mode, $langcode) {

  // If the entity is not a farm_plan, bail.
  if ($type != 'farm_plan') {
    return;
  }

  // Add the plan type.
  $plan_types = farm_plan_type_get_names();
  if (!empty($plan_types[$entity->type])) {
    $entity->content['type'] = array(
      '#markup' => '<div><strong>Plan type:</strong> ' . $plan_types[$entity->type] . '</div>',
      '#weight' => -101,
    );
  }

  // Add the plan's "active" status.
  if ($entity->active) {
    $status = 'Yes';
  }
  else {
    $status = 'No';
    drupal_set_message(t('This plan is no longer active. Inactive plans should be considered "archived" and should not be edited or deleted unless they contain information that is incorrect.'), 'warning');
  }
  $entity->content['active'] = array(
    '#markup' => '<div><strong>Active plan:</strong> ' . $status . '</div>',
    '#weight' => -100,
  );

  // Summarize areas and assets associated with the plan (logs will be added via
  // Views in hook_farm_ui_entity_views() below.
  $plan_areas = farm_plan_linked_records('area', $entity->id);
  if (!empty($plan_areas)) {
    $plan_area_links = array();
    foreach ($plan_areas as $area_id) {
      $area = taxonomy_term_load($area_id);
      $entity_label = entity_label('taxonomy_term', $area);
      $entity_uri = entity_uri('taxonomy_term', $area);
      $plan_area_links[] = l($entity_label, $entity_uri['path']);
    }
    $entity->content['farm_plan_areas'] = array(
      '#markup' => '<div><strong>Areas:</strong> ' . implode(', ', $plan_area_links) . '</div>',
    );
  }
  $plan_assets = farm_plan_linked_records('asset', $entity->id);
  if (!empty($plan_assets)) {
    $plan_asset_links = array();
    foreach ($plan_assets as $asset_id) {
      $asset = farm_asset_load($asset_id);
      $entity_label = entity_label('farm_asset', $asset);
      $entity_uri = entity_uri('farm_asset', $asset);
      $plan_asset_links[] = l($entity_label, $entity_uri['path']);
    }
    $entity->content['farm_plan_assets'] = array(
      '#markup' => '<div><strong>Assets:</strong> ' . implode(', ', $plan_asset_links) . '</div>',
    );
  }
}

/**
 * Implements hook_farm_ui_entity_views().
 */
function farm_plan_farm_ui_entity_views($entity_type, $bundle, $entity) {

  // If the entity is not a plan, bail.
  if (!($entity_type == 'farm_plan')) {
    return array();
  }

  // Display a View of logs associated with the plan.
  return array(
    'farm_plan_logs',
  );
}

/***************************************************************
 * Access functions
 * *************************************************************/

/**
 * Access callback for plan entities.
 *
 * @param string $op
 *   The operation being performed. One of 'view', 'update', 'create', 'delete'.
 * @param FarmPlan|string $farm_plan
 *   Optionally a specific plan entity to check.
 * @param object $account
 *   The user to check for. Leave it to NULL to check for the global user.
 *
 * @return bool
 *   Whether access is allowed or not.
 */
function farm_plan_access($op, $farm_plan = NULL, $account = NULL) {
  $rights = &drupal_static(__FUNCTION__, array());

  // If $op is not one of the supported ones, deny access.
  if (!in_array($op, array('create', 'view', 'update', 'delete'), TRUE)) {
    return FALSE;
  }
  // If no user object is supplied, the access check is for the current user.
  if (empty($account)) {
    global $user;
    $account = $user;
  }

  // If no plan is provided, check for access to all plans.
  if (empty($farm_plan)) {
    return user_access('view farm plans', $account);
  }

  // $farm_plan may be either an object or a plan type. Since plan types
  // cannot be an integer, use either id or type as the static cache id.
  $cid = is_object($farm_plan) ? $farm_plan->id : $farm_plan;

  // If we've already checked access for this plan, user and op, return from
  // cache.
  if (isset($rights[$account->uid][$cid][$op])) {
    return $rights[$account->uid][$cid][$op];
  }

  // If the user has 'administer farm_plan module' permission, grant them
  // access.
  if (user_access('administer farm_plan module', $account)) {
    $rights[$account->uid][$cid][$op] = TRUE;
    return TRUE;
  }

  // Check access to the plan based on it's type.
  $type = is_string($farm_plan) ? $farm_plan : $farm_plan->type;
  $farm_plan_types = farm_plan_types();
  $type_names = array();
  foreach ($farm_plan_types as $name => $farm_plan_type) {
    $type_names[] = $name;
  }
  if (in_array($type, $type_names)) {
    if ($op == 'create' && user_access('create ' . $type . ' farm plans', $account)) {
      $rights[$account->uid][$cid][$op] = TRUE;
      return TRUE;
    }

    if ($op == 'view') {
      if (user_access('view any ' . $type . ' farm plans', $account) || (user_access('view own ' . $type . ' farm plans', $account) && ($account->uid == $farm_plan->uid))) {
        $rights[$account->uid][$cid][$op] = TRUE;
        return TRUE;
      }
    }

    if ($op == 'update') {
      if (user_access('edit any ' . $type . ' farm plans', $account) || (user_access('edit own ' . $type . ' farm plans', $account) && ($account->uid == $farm_plan->uid))) {
        $rights[$account->uid][$cid][$op] = TRUE;
        return TRUE;
      }
    }

    if ($op == 'delete') {
      if (user_access('delete any ' . $type . ' farm plans', $account) || (user_access('delete own ' . $type . ' farm plans', $account) && ($account->uid == $farm_plan->uid))) {
        $rights[$account->uid][$cid][$op] = TRUE;
        return TRUE;
      }
    }
  }

  // If all else fails, deny access.
  return FALSE;
}

/**
 * Access callback: Checks whether the user has permission to add a plan.
 *
 * @param object|null $account
 *   The user account.
 *
 * @return bool
 *   TRUE if the user has add permission, otherwise FALSE.
 */
function farm_plan_add_access($account = NULL) {

  // If no user object is supplied, the access check is for the current user.
  if (empty($account)) {
    global $user;
    $account = $user;
  }

  // Check each of the plan types to see if the user has access.
  $types = farm_plan_types();
  foreach ($types as $type) {
    if (farm_plan_access('create', $type->type, $account)) {
      return TRUE;
    }
  }

  // If all else fails, deny access.
  return FALSE;
}

/**
 * Access callback for plan types.
 *
 * @param string $op
 *   The operation being performed.
 * @param FarmPlanType $farm_plan_type
 *   The farm plan entity.
 *
 * @return bool
 *   Returns true if the user has access.
 */
function farm_plan_type_access($op, FarmPlanType $farm_plan_type = NULL) {
  return user_access('administer farm_plan types');
}

/**
 * Access callback for farm_plan properties.
 */
function farm_plan_properties_access($op, $property, $entity = NULL, $account = NULL) {

  // Delegate to the general farm_plan access callback, based on the $op.
  switch ($op) {
    case 'view':
      return farm_plan_access('view', $entity, $account);
    case 'edit':
      return farm_plan_access('update', $entity, $account);
  }

  // Otherwise, deny access.
  return FALSE;
}

/***************************************************************
 * Farm plan API functions
 * *************************************************************/

/**
 * Load a plan.
 *
 * @param int $id
 *   The plan id.
 * @param bool $reset
 *   Whether or not to reset the entity cache.
 *
 * @return FarmPlan
 *   Returns a farm plan object.
 */
function farm_plan_load($id, $reset = FALSE) {
  $farm_plans = farm_plan_load_multiple(array($id), array(), $reset);
  return reset($farm_plans);
}

/**
 * Load multiple plans based on certain conditions.
 *
 * @param array $ids
 *   An array of farm plan ids.
 * @param array $conditions
 *   An array of entity load conditions.
 * @param bool $reset
 *   Whether or not to reset the entity cache.
 *
 * @return array
 *   Returns an array of farm plans.
 */
function farm_plan_load_multiple($ids = array(), $conditions = array(), $reset = FALSE) {
  return entity_load('farm_plan', $ids, $conditions, $reset);
}

/**
 * Save plan.
 *
 * @param FarmPlan $farm_plan
 *   The farm plan entity.
 */
function farm_plan_save(FarmPlan $farm_plan) {
  entity_save('farm_plan', $farm_plan);
}

/**
 * Delete single plan.
 *
 * @param FarmPlan $farm_plan
 *   The farm plan entity.
 */
function farm_plan_delete(FarmPlan $farm_plan) {
  entity_delete('farm_plan', entity_id('farm_plan', $farm_plan));
}

/**
 * Delete multiple plans.
 *
 * @param array $farm_plan_ids
 *   An array of farm plan ids.
 */
function farm_plan_delete_multiple(array $farm_plan_ids) {
  entity_delete_multiple('farm_plan', $farm_plan_ids);
}

/***************************************************************
 * Farm plan type API functions
 * *************************************************************/

/**
 * Load plan type.
 *
 * @param string $farm_plan_type
 *   The farm plan type.
 *
 * @return FarmPlanType
 *   Returns a farm plan type entity.
 */
function farm_plan_type_load($farm_plan_type) {
  return farm_plan_types($farm_plan_type);
}

/**
 * List of plan types.
 *
 * @param string $type_name
 *   The farm plan type name.
 *
 * @return FarmPlanType|array
 *   Returns either a single type, or an array of types.
 */
function farm_plan_types($type_name = NULL) {
  $types = entity_load_multiple_by_name('farm_plan_type', isset($type_name) ? array($type_name) : FALSE);
  return isset($type_name) ? reset($types) : $types;
}

/**
 * Save plan type entity.
 *
 * @param FarmPlanType $farm_plan_type
 *   The farm plan type entity.
 */
function farm_plan_type_save(FarmPlanType $farm_plan_type) {
  entity_save('farm_plan_type', $farm_plan_type);
}

/**
 * Delete single plan type.
 *
 * @param FarmPlanType $farm_plan_type
 *   The farm plan type entity.
 */
function farm_plan_type_delete(FarmPlanType $farm_plan_type) {
  entity_delete('farm_plan_type', entity_id('farm_plan_type', $farm_plan_type));
}

/**
 * Delete multiple plan types.
 *
 * @param array $farm_plan_type_ids
 *   An array of farm plan type ids.
 */
function farm_plan_type_delete_multiple(array $farm_plan_type_ids) {
  entity_delete_multiple('farm_plan_type', $farm_plan_type_ids);
}

/**
 * Get the names of all plan types.
 *
 * @return array
 *   Returns an array of plan type names, keyed by machine name.
 */
function farm_plan_type_get_names() {
  $names = array();
  $types = farm_plan_types();
  foreach ($types as $type) {
    $names[$type->type] = $type->label;
  }
  return $names;
}

/***************************************************************
 * Functions for linking/unlinking plans with other records.
 * *************************************************************/

/**
 * Load a list of records associated with a plan.
 *
 * @param string $record_type
 *   The record type (see farm_plan_record_relationships()).
 * @param int $plan_id
 *   The plan ID.
 *
 * @return array
 *   Returns an array of record IDs associated with the plan ID.
 */
function farm_plan_linked_records($record_type, $plan_id) {

  // Start an empty records array.
  $records = array();

  // If the plan ID is empty, bail.
  if (empty($plan_id)) {
    return;
  }

  // Get available relationships between plans and other record types.
  $relationships = farm_plan_record_relationships();

  // If a database table and field are not available, bail.
  if (empty($relationships[$record_type]['table']) || empty($relationships[$record_type]['field'])) {
    return;
  }

  // Get the table and field.
  $table = $relationships[$record_type]['table'];
  $field = $relationships[$record_type]['field'];

  // Query for record IDs.
  $query = db_select($table, 'r');
  $query->addField('r', $field);
  $query->condition('plan_id', $plan_id);
  $result = $query->execute();
  foreach ($result as $row) {
    if (!empty($row->{$field})) {
      $records[] = $row->{$field};
    }
  }

  // Return the record IDs.
  return $records;
}

/**
 * Link a plan to a record.
 *
 * @param string $record_type
 *   The record type (see farm_plan_record_relationships()).
 * @param int $plan_id
 *   The plan ID.
 * @param int $record_id
 *   The record ID.
 * @param array $primary_record
 *   If this is not the primary/required record type in the table, the primary
 *   record key/value to needed for updating the existing record.
 *   For example: array('asset_id' => 5)
 */
function farm_plan_link_record($record_type, $plan_id, $record_id, $primary_record = array()) {

  // First, delete any existing link.
  farm_plan_unlink_record($record_type, $plan_id, $record_id);

  // Get available relationships between plans and other record types.
  $relationships = farm_plan_record_relationships();

  // If a database table and field are not available, bail.
  if (empty($relationships[$record_type]['table']) || empty($relationships[$record_type]['field'])) {
    return;
  }

  // Get the table and field.
  $table = $relationships[$record_type]['table'];
  $field = $relationships[$record_type]['field'];

  // If this record type is not required, and a primary key/value is provided,
  // then update the existing relationship row.
  if ($relationships[$record_type]['required'] === FALSE && !empty($primary_record)) {
    $primary_record_key = key($primary_record);
    $primary_record_id = current($primary_record);
    $record = array(
      'plan_id' => $plan_id,
      $primary_record_key => $primary_record_id,
      $field => $record_id,
    );
    $primary_keys = array(
      'plan_id',
      $primary_record_key,
    );
    drupal_write_record($table, $record, $primary_keys);
  }

  // Otherwise create a new relationship row.
  else {
    $record = array(
      'plan_id' => $plan_id,
      $field => $record_id,
    );
    drupal_write_record($table, $record);
  }
}

/**
 * Unlink a plan from an area.
 *
 * @param string $record_type
 *   The record type (see farm_plan_record_relationships()).
 * @param int $plan_id
 *   The plan ID.
 * @param int $record_id
 *   The record ID.
 */
function farm_plan_unlink_record($record_type, $plan_id, $record_id) {

  // Get available relationships between plans and other record types.
  $relationships = farm_plan_record_relationships();

  // If a database table and field are not available, bail.
  if (empty($relationships[$record_type]['table']) || empty($relationships[$record_type]['field'])) {
    return;
  }

  // Get the table and field.
  $table = $relationships[$record_type]['table'];
  $field = $relationships[$record_type]['field'];

  // If this record type is not required, simply update the relationship row in
  // the database to remove reference to the record.
  if ($relationships[$record_type]['required'] === FALSE) {
    $query = db_update($table);
    $query->fields(array(
      $field => NULL,
    ));
    $query->condition('plan_id', $plan_id);
    $query->condition($field, $record_id);
    $query->execute();
  }

  // Otherwise, delete the whole relationship row.
  else {
    $query = db_delete($table);
    $query->condition('plan_id', $plan_id);
    $query->condition($field, $record_id);
    $query->execute();
  }
}

/**
 * Defines available relationships between plans and other record types.
 *
 * @return array
 *   Returns an array of record types with the database table and field names
 *   used to store relationships. See farm_plan.api.php.
 */
function farm_plan_record_relationships() {

  // Ask modules for relationships.
  $relationships = module_invoke_all('farm_plan_record_relationships');

  // Set default values.
  foreach ($relationships as &$relationship) {
    if (!isset($relationship['required'])) {
      $relationship['required'] = TRUE;
    }
  }

  // Return the relationships.
  return $relationships;
}

/**
 * Implements hook_farm_plan_record_relationships().
 */
function farm_plan_farm_plan_record_relationships() {
  return array(
    'area' => array(
      'label' => t('Area'),
      'entity_type' => 'taxonomy_term',
      'entity_type_table' => 'taxonomy_term_data',
      'entity_pk' => 'tid',
      'table' => 'farm_plan_area',
      'field' => 'area_id',
    ),
    'asset' => array(
      'label' => t('Asset'),
      'entity_type' => 'farm_asset',
      'entity_pk' => 'id',
      'table' => 'farm_plan_asset',
      'field' => 'asset_id',
    ),
    'log' => array(
      'label' => t('Log'),
      'entity_type' => 'log',
      'entity_pk' => 'id',
      'table' => 'farm_plan_log',
      'field' => 'log_id',
    ),
    'user' => array(
      'label' => t('User'),
      'entity_type' => 'user',
      'entity_pk' => 'uid',
      'table' => 'farm_plan_user',
      'field' => 'user_id',
    ),
  );
}

/**
 * Implements hook_entity_view_alter().
 */
function farm_plan_entity_view_alter(&$build, $type) {

  // Get the entity ID. Bail if not found.
  $entity_id = NULL;
  if (!empty($build['#entity'])) {
    $entity_id = entity_id($type, $build['#entity']);
  }
  elseif (!empty($build['#term'])) {
    $entity_id = entity_id($type, $build['#term']);
  }
  if (empty($entity_id)) {
    return;
  }

  // Get available relationships between plans and other record types.
  $relationships = farm_plan_record_relationships();

  // Iterate through the relationships to find a matching record type.
  $record_type = '';
  foreach ($relationships as $relationship => $info) {
    if ($type == $info['entity_type']) {
      $record_type = $relationship;
      break;
    }
  }

  // If a record type wasn't found, bail.
  if (empty($record_type)) {
    return;
  }

  // Find plan(s) that this entity is associated with.
  $query = 'SELECT plan_id FROM {' . $relationships[$record_type]['table'] . '} WHERE ' . $relationships[$record_type]['field'] . ' = :entity_id';
  $args = array(':entity_id' => $entity_id);
  $result = db_query($query, $args);
  $plan_ids = array();
  foreach ($result as $row) {
    if (!empty($row->plan_id)) {
      $plan_ids[] = $row->plan_id;
    }
  }

  // Iterate through the plans.
  foreach ($plan_ids as $plan_id) {

    // Load the plan.
    $plan = farm_plan_load($plan_id);

    // Get the plan URL and name.
    $plan_uri = entity_uri('farm_plan', $plan);
    $plan_path = $plan_uri['path'];
    $plan_name = entity_label('farm_plan', $plan);

    // Set a message pointing to the plan.
    $args = array(
      '@record_type' => $relationships[$record_type]['label'],
      '!plan_path' => url($plan_path),
      '%plan_name' => $plan_name,
    );
    $message = t('This @record_type is part of the plan: <a href="!plan_path">%plan_name</a>', $args);
    drupal_set_message($message);
  }
}

/**
 * Implements hook_entity_update().
 */
function farm_plan_entity_update($entity, $type) {

  // If a plan is made inactive, archive all assets linked to it, and vice
  // versa.
  if ($type != 'farm_plan') {
    return;
  }
  if (!(isset($entity->original) && isset($entity->original->active))) {
    return;
  }
  if ($entity->active == $entity->original->active) {
    return;
  }
  if (empty($entity->active)) {
    $archived = REQUEST_TIME;
  }
  else {
    $archived = FALSE;
  }
  $asset_ids = farm_plan_linked_records('asset', $entity->id);
  foreach ($asset_ids as $asset_id) {
    $asset = farm_asset_load($asset_id);
    if ($asset->archived != $archived) {
      $asset->archived = $archived;
      farm_asset_save($asset);

      // If the asset was archived, set a message.
      if (!empty($archived)) {
        $asset_label = entity_label('farm_asset', $asset);
        $asset_uri = entity_uri('farm_asset', $asset);
        $message = t('The asset <a href="!asset_path">%asset_label</a> has been archived.', array('!asset_path' => url($asset_uri['path']), '%asset_label' => $asset_label));
        drupal_set_message($message);
      }
    }
  }
}

/**
 * Implements hook_entity_delete().
 */
function farm_plan_entity_delete($entity, $type) {

  // Get the entity ID, and skip if it couldn't be found.
  $entity_id = entity_id($type, $entity);
  if (empty($entity_id)) {
    return;
  }

  // If the entity ID is not numeric, bail.
  if (!is_numeric($entity_id)) {
    return;
  }

  // Get available relationships between plans and other record types.
  $relationships = farm_plan_record_relationships();

  // Make a list of relationships indexed by entity type.
  $entity_types = array();
  foreach ($relationships as $relationship => $info) {
    if (!empty($info['entity_type'])) {
      $entity_types[$info['entity_type']][] = $relationship;
    }
  }

  // If a related entity type is being deleted, delete any references to that
  // entity in the relationship table.
  // In theory, this shouldn't happen because farm_constraint prevents entities
  // from being deleted that are linked to plans. But, it could still happen via
  // an uninformed call to entity_delete(), so we have this logic here to
  // handle cleanup regardless.
  if (array_key_exists($type, $entity_types)) {
    foreach ($entity_types[$type] as $relationship) {

      // Get information about the relationship.
      $info = $relationships[$relationship];

      // If it doesn't have a table, or a field, skip it.
      if (empty($info['table']) || empty($info['field'])) {
        continue;
      }

      // Delete all references to this plan in the table.
      db_query('DELETE FROM {' . $info['table'] . '} WHERE ' . $info['field'] . ' = :entity_id', array(':entity_id' => $entity_id));
    }
  }

  // If a plan is being deleted, remove references from all relationship tables.
  elseif ($type == 'farm_plan') {
    foreach ($relationships as $relationship => $info) {

      // If it doesn't have a table, skip it.
      if (empty($info['table'])) {
        continue;
      }

      // Delete all references to this plan in the table.
      db_query('DELETE FROM {' . $info['table'] . '} WHERE plan_id = :plan_id', array(':plan_id' => $entity_id));
    }
  }
}