You are here

class FarmAssetProcessor in farmOS 7

Creates farm assets from feed items.

Hierarchy

Expanded class hierarchy of FarmAssetProcessor

2 string references to 'FarmAssetProcessor'
farm_asset_feeds_plugins in modules/farm/farm_asset/farm_asset.module
Implements hook_feed_plugins().
farm_import_asset_importer in modules/farm/farm_import/farm_import.feeds_importer_default.inc
Helper function for generating an asset importer.

File

modules/farm/farm_asset/includes/feeds/plugins/FarmAssetProcessor.inc, line 10
Class definition of FarmAssetProcessor.

View source
class FarmAssetProcessor extends FeedsProcessor {

  /**
   * Define entity type.
   */
  public function entityType() {
    return 'farm_asset';
  }

  /**
   * Implements parent::entityInfo().
   */
  protected function entityInfo() {
    $info = parent::entityInfo();
    $info['label plural'] = t('Farm assets');
    return $info;
  }

  /**
   * Creates a new farm asset in memory and returns it.
   */
  protected function newEntity(FeedsSource $source) {

    // If an author is not defined, set the author to the current user.
    $uid = $this->config['author'];
    global $user;
    if (empty($uid) && !empty($user->uid)) {
      $uid = $user->uid;
    }

    // Assemble and return the entity.
    $values = array(
      'type' => $this
        ->bundle(),
      'created' => REQUEST_TIME,
      'changed' => REQUEST_TIME,
      'uid' => $uid,
      'is_new' => TRUE,
    );
    return entity_create('farm_asset', $values);
  }

  /**
   * Loads an existing farm asset.
   *
   * If the update existing method is not FEEDS_UPDATE_EXISTING, only the
   * farm_asset table will be loaded, foregoing the farm_asset_load API for
   * better performance.
   */
  protected function entityLoad(FeedsSource $source, $id) {
    $farm_asset = parent::entityLoad($source, $id);
    if ($this->config['update_existing'] != FEEDS_UPDATE_EXISTING) {
      $farm_asset->uid = $this->config['author'];
    }
    return $farm_asset;
  }

  /**
   * Check that the user has permission to save a farm asset.
   */
  protected function entitySaveAccess($entity) {

    // The check will be skipped for anonymous assets.
    if ($this->config['authorize'] && !empty($entity->uid)) {
      $author = user_load($entity->uid);

      // If the uid was mapped directly, rather than by email or username, it
      // could be invalid.
      if (!$author) {
        $message = 'User %uid is not a valid user.';
        throw new FeedsAccessException(t($message, array(
          '%uid' => $entity->uid,
        )));
      }
      if (empty($entity->id) || !empty($entity->is_new)) {
        $op = 'create';
        $access = farm_asset_access($op, $entity->type, $author);
      }
      else {
        $op = 'update';
        $access = farm_asset_access($op, $entity, $author);
      }
      if (!$access) {
        $message = t('The user %name is not authorized to %op assets of type %content_type. To import this item, either the user "@name" (author of the item) must be given the permission to @op assets of type @content_type, or the option "Authorize" on the farm asset processor settings must be turned off.', array(
          '%name' => $author->name,
          '%op' => $op,
          '%content_type' => $entity->type,
          '@name' => $author->name,
          '@op' => $op,
          '@content_type' => $entity->type,
        ));
        throw new FeedsAccessException($message);
      }
    }
  }

  /**
   * Validates a farm asset.
   */
  protected function entityValidate($entity, FeedsSource $source = NULL) {
    parent::entityValidate($entity, $source);
    if (!isset($entity->uid) || !is_numeric($entity->uid)) {
      $entity->uid = $this->config['author'];
    }
  }

  /**
   * Save a farm asset.
   */
  public function entitySave($entity) {
    farm_asset_save($entity);
  }

  /**
   * Delete a series of farm assets.
   */
  protected function entityDeleteMultiple($ids) {
    farm_asset_delete_multiple($ids);
  }

  /**
   * Override parent::configDefaults().
   */
  public function configDefaults() {
    return array(
      'author' => 0,
      'authorize' => TRUE,
    ) + parent::configDefaults();
  }

  /**
   * Override parent::configForm().
   */
  public function configForm(&$form_state) {
    $form = parent::configForm($form_state);
    $author = user_load($this->config['author']);
    $form['author'] = array(
      '#type' => 'textfield',
      '#title' => t('Author'),
      '#description' => t('Select the author of the assets to be created. If this is left empty, they will be assigned to the user running the import, or "anonymous" in the case of automated imports.'),
      '#autocomplete_path' => 'user/autocomplete',
      '#default_value' => empty($author->name) ? '' : check_plain($author->name),
    );
    $form['authorize'] = array(
      '#type' => 'checkbox',
      '#title' => t('Authorize'),
      '#description' => t('Check that the author has permission to create the asset.'),
      '#default_value' => $this->config['authorize'],
    );
    return $form;
  }

