field_validation_report.module

<?php

/**
 * @file
 * Code for the Field Validation Report module.
 */

include_once 'field_validation_report.forms.inc';

/**
 * Implements hook_menu().
 */
function field_validation_report_menu() {
  $return = array();

  $return['admin/reports/field-validation-report'] = array(
    'title' => 'Field Validation Report',
    'description' => 'Provides a report of all entities that do not pass field validation.',
    'page callback' => 'field_validation_report_page',
    'access arguments' => array('view field validation report'),
    'file' => 'field_validation_report.pages.inc',
    'type' => MENU_NORMAL_ITEM,
  );

  $return['admin/config/system/field-validation-report'] = array(
    'title' => 'Field Validation Report',
    'description' => 'Provides configuration options for Field Validation Report.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('field_validation_report_config'),
    'access arguments' => array('administer field validation report'),
    'file' => 'field_validation_report.admin.inc',
    'type' => MENU_NORMAL_ITEM,
  );

  return $return;
}

/**
 * Implements hook_permission().
 */
function field_validation_report_permission() {
  return array(
    'view field validation report' => array(
      'title' => t('View the Field Validation Report'),
      'description' => t('Allows the user to view the field validation report.'),
    ),
    'administer field validation report' => array(
      'title' => t('Administer Field Validation Report'),
      'description' => t('Allow the user to administer the configuration for field validation report.'),
    ),
  );
}

/**
 * Identify whether an entity type is capable of being validated.
 *
 * In order to be capable of appearing in the field validation report,
 * an entity type must be fieldable, and may not be a configuration entity.
 *
 * @param string $entity_type
 * @param array $entity_info
 *
 * @return bool
 */
function field_validation_report_entity_type_is_suitable($entity_type, $entity_info = array()) {
  $suitable = TRUE;

  // If the entity info was not passed along, load it.
  if (empty($entity_info)) {
    $entity_info = entity_get_info($entity_type);
  }

  // Configuration entities may not be validated.
  if (isset($entity_info['configuration']) && $entity_info['configuration'] == TRUE) {
    $suitable = FALSE;
  }

  // Entities must have bundles.
  elseif (empty($entity_info['bundles'])) {
    $suitable = FALSE;
  }

  // The entity type must be fieldable.
  elseif (empty($entity_info['fieldable'])) {
    $suitable = FALSE;
  }

  // Trigger hook_field_validation_report_entity_type_is_supported_alter() to allow other
  // modules to either enable or disable certain entity types.
  drupal_alter('field_validation_report_entity_type_is_supported', $suitable, $entity_type, $entity_info);

  return $suitable;
}

/**
 * Check whether the requested entity type (and bundle) is enabled.
 *
 * By default the entities are disabled, only certain entities will have been
 * enabled during installation. If an entity type is enabled it is assumed that
 * the entity bundles will also be enabled by default.
 *
 * @param string $entity_type
 *   The entity type.
 * @param string $bundle
 *   The bundle name.
 *
 * @return mixed
 *   TRUE/FALSE if checking a single entity type/bundle is enabled.
 *   Otherwise, a full array of entity types and bundles indicating
 *   whether they are enabled.
 *
 * @see field_validation_report_entity_type_is_suitable().
 */
function field_validation_report_entities_enabled($entity_type = NULL, $bundle = NULL) {
  $entity_types = &drupal_static(__FUNCTION__);

  // Identify which entities & bundles are supported the first time the
  // function is called.
  if (!isset($entity_types)) {
    foreach (entity_get_info() as $entity_name => $entity_info) {
      // Verify that this entity type is suitable.
      $entity_types[$entity_name] = field_validation_report_entity_type_is_suitable($entity_name, $entity_info);

      // The entity type technically supports validation.
      if (!empty($entity_types[$entity_name])) {
        // Entity types are enabled by default.
        // Allow entities to be disabled by assigning a variable
        // 'field_validation_report_enable_{$entity_type}' the value FALSE.
        if (variable_get('field_validation_report_enable_' . $entity_name, FALSE) == FALSE) {
          $entity_types[$entity_name] = FALSE;
        }

        // Check each bundle.
        else {
          $entity_types[$entity_name] = array();
          foreach ($entity_info['bundles'] as $bundle_name => $bundle_info) {
            // Allow bundles to be disabled by assigning a variable
            // 'field_validation_report_enable_{$entity_type}__{$bundle}' the value FALSE, e.g.:
            if (count($entity_info['bundles']) > 1 && variable_get('field_validation_report_enable_' . $entity_name . '__' . $bundle_name, TRUE) == FALSE) {
              $entity_types[$entity_name][$bundle_name] = FALSE;
            }
            else {
              $entity_types[$entity_name][$bundle_name] = TRUE;
            }
          }
        }
      }
    }
  }

  // It was requested to check a specific entity.
  if (isset($entity_type)) {
    // It was also requested to check a specific bundle for this entity.
    if (isset($bundle)) {
      $supported = !empty($entity_types[$entity_type][$bundle]);
    }

    // Check the entity.
    else {
      $supported = !empty($entity_types[$entity_type]);
    }

    return $supported;
  }

  // If nothing specific was requested, return the complete list of
  // entities & bundles indicating whether they are supported.
  return $entity_types;
}

/**
 * Helper function to run all enabled validations.
 */
function field_validation_report_run_validations() {
  // Clear the cache.
  $errors = cache_get('field_validation_report_errors');
  if (!empty($errors->data)) {
    cache_clear_all('field_validation_report_errors', 'cache');
  }

  // Loop over configuration, if bundle is enabled then run the validations.
  foreach (field_validation_report_entities_enabled() as $entity_type => $bundles) {
    if (!$bundles) {
      continue;
    }

    foreach ($bundles as $bundle_name => $bundle_enabled) {
      if (!$bundle_enabled) {
        continue;
      }

      _field_validation_report_validate_bundle($entity_type, $bundle_name);
    }
  }

  $errors = _field_validation_report_get_errors();
  cache_set('field_validation_report_errors', $errors);
}

