apachesolr_attachments.module in Apache Solr Attachments 6.3

Provides a file attachment search implementation for use with the Apache Solr module

File

apachesolr_attachments.module

<?php

/**
 * @file
 * Provides a file attachment search implementation for use with the Apache Solr module
 */
define('EXTRACTING_SERVLET', 'extract/tika');

/**
 * Implements hook_menu().
 */
function apachesolr_attachments_menu() {
  $items = array();
  $items['admin/config/search/apachesolr/attachments'] = array(
    'title' => 'Attachments',
    'description' => 'Administer Apache Solr Attachments.',
    'page callback' => 'apachesolr_attachments_admin_page',
    'access arguments' => array(
      'administer search',
    ),
    'file' => 'apachesolr_attachments.admin.inc',
    'type' => MENU_LOCAL_TASK,
  );
  $items['admin/config/search/apachesolr/attachments/test'] = array(
    'title' => 'Test tika extraction',
    'page callback' => 'apachesolr_attachments_test_tika_extraction',
    'access arguments' => array(
      'administer search',
    ),
    'file' => 'apachesolr_attachments.admin.inc',
    'type' => MENU_CALLBACK,
  );
  $items['admin/config/search/apachesolr/attachments/confirm/delete'] = array(
    'title' => 'Delete and reindex all files',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'apachesolr_attachments_confirm',
      6,
    ),
    'access arguments' => array(
      'administer search',
    ),
    'file' => 'apachesolr_attachments.admin.inc',
    'type' => MENU_CALLBACK,
  );
  $items['admin/config/search/apachesolr/attachments/confirm/clear-cache'] = array(
    'title' => 'Delete the local cache of file text',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'apachesolr_attachments_confirm',
      6,
    ),
    'access arguments' => array(
      'administer search',
    ),
    'file' => 'apachesolr_attachments.admin.inc',
    'type' => MENU_CALLBACK,
  );
  return $items;
}

/**
 * @file
 *   Indexer for the userhook_apachesolr_entity_info_alter entities for the Apachesolr module.
 */
function apachesolr_attachments_apachesolr_entity_info_alter(&$entity_info) {
  $entity_info['file']['indexable'] = TRUE;
  $entity_info['file']['status callback'][] = 'apachesolr_attachments_status_callback';
  $entity_info['file']['document callback'][] = 'apachesolr_attachments_solr_document';
  $entity_info['file']['reindex callback'] = 'apachesolr_attachments_solr_reindex';
  $entity_info['file']['index_table'] = 'apachesolr_index_entities_file';
  $entity_info['file']['result callback'] = 'apachesolr_attachments_file_result';
}

/**
 * Builds the file-specific information for a Solr document.
 *
 * @param ApacheSolrDocument $document
 *   The Solr document we are building up.
 * @param stdClass $entity
 *   The entity we are indexing.
 * @param string $entity_type
 *   The type of entity we're dealing with.
 */
