Club Drupal

// Options for handling content in Drupal but not in source data.

define('FEEDS_SKIP_NON_EXISTENT', 'skip');

define('FEEDS_DELETE_NON_EXISTENT', 'delete');

    if (!isset($state->removeList) && $parser_result->items) {

      $this->initEntitiesToBeRemoved($source, $state);

    }

      // If it's included in the feed, it must not be removed on clean.

      if ($entity_id) {

        unset($state->removeList[$entity_id]);

      }

      try {

        $hash = $this->hash($item);

        $changed = ($hash !== $this->getHash($entity_id));

        $force_update = $this->config['skip_hash_check'];

        // Do not proceed if the item exists, has not changed, and we're not

        // forcing the update.

        if ($entity_id && !$changed && !$force_update) {

          continue;

        }

        list($message, $arguments) = $this->createLogEntry($e, $entity, $item);

        $source->log('import', $message, $arguments, WATCHDOG_ERROR);

    // Remove not included items if needed.

    // It depends on the implementation of the clean() method what will happen

    // to items that were no longer in the source.

    $this->clean($state);

    if ($state->unpublished) {

      $messages[] = array(

        'message' => format_plural(

            $state->unpublished,

            'Unpublished @number @entity.',

            'Unpublished @number @entities.',

            array('@number' => $state->unpublished) + $tokens

        ),

      );

    }

    if ($state->blocked) {

      $messages[] = array(

        'message' => format_plural(

          $state->blocked,

          'Blocked @number @entity.',

          'Blocked @number @entities.',

          array('@number' => $state->blocked) + $tokens

        ),

      );

    }

    if ($state->deleted) {

      $messages[] = array(

       'message' => format_plural(

          $state->deleted,

          'Removed @number @entity.',

          'Removed @number @entities.',

          array('@number' => $state->deleted) + $tokens

        ),

      );

    }

  /**

   * Initialize the array of entities to remove with all existing entities

   * previously imported from the source.

   *

   * @param FeedsSource $source

   *   Source information about this import.

   * @param FeedsState $state

   *   The FeedsState object for the given stage.

   */

  protected function initEntitiesToBeRemoved(FeedsSource $source, FeedsState $state) {

    $state->removeList = array();

    // We fill it only if needed.

    if (!isset($this->config['update_non_existent']) || $this->config['update_non_existent'] == FEEDS_SKIP_NON_EXISTENT) {

      return;

    }

    // Build base select statement.

    $info = $this->entityInfo();

    $id_key = db_escape_field($info['entity keys']['id']);

    $select = db_select($info['base table'], 'e');

    $select->addField('e', $info['entity keys']['id'], 'entity_id');

    $select->join(

      'feeds_item',

      'fi',

      'e.' . $id_key . ' = fi.entity_id AND fi.entity_type = :entity_type', array(

        ':entity_type' => $this->entityType(),

    ));

    $select->condition('fi.id', $this->id);

    $select->condition('fi.feed_nid', $source->feed_nid);

    // No need to remove item again if same method of removal was already used.

    $select->condition('fi.hash', $this->config['update_non_existent'], '<>');

    $entities = $select->execute();

    // If not found on process, existing entities will be deleted.

    foreach ($entities as $entity) {

      // Obviously, items which are still included in the source feed will be

      // removed from this array when processed.

      $state->removeList[$entity->entity_id] = $entity->entity_id;

    }

  }

  /**

   * Deletes entities which were not found during processing.

   *

   * @todo batch delete?

   *

   * @param FeedsState $state

   *   The FeedsState object for the given stage.

   */

  protected function clean(FeedsState $state) {

    // We clean only if needed.

    if (!isset($this->config['update_non_existent']) || $this->config['update_non_existent'] == FEEDS_SKIP_NON_EXISTENT) {

      return;

    }

    $total = count($state->removeList);

    if ($total) {

      $this->entityDeleteMultiple($state->removeList);

      $state->deleted += $total;

    }

  }

   * Deletes feed items older than REQUEST_TIME - $time.

   * Do not invoke expire on a processor directly, but use

   * FeedsSource::expire() instead.

   *

   * @param FeedsSource $source

   *   The source to expire entities for.

   *   (optional) All items produced by this configuration that are older than

   *   REQUEST_TIME - $time should be deleted. If NULL, processor should use

   *   internal configuration. Defaults to NULL.

   * @return float

   *

   * @see FeedsSource::expire()

  public function expire(FeedsSource $source, $time = NULL) {

    $state = $source->state(FEEDS_PROCESS_EXPIRE);

    if ($time === NULL) {

      $time = $this->expiryTime();

    }

    if ($time == FEEDS_EXPIRE_NEVER) {

      return;

    }

    $select = $this->expiryQuery($source, $time);

    // If there is no total, query it.

    if (!$state->total) {

      $state->total = $select->countQuery()->execute()->fetchField();

    }

    // Delete a batch of entities.

    $entity_ids = $select->range(0, $this->getLimit())->execute()->fetchCol();

    if ($entity_ids) {

      $this->entityDeleteMultiple($entity_ids);

      $state->deleted += count($entity_ids);

      $state->progress($state->total, $state->deleted);

    }

    else {

      $state->progress($state->total, $state->total);

    }

  }

  /**

   * Returns a database query used to select entities to expire.

   *

   * Processor classes should override this method to set the age portion of the

   * query.

   *

   * @param FeedsSource $source

   *   The feed source.

   * @param int $time

   *   Delete entities older than this.

   *

   * @return SelectQuery

   *   A select query to execute.

   *

   * @see FeedsNodeProcessor::expiryQuery()

   */

  protected function expiryQuery(FeedsSource $source, $time) {

    // Build base select statement.

    $info = $this->entityInfo();

    $id_key = db_escape_field($info['entity keys']['id']);

    $select = db_select($info['base table'], 'e');

    $select->addField('e', $info['entity keys']['id'], 'entity_id');

    $select->join(

      'feeds_item',

      'fi',

      "e.$id_key = fi.entity_id AND fi.entity_type = :entity_type", array(

        ':entity_type' => $this->entityType(),

    ));

    $select->condition('fi.id', $this->id);

    $select->condition('fi.feed_nid', $source->feed_nid);

    return $select;

  /**

   * Returns a statically cached version of the target mappings.

   *

   * @return array

   *   The targets for this importer.

   */

  protected function getCachedTargets() {

    $targets = &drupal_static('FeedsProcessor::getCachedTargets', array());

    if (!isset($targets[$this->id])) {

      $targets[$this->id] = $this->getMappingTargets();

    }

    return $targets[$this->id];

  }

  /**

   * Returns a statically cached version of the source mappings.

   *

   * @return array

   *   The sources for this importer.

   */

  protected function getCachedSources() {

    $sources = &drupal_static('FeedsProcessor::getCachedSources', array());

    if (!isset($sources[$this->id])) {

      $sources[$this->id] = feeds_importer($this->id)->parser->getMappingSources();

      if (is_array($sources[$this->id])) {

        foreach ($sources[$this->id] as $source_key => $source) {

          if (empty($source['callback']) || !is_callable($source['callback'])) {

            unset($sources[$this->id][$source_key]['callback']);

          }

        }

      }

    }

    return $sources[$this->id];

  }

   * @see hook_feeds_processor_targets()

   * @see hook_feeds_processor_targets_alter()

    $targets = $this->getCachedTargets();

      if (isset($targets[$mapping['target']]['real_target'])) {

        $target_item->{$targets[$mapping['target']]['real_target']} = NULL;

      else {

        $target_item->{$mapping['target']} = NULL;

    // This is where the actual mapping happens: For every mapping we invoke

    // the parser's getSourceElement() method to retrieve the value of the

    // source element and pass it to the processor's setTargetElement() to stick

    // it on the right place of the target item.

      $value = $this->getSourceValue($source, $result, $mapping['source']);

      $this->mapToTarget($source, $mapping['target'], $target_item, $value, $mapping);

    }

    return $target_item;

  }

  /**

   * Returns the values from the parser, or callback.

   *

   * @param FeedsSource $source

   *   The feed source.

   * @param FeedsParserResult $result

   *   The parser result.

   * @param string $source_key

   *   The current key being processed.

   *

   * @return mixed

   *   A value, or a list of values.

   */

  protected function getSourceValue(FeedsSource $source, FeedsParserResult $result, $source_key) {

    $sources = $this->getCachedSources();

    if (isset($sources[$source_key]['callback'])) {

      return call_user_func($sources[$source_key]['callback'], $source, $result, $source_key);

    }

    return feeds_importer($this->id)->parser->getSourceElement($source, $result, $source_key);

  }

  /**

   * Maps values onto the target item.

   *

   * @param FeedsSource $source

   *   The feed source.

   * @param mixed &$target_item

   *   The target item to apply values into.

   * @param mixed $value

   *   A value, or a list of values.

   * @param array $mapping

   *   The mapping configuration.

   */

  protected function mapToTarget(FeedsSource $source, $target, &$target_item, $value, array $mapping) {

    $targets = $this->getCachedTargets();

    if (isset($targets[$target]['preprocess_callbacks'])) {

      foreach ($targets[$target]['preprocess_callbacks'] as $callback) {

        call_user_func_array($callback, array($source, $target_item, $target, &$mapping));

    }

    // Map the source element's value to the target.

    // If the mapping specifies a callback method, use the callback instead of

    // setTargetElement().

    if (isset($targets[$target]['callback'])) {

      // All target callbacks expect an array.

      if (!is_array($value)) {

        $value = array($value);

      call_user_func($targets[$target]['callback'], $source, $target_item, $target, $value, $mapping);

    }

    else {

      $this->setTargetElement($source, $target_item, $target, $value, $mapping);

      'update_non_existent' => FEEDS_SKIP_NON_EXISTENT,

      '#description' => t('Select the default input format for the text fields of the nodes to be created.'),

    $form['update_non_existent'] = array(

      '#type' => 'radios',

      '#title' => t('Action to take when previously imported @entities are missing in the feed', $tokens),

      '#description' => t('Select how @entities previously imported and now missing in the feed should be updated.', $tokens),

      '#options' => array(

        FEEDS_SKIP_NON_EXISTENT => t('Skip non-existent @entities', $tokens),

        FEEDS_DELETE_NON_EXISTENT => t('Delete non-existent @entities', $tokens),

      ),

      '#default_value' => $this->config['update_non_existent'],

    );

  /**

   * Allows other modules to expose targets.

   *

   * @param array &$targets

   *   The existing target array.

   */

  protected function getHookTargets(array &$targets) {

    self::loadMappers();

    $entity_type = $this->entityType();

    $bundle = $this->bundle();

    $targets += module_invoke_all('feeds_processor_targets', $entity_type, $bundle);

    drupal_alter('feeds_processor_targets', $targets, $entity_type, $bundle);

  }

   * @param FeedsParserResult $result

   * @return int

    $targets = $this->getCachedTargets();

    $entity_id = 0;

    // Iterate through all unique targets and test whether they already exist in

    // the database.

      if ($target === 'guid' || $target === 'url') {

        $entity_id = db_select('feeds_item')

          ->fields('feeds_item', array('entity_id'))

          ->condition('feed_nid', $source->feed_nid)

          ->condition('entity_type', $this->entityType())

          ->condition('id', $source->id)

          ->condition($target, $value)

          ->execute()

          ->fetchField();

      if (!$entity_id && !empty($targets[$target]['unique_callbacks'])) {

        if (!is_array($value)) {

          $value = array($value);

        }

        foreach ($targets[$target]['unique_callbacks'] as $callback) {

          if ($entity_id = call_user_func($callback, $source, $this->entityType(), $this->bundle(), $target, $value)) {

            // Stop at the first unique ID returned by a callback.

            break;

          }

        }

      }

      // Return with the content id found.

      if ($entity_id) {

    return $entity_id;

   * DEPRECATED: Creates a log message for exceptions during import.

   *

   * Don't use this method as it concatenates user variables into the log

   * message, which will pollute the locales_source table when the log message

   * is translated. Use ::createLogEntry instead.

   *

   * @deprecated

   *   Use ::createLogEntry instead.

    // $this->exportObjectVars() already runs check_plain() for us, so we can

    // concatenate here as is.

    $message .= '<pre>' . $this->exportObjectVars($item) . '</pre>';

    $message .= '<pre>' . $this->exportObjectVars($entity) . '</pre>';

  /**

   * Creates a log entry for when an exception occured during import.

   *

   * @param Exception $e

   *   The exception that was throwned during processing the item.

   * @param object $entity

   *   The entity object.

   * @param array $item

   *   The parser result for this entity.

   *

   * @return array

   *   The message and arguments to log.

   */

  protected function createLogEntry(Exception $e, $entity, $item) {

    $message = '@exception';

    $message .= '<h3>Original item</h3>';

    $message .= '<pre>!item</pre>';

    $message .= '<h3>Entity</h3>';

    $message .= '<pre>!entity</pre>';

    $arguments = array(

      '@exception' => $e->getMessage(),

      // $this->exportObjectVars() already runs check_plain() for us, so we can

      // use the "!" placeholder.

      '!item' => $this->exportObjectVars($item),

      '!entity' => $this->exportObjectVars($entity),

    );

    return array($message, $arguments);

  }

  /**

   * Returns a string representation of an object or array for log messages.

   *

   * @param object|array $object

   *   The object to convert.

   *

   * @return string

   *   The sanitized string representation of the object.

   */

  protected function exportObjectVars($object) {

    include_once DRUPAL_ROOT . '/includes/utility.inc';

    $out = is_array($object) ? $object : get_object_vars($object);

    $out = array_filter($out, 'is_scalar');

    foreach ($out as $key => $value) {

      if (is_string($value)) {

        $out[$key] = truncate_utf8($value, 100, FALSE, TRUE);

      }

    }

    if (is_array($object)) {

      return check_plain(drupal_var_export($out));

    }

    return check_plain(drupal_var_export((object) $out));

  }

  /**

   * Overrides FeedsPlugin::dependencies().

   */

  public function dependencies() {

    $dependencies = parent::dependencies();

    // Find out which module defined the entity type.

    $info = $this->entityInfo();

    if (isset($info['module'])) {

      $dependencies[$info['module']] = $info['module'];

    }

    return $dependencies;

  }