  /**
   * Override parent::configFormValidate().
   */
  public function configFormValidate(&$values) {
    if ($author = user_load_by_name($values['author'])) {
      $values['author'] = $author->uid;
    }
    else {
      $values['author'] = 0;
    }
  }

  /**
   * Override setTargetElement to operate on a target item that is a farm asset.
   */
  public function setTargetElement(FeedsSource $source, $target_asset, $target_element, $value) {
    switch ($target_element) {
      case 'created':
        $target_asset->created = feeds_to_unixtime($value, REQUEST_TIME);
        break;
      case 'changed':

        // The 'changed' value will be set on the asset in
        // farm_asset_entity_presave(). This is because farm_asset_save()
        // always overwrites this value (though before invoking
        // hook_entity_presave()).
        $target_asset->feeds_item->asset_changed = feeds_to_unixtime($value, REQUEST_TIME);
        break;
      case 'archived':

        // If the 'archived' property is set to TRUE, then use the current
        // timestamp.
        if ($value == TRUE) {
          $target_asset->archived = REQUEST_TIME;
        }
        break;
      case 'user_name':
        if ($user = user_load_by_name($value)) {
          $target_asset->uid = $user->uid;
        }
        break;
      case 'user_mail':
        if ($user = user_load_by_mail($value)) {
          $target_asset->uid = $user->uid;
        }
        break;
      default:
        parent::setTargetElement($source, $target_asset, $target_element, $value);
        break;
    }
  }

  /**
   * Return available mapping targets.
   */
  public function getMappingTargets() {
    $targets = parent::getMappingTargets();
    $targets['id'] = array(
      'name' => t('Asset ID'),
      'description' => t('The id of the asset. NOTE: use this feature with care, asset ids are usually assigned by Drupal.'),
      'optional_unique' => TRUE,
    );
    $targets['name'] = array(
      'name' => t('Name'),
      'description' => t('The name of the asset.'),
    );
    $targets['uid'] = array(
      'name' => t('Author user ID'),
      'description' => t('The user ID of the asset author.'),
    );
    $targets['user_name'] = array(
      'name' => t('Author username'),
      'description' => t('The username of the asset author.'),
    );
    $targets['user_mail'] = array(
      'name' => t('Author user email'),
      'description' => t('The email address of the asset author.'),
    );
    $targets['created'] = array(
      'name' => t('Created date'),
      'description' => t('The UNIX time when an asset has been published.'),
    );
    $targets['changed'] = array(
      'name' => t('Updated date'),
      'description' => t('The Unix timestamp when an asset has been last updated.'),
    );
    $targets['archived'] = array(
      'name' => t('archived'),
      'description' => t('The Unix timestamp when an asset was archived.'),
    );
    $this
      ->getHookTargets($targets);
    return $targets;
  }

  /**
   * Get id of an existing feed item asset if available.
   */
  protected function existingEntityId(FeedsSource $source, FeedsParserResult $result) {
    if ($id = parent::existingEntityId($source, $result)) {
      return $id;
    }

    // Iterate through all unique targets and test whether they do already
    // exist in the database.
    foreach ($this
      ->uniqueTargets($source, $result) as $target => $value) {
      switch ($target) {
        case 'id':
          $id = db_query("SELECT id FROM {farm_asset} WHERE id = :id", array(
            ':id' => $value,
          ))
            ->fetchField();
          break;
      }
      if (!empty($id)) {

        // Return with the first id found.
        return $id;
      }
    }
    return 0;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
FarmAssetProcessor::configDefaults public function Override parent::configDefaults().
FarmAssetProcessor::configForm public function Override parent::configForm().
FarmAssetProcessor::configFormValidate public function Override parent::configFormValidate().
FarmAssetProcessor::entityDeleteMultiple protected function Delete a series of farm assets.
FarmAssetProcessor::entityInfo protected function Implements parent::entityInfo().
FarmAssetProcessor::entityLoad protected function Loads an existing farm asset.
FarmAssetProcessor::entitySave public function Save a farm asset.
FarmAssetProcessor::entitySaveAccess protected function Check that the user has permission to save a farm asset.
FarmAssetProcessor::entityType public function Define entity type.
FarmAssetProcessor::entityValidate protected function Validates a farm asset.
FarmAssetProcessor::existingEntityId protected function Get id of an existing feed item asset if available.
FarmAssetProcessor::getMappingTargets public function Return available mapping targets.
FarmAssetProcessor::newEntity protected function Creates a new farm asset in memory and returns it.
FarmAssetProcessor::setTargetElement public function Override setTargetElement to operate on a target item that is a farm asset.