function apachesolr_attachments_solr_document(ApacheSolrDocument $document, $file, $entity_type, $env_id) {
  module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');
  $documents = array();
  $table = apachesolr_get_indexer_table('file');

  // Text is saved in the index table. Will be used by the node indexing if
  // available.
  $text = apachesolr_attachments_get_attachment_text($file);

  // If we don't have extracted text we should stop our process here
  if (empty($text)) {
    return $documents;
  }

  // Get the list of parents that we should index from the indexing table
  $parents = db_select($table, 'aie')
    ->fields('aie')
    ->condition('entity_type', 'file')
    ->condition('entity_id', $file->fid)
    ->execute();
  foreach ($parents as $parent) {

    // load the parent entity and reset cache
    $parent_entities = entity_load($parent->parent_entity_type, array(
      $parent->parent_entity_id,
    ), NULL, TRUE);
    $parent_entity = reset($parent_entities);

    // Skip invalid entities
    if (empty($parent_entity)) {
      continue;
    }

    // Retrieve the parent entity id and bundle
    list($parent_entity_id, $parent_entity_vid, $parent_entity_bundle) = entity_extract_ids($parent->parent_entity_type, $parent_entity);
    $parent_entity_type = $parent->parent_entity_type;

    // Get a clone of the bare minimum document
    $filedocument = clone $document;

    //Get the callback array to add stuff to the document
    $callbacks = apachesolr_entity_get_callback($parent_entity_type, 'document callback');

    // Skip invalid entity types
    if (empty($callbacks)) {
      continue;
    }
    $build_documents = array();
    foreach ($callbacks as $callback) {

      // Call a type-specific callback to add stuff to the document.
      $build_documents = array_merge($build_documents, $callback($filedocument, $parent_entity, $parent_entity_type, $env_id));
    }

    // Take the top document from the stack
    $filedocument = reset($build_documents);

    // Build our separate document and overwrite basic information
    $filedocument->id = apachesolr_document_id($file->fid . '-' . $parent_entity_type . '-' . $parent_entity_id, $entity_type);
    $filedocument->url = file_create_url($file->uri);
    $path = file_stream_wrapper_get_instance_by_uri($file->uri)
      ->getExternalUrl();

    // A path is not a requirement of an entity
    if (!empty($path)) {
      $filedocument->path = $path;
    }

    // Add extra info to our document
    $filedocument->label = apachesolr_clean_text($file->filename);
    $filedocument->content = apachesolr_clean_text($file->filename) . ' ' . $text;
    $filedocument->ds_created = apachesolr_date_iso($file->timestamp);
    $filedocument->ds_changed = $filedocument->ds_created;
    $filedocument->created = apachesolr_date_iso($file->timestamp);
    $filedocument->changed = $filedocument->created;

    // Add Parent information fields. See http://drupal.org/node/1515822 for explanation
    $parent_entity_info = entity_get_info($parent_entity_type);
    $small_parent_entity = new stdClass();
    $small_parent_entity->entity_type = $parent_entity_type;
    $small_parent_entity->{$parent_entity_info['entity keys']['id']} = $parent_entity_id;
    $small_parent_entity->{$parent_entity_info['entity keys']['bundle']} = $parent_entity_bundle;
    $small_parent_entity->{$parent_entity_info['entity keys']['label']} = $parent_entity->{$parent_entity_info['entity keys']['label']};

    // Add all to one field because if it is spread out over
    // multiple fields there is no way of knowing which multifield value
    // belongs to which entity
    // It does not load the complete entity in to the index because that
    // would dramatically increase the index size and processing time
    $filedocument->zm_parent_entity = drupal_json_encode($small_parent_entity);
    $filedocument->sm_parent_entity_bundle = $parent_entity_type . "-" . $parent_entity_bundle;
    $filedocument->sm_parent_entity_type = $parent_entity_type;

    // Add Apachesolr Attachments specific fields.
    $filedocument->ss_filemime = $file->filemime;
    $filedocument->ss_filesize = $file->filesize;
    $documents[] = $filedocument;
  }
  return $documents;
}

/**
 * Reindexing callback for ApacheSolr, for file entities.
 */
function apachesolr_attachments_solr_reindex() {
  module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');
  $indexer_table = apachesolr_get_indexer_table('file');
  $transaction = db_transaction();
  $env_id = apachesolr_default_environment();
  try {

    // Clean the table
    db_delete($indexer_table)
      ->condition('entity_type', 'file')
      ->isNull('body')
      ->execute();
    $files = _apachesolr_attachments_get_all_files();

    // If we do not have files, return success
    if (empty($files)) {
      return TRUE;
    }

    // Loop over all the files and add them to our indexing table
    foreach ($files as $parent_entity_type => $parent_entities) {
      foreach ($parent_entities as $parent_entity_info) {

        // Fake our file class
        $file = new stdClass();
        foreach ($parent_entity_info->extraFields as $key => $value) {
          if (strpos($key, '_fid')) {
            $file->fid = $parent_entity_info->extraFields->{$key};
          }
        }
        list($parent_entity_id) = entity_extract_ids($parent_entity_type, $parent_entity_info);
        apachesolr_attachments_add_file_usage($file, $parent_entity_type, $parent_entity_id);
      }
    }
  } catch (Exception $e) {
    $transaction
      ->rollback();
    drupal_set_message($e
      ->getMessage(), 'error');
    watchdog_exception('Apache Solr Attachments', $e);
    return FALSE;
  }
  return TRUE;
}

/**
 * Fetches all files linked to nodes created by fields from the file module
 * regardless of the widget
 * @return type
 */
