public function FeedImportProcessor::setFields in Feed Import 7.3

Sets entity fields.

Parameters

array $fields: List of dynamic fields

array $static_fields: List of static fields

array $compare_functions: List of compare functions

string $default_compare: Default compare function

Return value

boolean TRUE if fields were set

File

feed_import_base/inc/feed_import.inc, line 920

This file contains Feed Import helpers.

Class

FeedImportProcessor

Class that processess the import.

Code

public function setFields(array $fields = array(), array $static_fields = array(), array $compare_functions = array(), array $merge_classes = array(), $default_compare = '_feed_import_base_compare_other_fields') {

  // Check for requirements.
  if (!$this->entityInfo || !$this->reader || !$this->filters || !empty($this->baseEntity)) {
    $this
      ->addError('Could not set fields because there are missing dependencies or fields were already added');
    return FALSE;
  }

  // Create default merge
  if (!isset($merge_classes[static::UPDATE_COMBINE])) {
    $this
      ->addError(sprintf('Merge field default class found!'));
    return FALSE;
  }
  $class = $merge_classes[static::UPDATE_COMBINE];
  if (!class_exists($class)) {
    $this
      ->addError(sprintf('Merge field default class %s was not found!', $class));
    return FALSE;
  }
  elseif (!is_subclass_of($class, 'FeedImportMergeField')) {
    $this
      ->addError(sprintf('Merge field default class %s must extend % class!', $class, 'FeedImportMergeField'));
    return FALSE;
  }
  $merge_classes[static::UPDATE_COMBINE] = new $class();

  // Create format paths callback.
  $fp = array(
    $this->reader,
    'formatPath',
  );

  // Get language key.
  $lk = $this->entityInfo->langKey;

  // Set static fields.
  $this->staticFields =& $static_fields;

  // Parse all fields.
  foreach ($fields as &$f) {

    // Set field info.
    $this->fieldsInfo[$f['field']] =& $f;
    if (!isset($merge_classes[$f['update_mode']])) {
      $this
        ->addError(sprintf('No field merge class found for field %s!', $f['field']));
      return FALSE;
    }
    if (is_string($merge_classes[$f['update_mode']])) {
      $class = $merge_classes[$f['update_mode']];
      if (!class_exists($class)) {
        $this
          ->addError(sprintf('Merge field class %s for field %s was not found!', $class, $f['field']));
        return FALSE;
      }
      elseif (!is_subclass_of($class, 'FeedImportMergeField')) {
        $this
          ->addError(sprintf('Merge field class %s for field %s must extend % class!', $class, $f['field'], 'FeedImportMergeField'));
        return FALSE;
      }
      $merge_classes[$f['update_mode']] = new $class();
    }
    $f['update_mode'] = $merge_classes[$f['update_mode']];
    $f['overwrite'] = $f['update_mode']
      ->overwriteEmpty();

    // Add cardinality
    $f['cardinality'] = isset($this->entityInfo->fields[$f['field']]['cardinality']) ? $this->entityInfo->fields[$f['field']]['cardinality'] : 1;

    // Add compare function
    if ($f['column']) {
      $f['compare'] = $this->entityInfo->fields[$f['field']]['module'] . ':' . $this->entityInfo->fields[$f['field']]['type'];
      if (isset($compare_functions[$f['compare']])) {
        $f['compare'] = $compare_functions[$f['compare']];
      }
      else {
        $f['compare'] = $default_compare;
      }
    }

    // Check if column must be guessed.
    if ($f['column'] === TRUE && isset($this->entityInfo->fields[$f['field']])) {
      $f['column'] = $this->entityInfo->fields[$f['field']]['column'];
    }

    // Get paths count
    $f['paths_count'] = count($f['paths']);

    // Check if can be used as static field to improve performance
    if (!$f['paths_count'] && $f['default_action'] == 'default_value') {
      if ($f['column']) {

        // Its a field, add it to static fields.
        $this->staticFields[$f['field']][$f['column']] = $f['default_value'];
      }
      else {

        // Its a property.
        $this->staticFields[$f['field']] = $f['default_value'];
      }

      // Ignore filters.
      $f['prefilters'] = $f['filters'] = FALSE;

      // Next field.
      continue;
    }

    // Check (pre)filters
    foreach (array(
      'prefilters',
      'filters',
    ) as $fgroup) {
      if ($f[$fgroup]) {
        $ok = TRUE;

        // Add filters
        foreach ($f[$fgroup] as &$v) {
          if (!$this->filters
            ->add($fgroup, $f['field'], $v['function'], $v['params'])) {
            $ok = FALSE;
            $this
              ->addError(sprintf('Could not add function %s in %s for %s field because is not defined', $v['function'], $fgroup, $f['field']));
            if ($this->breakOnUndefinedFilter) {
              $this
                ->addError('Import stopped because a filter function is missing!');
              return FALSE;
            }
          }
        }
        $f[$fgroup] = $ok;
      }
      else {

        // No filters
        $f[$fgroup] = FALSE;
      }
    }

    // Format paths
    $f['paths'] = array_map($fp, $f['paths']);

    // Add to fields
    $this->fields[$f['field']] =& $f;
  }

  // Remove reference to $f.
  unset($f);

  // Set all static fields properties.
  // In the end just fields remain in static fields (no properties).
  foreach ($this->staticFields as $f => &$value) {
    if (is_scalar($value)) {
      if (!isset($this->fieldsInfo[$f])) {
        $this->fieldsInfo[$f] = array(
          'field' => $f,
          'column' => FALSE,
          'update_mode' => $merge_classes[static::UPDATE_COMBINE],
          'overwrite' => $merge_classes[static::UPDATE_COMBINE]
            ->overwriteEmpty(),
          'cardinality' => 1,
        );
      }
      $this->baseEntity[$f] = $value;
      unset($this->staticFields[$f]);
    }
    elseif (!isset($this->fieldsInfo[$f])) {
      $this->fieldsInfo[$f] = array(
        'field' => $f,
        'column' => isset($this->entityInfo->fields[$f]) ? $this->entityInfo->fields[$f]['column'] : 'value',
        'update_mode' => $merge_classes[static::UPDATE_COMBINE],
        'overwrite' => $merge_classes[static::UPDATE_COMBINE]
          ->overwriteEmpty(),
        'cardinality' => isset($this->entityInfo->fields[$f]['cardinality']) ? $this->entityInfo->fields[$f]['cardinality'] : 1,
      );
    }
  }

  // There isn't lang in base entity nor in fields so use default.
  if (!isset($this->baseEntity[$lk]) && !isset($this->fields[$lk])) {
    $this->baseEntity[$lk] = LANGUAGE_NONE;
  }

  // Check for language in base entity.
  if (isset($this->baseEntity[$lk])) {

    // We have lang so set static fields in base entity.
    $lang = $this->baseEntity[$lk];
    foreach ($this->staticFields as $f => &$value) {
      if (!isset($this->fields[$f])) {

        // This field is not dynamically generated so use it in base entity.
        $this->baseEntity[$f][$lang][] = $value;

        // Remove it from static fields because now is part of base entity.
        unset($this->staticFields[$f]);
      }
    }
  }
  else {

    // No language, it means language is dynamically created.
    // Move language on top to be available for other fields.
    $this->fields = array_merge(array(
      $lk => NULL,
    ), $this->fields);

    // However, set it to NONE, and if used will be overwritten.
    $this->baseEntity[$lk] = LANGUAGE_NONE;
  }
  return TRUE;
}