/**
 * Stores the current collected error messages in a static variable.
 *
 * @return array
 *   An array of errors collected through the validations, keyed by
 *   entity type, bundle name and entity id.
 *   e.g $errors['node']['page'][1] = 'the error';
 */
function &_field_validation_report_get_errors() {
  $errors = cache_get('field_validation_report_errors');

  if ($errors) {
    return $errors->data;
  }

  $errors = &drupal_static(__FUNCTION__, array());
  return $errors;
}

/**
 * Validates an entity type.
 *
 * Runs the validation functions for all entities of this type.
 * To view the errors you will need to call
 * _field_validation_report_get_errors();
 *
 * @param string $entity_type
 *   The machine name of the entity type, e.g `node`
 */
function _field_validation_report_validate_entity_type($entity_type) {
  $entity_type_info = entity_get_info($entity_type);

  foreach ($entity_type_info['bundles'] as $bundle_name => $bundle) {
    _field_validation_report_validate_bundle($entity_type, $bundle_name);
  }
}

/**
 * Validates a bundle of an entity type.
 *
 * Runs the validation functions for the specified bundle
 * of this entity type.
 * To view the errors you will need to call
 * _field_validation_report_get_errors();
 *
 * @param string $entity_type
 *   The machine name of the entity type, e.g `node`
 * @param string $bundle_name
 *   The machine name of the bundle, e.g `page`
 */
function _field_validation_report_validate_bundle($entity_type, $bundle_name) {
  $entity_type_info = entity_get_info($entity_type);

  $query = new \EntityFieldQuery();
  $query->entityCondition('entity_type', $entity_type);
  if (count($entity_type_info['bundles']) > 1) {
    $query->entityCondition('bundle', $bundle_name);
  }

  if ($entity_type == 'comment') {
    $query->addTag('comment_bundle_fix');
  }

  $results = $query->execute();

  if (!empty($results[$entity_type])) {
    $entities = entity_load($entity_type, array_keys($results[$entity_type]));
    foreach ($entities as $entity) {
      _field_validation_report_validate_entity($entity_type, $entity);
    }
  }
}

/**
 * Validates a particular entity.
 *
 * Runs the validation functions for a particular entity.
 * To view the errors you will need to call
 * _field_validation_report_get_errors();
 *
 * @param string $entity_type
 *   The machine name of the entity type, e.g `node`
 * @param stdClass $entity
 *   The entity object to validate.
 */
function _field_validation_report_validate_entity($entity_type, $entity) {
  $errors = &_field_validation_report_get_errors();

  list($entity_id, $revision_id, $bundle_name) = entity_extract_ids($entity_type, $entity);

  $form_state = array(
    'programmed' => TRUE,
    'build_info' => array(
      'args' => array(
        0 => $entity_type,
        1 => &$entity,
      ),
    ),
    'triggering_element' => array(
      '#parents' => array(),
      '#limit_validation_errors' => FALSE,
    ));

  $form = drupal_build_form('field_validation_report_pseudo_form', $form_state);
  field_attach_form_validate($entity_type, $entity, $form, $form_state);

  // Report errors.
  $form_errors = form_get_errors();
  // Setup errors array if not set.
  $errors['__count'] = 0;
  if (!isset($errors[$entity_type])) {
    $errors[$entity_type] = array();
    $errors[$entity_type]['__count'] = 0;
  }
  if (!isset($errors[$entity_type][$bundle_name])) {
    $errors[$entity_type][$bundle_name] = array();
    $errors[$entity_type][$bundle_name]['__count'] = 0;
  }
  if (!isset($errors[$entity_type][$bundle_name][$entity_id])) {
    $errors[$entity_type][$bundle_name][$entity_id] = array();
    $errors[$entity_type][$bundle_name][$entity_id]['__count'] = 0;
  }

  if (!empty($form_errors)) {
    foreach ($form_errors as $form_error) {
      $errors['__count']++;
      $errors[$entity_type]['__count']++;
      $errors[$entity_type][$bundle_name]['__count']++;
      $errors[$entity_type][$bundle_name][$entity_id]['__count']++;
      $errors[$entity_type][$bundle_name][$entity_id][] = $form_error;

      // Remove the error message created by this validation.
      $messages = drupal_get_messages('error', FALSE);
      foreach ($messages['error'] as $key => $message) {
        if ($message == $form_error) {
          unset($_SESSION['messages']['error'][$key]);
        }
      }
    }
  }

  // Prevent duplicate error messages.
  form_clear_error();

  // Prevent blank error message.
  if (empty($_SESSION['messages']['error'])) {
    unset($_SESSION['messages']['error']);
  }
}

/**
 * Implements hook_TAG_query_alter().
 *
 * Fix until https://www.drupal.org/node/2581225 is committed.
 * As bundles do not specify a bundle column in the comment schema,
 * EntityFieldQuery throws a column not found error when attempting
 * to filter comment entities by bundle. This hook modifies the query
 * to correctly filter the comments by the bundle.
 */
function field_validation_report_query_comment_bundle_fix_alter(QueryAlterableInterface $query) {
  $query->innerJoin('node', NULL, 'comment.nid = node.nid');
  $conditions = &$query->conditions();
  $conditions[0]['field'] = 'node.type';
  $conditions[0]['value'] = str_replace('comment_node_', '', $conditions[0]['value']);
}