function _apachesolr_attachments_get_all_files() {
  $results = array();
  $fields = field_info_field_by_ids();
  foreach ($fields as $field_id => $field_info) {
    if ($field_info['type'] == 'file') {
      foreach ($field_info['bundles'] as $entity_type => $bundles) {
        $entity_info = entity_get_info($entity_type);

        // If this entity type is not indexable, ignore this and move on to the
        // next one
        if (empty($entity_info['apachesolr']['indexable'])) {
          continue;
        }
        $query = new ApachesolrAttachmentsEntityFieldQuery();
        $results_query = $query
          ->entityCondition('entity_type', $entity_type)
          ->fieldCondition($field_info['field_name'])
          ->addExtraField($field_info['field_name'], 'fid', 'fid')
          ->execute();
        $results = array_merge_recursive($results, $results_query);
      }
    }
  }
  return $results;
}

/**
 * Status callback for the files. Files should never be removed from the table.
 * See apachesolr_attachments_apachesolr_exclude() for exclusion of items
 * @param type $entity_id
 * @param type $entity_type
 * @return type
 */
function apachesolr_attachments_status_callback($entity_id, $entity_type) {
  module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');

  // load the entity and reset cache
  $entities = entity_load($entity_type, array(
    $entity_id,
  ), NULL, TRUE);
  $entity = reset($entities);

  // Check if the mimetype is allowed
  if (apachesolr_attachments_allowed_mime($entity->filemime) == FALSE) {

    // Set status to 0 and remove from the index
    return FALSE;
  }

  // Check if the file is a real file
  if (apachesolr_attachments_is_file($entity) == FALSE) {

    // Set status to 0 and remove from the index
    return FALSE;
  }

  // Check if the entity status is active
  if ($entity->status != 1) {

    // Set status to 0 and remove from the index
    return FALSE;
  }

  // Keep status at 1
  return TRUE;
}

/**
 * Implenents hook_apachesolr_ENTITY_TYPE_exclude().
 *
 * This is invoked for each file entity that is being inspected to be added to the
 * index. if any module returns TRUE, the entity is skipped for indexing.
 *
 * @param integer $entity_id
 * @param integer $row
 *   A complete set of data from the indexing table.
 * @param string $env_id
 * @return boolean
 */
function apachesolr_attachments_apachesolr_file_exclude($entity_id, $row, $env_id) {
  module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');

  // Make sure we have a boolean value.
  // Anything different from 1 becomes zero
  if (!$entity_id || !$row->parent_entity_id) {

    // Exclude
    return TRUE;
  }

  // Check if the parent entity is excluded
  $parent_entity_id = $row->parent_entity_id;
  $parent_entity_type = $row->parent_entity_type;
  $exclude = apachesolr_attachments_is_parent_excluded($entity_id, 'file', $parent_entity_id, $parent_entity_type, $env_id);
  if ($exclude) {

    // Exclude
    return TRUE;
  }

  // Do not exclude
  return FALSE;
}
function apachesolr_attachments_is_file($entity) {
  if (!empty($entity->uri)) {
    $filepath = drupal_realpath($entity->uri);

    // Check that we have a valid filepath.
    if (!$filepath) {
      return FALSE;
    }
    elseif (!is_file($filepath)) {
      watchdog('Apache Solr Attachments', '%filepath is not a valid file path', array(
        '%filepath' => $entity->uri,
      ), WATCHDOG_WARNING);
      return FALSE;
    }
    else {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Excludes a file if the parent_entity is set to status 0 or it is not
 * being indexed
 * @param type $entity_id
 * @param type $entity_type
 * @return type
 */
function apachesolr_attachments_is_parent_excluded($entity_id, $entity_type, $parent_entity_id, $parent_entity_type, $env_id) {
  $query = new EntityFieldQuery();
  $result = $query
    ->entityCondition('entity_type', $parent_entity_type)
    ->entityCondition('entity_id', $parent_entity_id)
    ->execute();

  // We only need the class and 1 item;
  if (empty($result)) {

    // Parent entity id does not exist anymore
    return TRUE;
  }
  $values = array_values($result[$parent_entity_type]);

  // Since we only expect 1 eid to return, we are going to do
  // a reset of the array
  $stub_entity = reset($values);
  $parent_entity_bundle = $stub_entity->type;

  // Ignore this parent if the bundles to be indexed for this entity type
  // are not indexed
  $bundles = apachesolr_get_index_bundles($env_id, $parent_entity_type);
  if (empty($bundles)) {

    // Exclude it
    return TRUE;
  }
  else {
    if (!in_array($parent_entity_bundle, $bundles)) {

      // Exclude it
      return TRUE;
    }
  }

  // Skip indexing of files if the node was excluded by apache solr
  $status_callbacks = apachesolr_entity_get_callback($parent_entity_type, 'status callback');
  if (!empty($status_callbacks)) {

    // Set status to true. Allow the callbacks to make the change
    $status = TRUE;

    // Check status callback before sending to the index
    foreach ($status_callbacks as $status_callback) {
      if (is_callable($status_callback)) {

        // by placing $status in front we prevent calling any other callback
        // after one status callback returned false
        $status = $status && $status_callback($parent_entity_id, $parent_entity_type);
      }
    }

    // TRUE means the status is ok. We should return FALSE so it does
    // not exclude
    return !$status;
  }

  // Exclude by default
  return TRUE;
}

/**
 * For a particular entity, remove all file attachments from the Solr index.
 * This function is not in use in the module but can come in handy for people
 * that prefer to use functions
 *
 * @see apachesolr_delete_node_from_index()
 */
function apachesolr_attachments_remove_attachments_from_index($parent_entity_type, $parent_entity) {
  static $failed = FALSE;
  if ($failed) {
    return FALSE;
  }
  try {

    // Retrieve the parent entity id and bundle
    list($parent_entity_id, $parent_entity_vid, $parent_entity_bundle) = entity_extract_ids($parent_entity_type, $parent_entity);
    $solr = apachesolr_get_solr();
    $solr
      ->deleteByQuery("sm_parent_entity:{$parent_entity_type}-{$parent_entity_bundle}-{$parent_entity_id} AND entity_type:file AND hash:" . apachesolr_site_hash());
    $solr
      ->commit();
    return TRUE;
  } catch (Exception $e) {
    watchdog('Apache Solr Attachments', nl2br(check_plain($e
      ->getMessage())), NULL, WATCHDOG_ERROR);

    // Don't keep trying queries if they are failing.
    $failed = TRUE;
    return FALSE;
  }
}

/**
 * Implements hook_apachesolr_query_alter().
 */
function apachesolr_attachments_apachesolr_query_alter(DrupalSolrQueryInterface $query) {
  if ($query
    ->getName() == 'apachesolr') {

    // Fetch the extra file data on searches.
    $query
      ->addParam('fl', array(
      'zm_parent_entity',
      'ss_filemime',
      'ss_file_entity_title',
      'ss_file_entity_url',
    ));
  }
  elseif ($query
    ->getName() == 'apachesolr_mlt') {

    // Exclude files from MLT results.
    $query
      ->addFilter('entity_type', 'file', TRUE);
  }
}

/*
 * hook_entity_OP functions need to happen to clean up the table after files
 * were added to the index table
 */
function apachesolr_attachments_entity_update($entity, $type) {
  module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');
  apachesolr_attachments_clean_index_table();
}
function apachesolr_attachments_entity_insert($entity, $type) {
  apachesolr_attachments_entity_update($entity, $type);
}
function apachesolr_attachments_entity_delete($entity, $type) {
  module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');
  apachesolr_attachments_clean_index_table();
}

/**
 * Hook into the field operations
 *   - we want to save the same data in a shadow copy table for easier indexing.
 *   - We do not delete the file / media entity when its usage count goes to 0
 *     but instead we set status to  0.
 *   - This is meant to make the backport to drupal 6 easier
 */
function apachesolr_attachments_field_attach_insert($parent_entity_type, $parent_entity) {
  apachesolr_attachments_field_attach_update($parent_entity_type, $parent_entity);
}
function apachesolr_attachments_field_attach_update($parent_entity_type, $parent_entity) {

  // Not all entities sent through this function have the same
  // syntax and/or content. We only check entities that have a type.
  // This excludes comments, so if there would be a file entity atttached to
  // a comment, this would not be picked up.
  // TODO: If you are a entity magician, please improve
  if (isset($parent_entity->type)) {

    // Check if the deleted entity had a file attached
    foreach (field_info_instances($parent_entity_type, $parent_entity->type) as $instance) {
      $field_info = field_info_field($instance['field_name']);
      if ($field_info['type'] == 'file') {

        // Include the file after the if, otherwise it'll get included everywhere
        module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');
        $items = field_get_items($parent_entity_type, $parent_entity, $field_info['field_name']);
        foreach ($items as $file_info) {
          $file = file_load($file_info['fid']);

          // Discard empty entities
          if (empty($file)) {
            continue;
          }

          // Retrieve parent entity id and add its file usage
          list($parent_entity_id) = entity_extract_ids($parent_entity_type, $parent_entity);
          apachesolr_attachments_add_file_usage($file, $parent_entity_type, $parent_entity_id);
        }
      }
    }
  }
}
function apachesolr_attachments_field_attach_delete($parent_entity_type, $parent_entity) {

  // Not all entities sent through this function have the same
  // syntax and/or content. We only check entities that have a type.
  // This excludes comments, so if there would be a file entity atttached to
  // a comment, this would not be picked up.
  // TODO: If you are a entity magician, please improve
  if (isset($parent_entity->type)) {

    // Check if the deleted entity had a file attached
    foreach (field_info_instances($parent_entity_type, $parent_entity->type) as $instance) {
      $field_info = field_info_field($instance['field_name']);
      if ($field_info['type'] == 'file') {

        // Include the file after the if, otherwise it'll get included everywhere
        module_load_include('inc', 'apachesolr_attachments', 'apachesolr_attachments.index');
        $items = field_get_items($parent_entity_type, $parent_entity, $field_info['field_name']);
        foreach ($items as $file_info) {
          $file = file_load($file_info['fid']);

          // Discard empty entities
          if (empty($file)) {
            continue;
          }

          // Retrieve parent entity id and delete its file usage
          list($parent_entity_id) = entity_extract_ids($parent_entity_type, $parent_entity);
          apachesolr_attachments_delete_file_usage($file, $parent_entity_type, $parent_entity_id);
        }
      }
    }
  }
}

/**
 * Callback function for file search results.
 *
 * @param stdClass $doc
 *   The result document from Apache Solr.
 * @param array $result
 *   The result array for this record to which to add.
 */
function apachesolr_attachments_file_result($doc, &$result, &$extra) {
  $doc->uid = $doc->is_uid;
  $result += array(
    'type' => t('File attachment'),
    'user' => theme('username', array(
      'account' => $doc,
    )),
    'date' => isset($doc->created) ? $doc->created : 0,
    'node' => $doc,
    'file' => $doc,
    'uid' => $doc->is_uid,
  );
}

/**
 * Implements hook_theme().
 */
function apachesolr_attachments_theme() {
  return array(
    'apachesolr_search_snippets__file' => array(
      'variables' => array(
        'doc' => NULL,
        'snippets' => array(),
      ),
    ),
  );
}

/**
 * @todo Vastly improve this theming function
 * @param type $vars
 * @return type
 */
function theme_apachesolr_search_snippets__file($vars) {
  $doc = $vars['doc'];
  $snippets = $vars['snippets'];
  $parent_entity_links = array();

  // Retrieve our parent entities. They have been saved as
  // a small serialized entity
  foreach ($doc->zm_parent_entity as $parent_entity_encoded) {
    $parent_entity = (object) drupal_json_decode($parent_entity_encoded);
    $parent_entity_uri = entity_uri($parent_entity->entity_type, $parent_entity);
    $parent_entity_uri['options']['absolute'] = TRUE;
    $parent_label = entity_label($parent_entity->entity_type, $parent_entity);
    $parent_entity_links[] = l($parent_label, $parent_entity_uri['path'], $parent_entity_uri['options']);
  }
  if (module_exists('file')) {
    $file_type = t('!icon @filemime', array(
      '@filemime' => $doc->ss_filemime,
      '!icon' => theme('file_icon', array(
        'file' => (object) array(
          'filemime' => $doc->ss_filemime,
        ),
      )),
    ));
  }
  else {
    $file_type = t('@filemime', array(
      '@filemime' => $doc->ss_filemime,
    ));
  }
  return implode(' ... ', $snippets) . '<span>' . $file_type . ' <em>attached to:</em>' . implode(', ', $parent_entity_links) . '</span>';
}

/**
 * Provides a default list of filename extensions to exclude from the index.
 *
 * @return
 *   An array of file extensions.
 */
function apachesolr_attachments_default_excluded() {
  $default = array(
    'aif',
    'art',
    'avi',
    'bmp',
    'gif',
    'ico',
    'jpg',
    'mov',
    'mp3',
    'mp4',
    'mpg',
    'oga',
    'ogv',
    'png',
    'psd',
    'ra',
    'ram',
    'rgb',
    'tif',
    'wmv',
  );
  return $default;
}
class ApachesolrAttachmentsEntityFieldQuery extends EntityFieldQuery {

  // Extra added fields to the query
  private $addedFields = array();

  /**
   * Finishes the query.
   *
   * Adds tags, metaData, range and returns the requested list or count.
   *
   * @param SelectQuery $select_query
   *   A SelectQuery which has entity_type, entity_id, revision_id and bundle
   *   fields added.
   * @param $id_key
   *   Which field's values to use as the returned array keys.
   *
   * @return
   *   See EntityFieldQuery::execute().
   */
  function finishQuery($select_query, $id_key = 'entity_id') {
    foreach ($this->tags as $tag) {
      $select_query
        ->addTag($tag);
    }
    foreach ($this->metaData as $key => $object) {
      $select_query
        ->addMetaData($key, $object);
    }
    $select_query
      ->addMetaData('entity_field_query', $this);
    if ($this->range) {
      $select_query
        ->range($this->range['start'], $this->range['length']);
    }
    if ($this->count) {
      return $select_query
        ->countQuery()
        ->execute()
        ->fetchField();
    }
    $return = array();
    foreach ($this->addedFields as $addedField) {
      $fields = $select_query
        ->getFields();
      if (!empty($addedField['field_name'])) {
        $column = $addedField['field_name'] . '_' . $addedField['column'];
        $column_alias = $addedField['field_name'] . '_' . $addedField['column_alias'];
      }
      else {
        $column = $addedField['column'];
        $column_alias = $addedField['column_alias'];
      }
      $select_query
        ->addField($fields['entity_id']['table'], $column, $column_alias);
    }
    foreach ($select_query
      ->execute() as $partial_entity) {
      $bundle = isset($partial_entity->bundle) ? $partial_entity->bundle : NULL;
      $entity = entity_create_stub_entity($partial_entity->entity_type, array(
        $partial_entity->entity_id,
        $partial_entity->revision_id,
        $bundle,
      ));

      // This is adding the file id using our metaData field.
      $entity->extraFields = $partial_entity;

      //$entity->file_fid = $partial_entity->{$this->metaData['field_key']};
      $return[$partial_entity->entity_type][$partial_entity->{$id_key}] = $entity;
      $this->ordered_results[] = $partial_entity;
    }
    return $return;
  }
  public function addExtraField($field_name, $column, $column_alias = NULL) {
    $this->addedFields[] = array(
      'field_name' => $field_name,
      'column' => $column,
      'column_alias' => $column_alias,
    );
    return $this;
  }

}

Functions

Name	Description
apachesolr_attachments_apachesolr_entity_info_alter	@file Indexer for the userhook_apachesolr_entity_info_alter entities for the Apachesolr module.
apachesolr_attachments_apachesolr_file_exclude	Implenents hook_apachesolr_ENTITY_TYPE_exclude().
apachesolr_attachments_apachesolr_query_alter	Implements hook_apachesolr_query_alter().
apachesolr_attachments_default_excluded	Provides a default list of filename extensions to exclude from the index.
apachesolr_attachments_entity_delete
apachesolr_attachments_entity_insert
apachesolr_attachments_entity_update
apachesolr_attachments_field_attach_delete
apachesolr_attachments_field_attach_insert	Hook into the field operations
apachesolr_attachments_field_attach_update
apachesolr_attachments_file_result	Callback function for file search results.
apachesolr_attachments_is_file
apachesolr_attachments_is_parent_excluded	Excludes a file if the parent_entity is set to status 0 or it is not being indexed
apachesolr_attachments_menu	Implements hook_menu().
apachesolr_attachments_remove_attachments_from_index	For a particular entity, remove all file attachments from the Solr index. This function is not in use in the module but can come in handy for people that prefer to use functions
apachesolr_attachments_solr_document	Builds the file-specific information for a Solr document.
apachesolr_attachments_solr_reindex	Reindexing callback for ApacheSolr, for file entities.
apachesolr_attachments_status_callback	Status callback for the files. Files should never be removed from the table. See apachesolr_attachments_apachesolr_exclude() for exclusion of items
apachesolr_attachments_theme	Implements hook_theme().
theme_apachesolr_search_snippets__file	@todo Vastly improve this theming function
_apachesolr_attachments_get_all_files	Fetches all files linked to nodes created by fields from the file module regardless of the widget

Constants

Name	Description
EXTRACTING_SERVLET	@file Provides a file attachment search implementation for use with the Apache Solr module

Classes

Name	Description
ApachesolrAttachmentsEntityFieldQuery