first import
This commit is contained in:
Bachir Soussi Chiadmi
671
sites/all/modules/migrate/plugins/destinations/fields.inc
Normal file
671
sites/all/modules/migrate/plugins/destinations/fields.inc
Normal file
@@ -0,0 +1,671 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* @file
|
||||
* Support for processing entity fields
|
||||
*/
|
||||
|
||||
class MigrateFieldsEntityHandler extends MigrateDestinationHandler {
|
||||
public function __construct() {
|
||||
$this->registerTypes(array('entity'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of MigrateDestinationHandler::fields().
|
||||
*
|
||||
* @param $entity_type
|
||||
* The entity type (node, user, etc.) for which to list fields.
|
||||
* @param $bundle
|
||||
* The bundle (article, blog, etc.), if any, for which to list fields.
|
||||
* @param Migration $migration
|
||||
* Optionally, the migration providing the context.
|
||||
* @return array
|
||||
* An array keyed by field name, with field descriptions as values.
|
||||
*/
|
||||
public function fields($entity_type, $bundle, $migration = NULL) {
|
||||
$fields = array();
|
||||
$field_instance_info = field_info_instances($entity_type, $bundle);
|
||||
foreach ($field_instance_info as $machine_name => $instance) {
|
||||
$field_info = field_info_field($machine_name);
|
||||
$type = $field_info['type'];
|
||||
|
||||
$fields[$machine_name] = t('Field:') . ' ' . $instance['label'] .
|
||||
' (' . $field_info['type'] . ')';
|
||||
|
||||
// Look for subfields
|
||||
$class_list = _migrate_class_list('MigrateFieldHandler');
|
||||
$disabled = unserialize(variable_get('migrate_disabled_handlers', serialize(array())));
|
||||
foreach ($class_list as $class_name => $handler) {
|
||||
if (!in_array($class_name, $disabled) && $handler->handlesType($type)
|
||||
&& method_exists($handler, 'fields')) {
|
||||
migrate_instrument_start($class_name . '->fields');
|
||||
$subfields = call_user_func(array($handler, 'fields'), $type,
|
||||
$machine_name, $migration);
|
||||
migrate_instrument_stop($class_name . '->fields');
|
||||
foreach ($subfields as $subfield_name => $subfield_label) {
|
||||
$fields[$machine_name . ':' . $subfield_name] = $subfield_label;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return $fields;
|
||||
}
|
||||
|
||||
public function prepare($entity, stdClass $row) {
|
||||
migrate_instrument_start('MigrateDestinationEntity->prepareFields');
|
||||
// Look for Field API fields attached to this destination and handle appropriately
|
||||
$migration = Migration::currentMigration();
|
||||
$destination = $migration->getDestination();
|
||||
$entity_type = $destination->getEntityType();
|
||||
$bundle = $destination->getBundle();
|
||||
$instances = field_info_instances($entity_type, $bundle);
|
||||
foreach ($instances as $machine_name => $instance) {
|
||||
if (property_exists($entity, $machine_name)) {
|
||||
// Normalize to an array
|
||||
if (!is_array($entity->$machine_name)) {
|
||||
$entity->$machine_name = array($entity->$machine_name);
|
||||
}
|
||||
$field_info = field_info_field($machine_name);
|
||||
$entity->$machine_name = migrate_field_handler_invoke_all($entity, $field_info,
|
||||
$instance, $entity->$machine_name);
|
||||
}
|
||||
}
|
||||
migrate_instrument_stop('MigrateDestinationEntity->prepareFields');
|
||||
}
|
||||
|
||||
public function complete($entity, stdClass $row) {
|
||||
migrate_instrument_start('MigrateDestinationEntity->completeFields');
|
||||
// Look for Field API fields attached to this destination and handle appropriately
|
||||
$migration = Migration::currentMigration();
|
||||
$destination = $migration->getDestination();
|
||||
$entity_type = $destination->getEntityType();
|
||||
$bundle = $destination->getBundle();
|
||||
$instances = field_info_instances($entity_type, $bundle);
|
||||
foreach ($instances as $machine_name => $instance) {
|
||||
if (property_exists($entity, $machine_name)) {
|
||||
// Normalize to an array
|
||||
if (!is_array($entity->$machine_name)) {
|
||||
$entity->$machine_name = array($entity->$machine_name);
|
||||
}
|
||||
$field_info = field_info_field($machine_name);
|
||||
migrate_field_handler_invoke_all($entity, $field_info,
|
||||
$instance, $entity->$machine_name, 'complete');
|
||||
}
|
||||
}
|
||||
migrate_instrument_stop('MigrateDestinationEntity->completeFields');
|
||||
}
|
||||
}
|
||||
|
||||
abstract class MigrateFieldHandler extends MigrateHandler {
|
||||
// Derived classes are expected to implement one or both of the prepare/complete
|
||||
// handlers.
|
||||
|
||||
// abstract public function prepare($entity, array $field_info, array $instance, array $values);
|
||||
// abstract public function complete($entity, array $field_info, array $instance, array $values);
|
||||
|
||||
/**
|
||||
* Determine the language of the field
|
||||
*
|
||||
* @param $entity
|
||||
* @param $field_info
|
||||
* @param $arguments
|
||||
* @return string language code
|
||||
*/
|
||||
function getFieldLanguage($entity, $field_info, array $arguments) {
|
||||
$migration = Migration::currentMigration();
|
||||
switch (TRUE) {
|
||||
case !field_is_translatable($migration->getDestination()->getEntityType(), $field_info):
|
||||
return LANGUAGE_NONE;
|
||||
case isset($arguments['language']):
|
||||
return $arguments['language'];
|
||||
case !empty($entity->language) && $entity->language != LANGUAGE_NONE:
|
||||
return $entity->language;
|
||||
break;
|
||||
default:
|
||||
return $migration->getDestination()->getLanguage();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Base class for creating field handlers for fields with a single value.
|
||||
*
|
||||
* To use this class just extend it and pass key where the field's value should
|
||||
* be stored to the constructor, then register the type(s):
|
||||
* @code
|
||||
* class MigrateLinkFieldHandler extends MigrateSimpleFieldHandler {
|
||||
* public function __construct() {
|
||||
* parent::__construct('url');
|
||||
* $this->registerTypes(array('link'));
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
abstract class MigrateSimpleFieldHandler extends MigrateFieldHandler {
|
||||
protected $fieldValueKey = 'value';
|
||||
|
||||
protected $skipEmpty = FALSE;
|
||||
|
||||
/**
|
||||
* Construct a simple field handler.
|
||||
*
|
||||
* @param $options
|
||||
* Array of options (rather than unamed parameters so you don't have to
|
||||
* what TRUE or FALSE means). The following keys are used:
|
||||
* - 'value_key' string with the name of the key in the fields value array.
|
||||
* - 'skip_empty' Boolean indicating that empty values should not be saved.
|
||||
*/
|
||||
public function __construct($options = array()) {
|
||||
if (isset($options['value_key'])) {
|
||||
$this->fieldValueKey = $options['value_key'];
|
||||
}
|
||||
if (isset($options['skip_empty'])) {
|
||||
$this->skipEmpty = $options['skip_empty'];
|
||||
}
|
||||
}
|
||||
|
||||
public function prepare($entity, array $field_info, array $instance, array $values) {
|
||||
$arguments = array();
|
||||
if (isset($values['arguments'])) {
|
||||
$arguments = $values['arguments'];
|
||||
unset($values['arguments']);
|
||||
}
|
||||
$language = $this->getFieldLanguage($entity, $field_info, $arguments);
|
||||
|
||||
// Let the derived class skip empty values.
|
||||
if ($this->skipEmpty) {
|
||||
$values = array_filter($values, array($this, 'notNull'));
|
||||
}
|
||||
|
||||
// Setup the Field API array for saving.
|
||||
$delta = 0;
|
||||
foreach ($values as $value) {
|
||||
if (is_array($language)) {
|
||||
$current_language = $language[$delta];
|
||||
}
|
||||
else {
|
||||
$current_language = $language;
|
||||
}
|
||||
$return[$current_language][] = array($this->fieldValueKey => $value);
|
||||
$delta++;
|
||||
}
|
||||
return isset($return) ? $return : NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns TRUE only for values which are not NULL.
|
||||
*
|
||||
* @param $value
|
||||
* @return bool
|
||||
*/
|
||||
protected function notNull($value) {
|
||||
return !is_null($value);
|
||||
}
|
||||
}
|
||||
|
||||
class MigrateTextFieldHandler extends MigrateFieldHandler {
|
||||
public function __construct() {
|
||||
$this->registerTypes(array('text', 'text_long', 'text_with_summary'));
|
||||
}
|
||||
|
||||
static function arguments($summary = NULL, $format = NULL, $language = NULL) {
|
||||
$arguments = array();
|
||||
if (!is_null($summary)) {
|
||||
$arguments['summary'] = $summary;
|
||||
}
|
||||
if (!is_null($format)) {
|
||||
$arguments['format'] = $format;
|
||||
}
|
||||
if (!is_null($language)) {
|
||||
$arguments['language'] = $language;
|
||||
}
|
||||
return $arguments;
|
||||
}
|
||||
|
||||
public function fields($type) {
|
||||
$fields = array();
|
||||
if ($type == 'text_with_summary') {
|
||||
$fields['summary'] = t('Subfield: Summary of field contents');
|
||||
}
|
||||
$fields += array(
|
||||
'format' => t('Subfield: Text format for the field'),
|
||||
'language' => t('Subfield: Language for the field'),
|
||||
);
|
||||
return $fields;
|
||||
}
|
||||
|
||||
public function prepare($entity, array $field_info, array $instance, array $values) {
|
||||
if (isset($values['arguments'])) {
|
||||
$arguments = $values['arguments'];
|
||||
unset($values['arguments']);
|
||||
}
|
||||
else {
|
||||
$arguments = array();
|
||||
}
|
||||
|
||||
$migration = Migration::currentMigration();
|
||||
$destination = $migration->getDestination();
|
||||
$language = $this->getFieldLanguage($entity, $field_info, $arguments);
|
||||
$max_length = isset($field_info['settings']['max_length']) ?
|
||||
$field_info['settings']['max_length'] : 0;
|
||||
|
||||
// Setup the standard Field API array for saving.
|
||||
$delta = 0;
|
||||
foreach ($values as $value) {
|
||||
$item = array();
|
||||
if (isset($arguments['summary'])) {
|
||||
if (is_array($arguments['summary'])) {
|
||||
$item['summary'] = $arguments['summary'][$delta];
|
||||
}
|
||||
else {
|
||||
$item['summary'] = $arguments['summary'];
|
||||
}
|
||||
}
|
||||
if (isset($arguments['format'])) {
|
||||
if (is_array($arguments['format'])) {
|
||||
$format = $arguments['format'][$delta];
|
||||
}
|
||||
else {
|
||||
$format = $arguments['format'];
|
||||
}
|
||||
}
|
||||
else {
|
||||
$format = $destination->getTextFormat();
|
||||
}
|
||||
$item['format'] = $item['value_format'] = $format;
|
||||
// Make sure the value will fit
|
||||
if ($max_length) {
|
||||
$item['value'] = drupal_substr($value, 0, $max_length);
|
||||
if (!empty($arguments['track_overflow'])) {
|
||||
$value_length = drupal_strlen($value);
|
||||
if ($value_length > $max_length) {
|
||||
$migration->saveMessage(
|
||||
t('Value for field !field exceeds max length of !max_length, actual length is !length',
|
||||
array('!field' => $instance['field_name'], '!max_length' => $max_length,
|
||||
'!length' => $value_length)),
|
||||
Migration::MESSAGE_INFORMATIONAL);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
$item['value'] = $value;
|
||||
}
|
||||
|
||||
if (is_array($language)) {
|
||||
$current_language = $language[$delta];
|
||||
}
|
||||
else {
|
||||
$current_language = $language;
|
||||
}
|
||||
$return[$current_language][] = $item;
|
||||
$delta++;
|
||||
}
|
||||
|
||||
return isset($return) ? $return : NULL;
|
||||
}
|
||||
}
|
||||
|
||||
class MigrateValueFieldHandler extends MigrateSimpleFieldHandler {
|
||||
public function __construct() {
|
||||
parent::__construct(array(
|
||||
'value_key' => 'value',
|
||||
'skip_empty' => FALSE,
|
||||
));
|
||||
$this->registerTypes(array('value', 'list', 'list_boolean', 'list_integer',
|
||||
'list_float', 'list_text', 'number_integer', 'number_decimal', 'number_float'));
|
||||
}
|
||||
}
|
||||
|
||||
class MigrateTaxonomyTermReferenceFieldHandler extends MigrateFieldHandler {
|
||||
public function __construct() {
|
||||
$this->registerTypes(array('taxonomy_term_reference'));
|
||||
}
|
||||
|
||||
public function fields($type) {
|
||||
return array(
|
||||
'source_type' => t('Option: Set to \'tid\' when the value is a source ID'),
|
||||
'create_term' => t('Option: Set to TRUE to create referenced terms when necessary')
|
||||
);
|
||||
}
|
||||
|
||||
public function prepare($entity, array $field_info, array $instance, array $values) {
|
||||
if (isset($values['arguments'])) {
|
||||
$arguments = $values['arguments'];
|
||||
unset($values['arguments']);
|
||||
}
|
||||
else {
|
||||
$arguments = array();
|
||||
}
|
||||
if (empty($values[0])) {
|
||||
$values = array();
|
||||
}
|
||||
|
||||
$tids = array();
|
||||
if (isset($arguments['source_type']) && $arguments['source_type'] == 'tid') {
|
||||
// Nothing to do. We have tids already.
|
||||
$tids = $values;
|
||||
}
|
||||
elseif ($values) {
|
||||
// Get the vocabulary for this term
|
||||
if (isset($field_info['settings']['allowed_values'][0]['vid'])) {
|
||||
$vid = $field_info['settings']['allowed_values'][0]['vid'];
|
||||
}
|
||||
else {
|
||||
$vocab_name = $field_info['settings']['allowed_values'][0]['vocabulary'];
|
||||
$names = taxonomy_vocabulary_get_names();
|
||||
$vid = $names[$vocab_name]->vid;
|
||||
}
|
||||
|
||||
// Cannot use taxonomy_term_load_multiple() since we have an array of names.
|
||||
// It wants a singular value. This query may return case-insensitive
|
||||
// matches.
|
||||
$existing_terms = db_select('taxonomy_term_data', 'td')
|
||||
->fields('td', array('tid', 'name'))
|
||||
->condition('td.name', $values, 'IN')
|
||||
->condition('td.vid', $vid)
|
||||
->execute()
|
||||
->fetchAllKeyed(1, 0);
|
||||
foreach ($values as $value) {
|
||||
if (isset($existing_terms[$value])) {
|
||||
$tids[] = $existing_terms[$value];
|
||||
}
|
||||
elseif (!empty($arguments['create_term'])) {
|
||||
$new_term = new stdClass();
|
||||
$new_term->vid = $vid;
|
||||
$new_term->name = $value;
|
||||
taxonomy_term_save($new_term);
|
||||
$tids[] = $new_term->tid;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$language = $this->getFieldLanguage($entity, $field_info, $arguments);
|
||||
$result = array();
|
||||
$delta = 0;
|
||||
foreach ($tids as $tid) {
|
||||
if (is_array($language)) {
|
||||
$current_language = $language[$delta];
|
||||
}
|
||||
else {
|
||||
$current_language = $language;
|
||||
}
|
||||
$result[$current_language][] = array('tid' => $tid);
|
||||
$delta++;
|
||||
}
|
||||
return $result;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The next generation of file field handler. This class focuses on the file
|
||||
* field itself, and offloads understanding of obtaining the actual file and
|
||||
* dealing with the file entity to an embedded MigrateFileInterface instance.
|
||||
*/
|
||||
abstract class MigrateFileFieldBaseHandler extends MigrateFieldHandler {
|
||||
/**
|
||||
* Implementation of MigrateFieldHandler::fields().
|
||||
*
|
||||
* @param $type
|
||||
* The file field type - 'file', 'image', etc.
|
||||
* @param $parent_field
|
||||
* Name of the parent field.
|
||||
* @param Migration $migration
|
||||
* The migration context for the parent field. We can look at the mappings
|
||||
* and determine which subfields are relevant.
|
||||
* @return array
|
||||
*/
|
||||
public function fields($type, $parent_field, $migration = NULL) {
|
||||
$fields = array(
|
||||
'file_class' => t('Option: <a href="@doc">Implementation of MigrateFile to use</a>',
|
||||
array('@doc' => 'http://drupal.org/node/1540106#file_class')),
|
||||
'language' => t('Subfield: Language for the field'),
|
||||
);
|
||||
|
||||
// If we can identify the file class mapped to this field, pick up the
|
||||
// subfields specific to that class.
|
||||
if ($migration) {
|
||||
$field_mappings = $migration->getFieldMappings();
|
||||
$class_mapping = $parent_field . ':file_class';
|
||||
if (isset($field_mappings[$class_mapping])) {
|
||||
$mapping = $field_mappings[$class_mapping];
|
||||
$file_class = $mapping->getDefaultValue();
|
||||
}
|
||||
}
|
||||
if (!isset($file_class)) {
|
||||
$file_class = 'MigrateFileUri';
|
||||
}
|
||||
$fields += call_user_func(array($file_class, 'fields'));
|
||||
return $fields;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of MigrateFieldHandler::prepare().
|
||||
*
|
||||
* Prepare file data for saving as a Field API file field.
|
||||
*
|
||||
* @return array
|
||||
* Field API array suitable for inserting in the destination object.
|
||||
*/
|
||||
public function prepare($entity, array $field_info, array $instance, array $values) {
|
||||
if (isset($values['arguments'])) {
|
||||
$arguments = $values['arguments'];
|
||||
unset($values['arguments']);
|
||||
}
|
||||
else {
|
||||
$arguments = array();
|
||||
}
|
||||
|
||||
$language = $this->getFieldLanguage($entity, $field_info, $arguments);
|
||||
$migration = Migration::currentMigration();
|
||||
|
||||
// One can override the source class via CLI or drushrc.php (the
|
||||
// option is named file_function for historical reasons)
|
||||
if ($migration->getOption('file_function')) {
|
||||
$file_class = $migration->getOption('file_function');
|
||||
}
|
||||
elseif (!empty($arguments['file_class'])) {
|
||||
$file_class = $arguments['file_class'];
|
||||
}
|
||||
else {
|
||||
$file_class = 'MigrateFileUri';
|
||||
}
|
||||
|
||||
// If a destination directory (relative to the Drupal public files directory)
|
||||
// is not explicitly provided, use the default for the field.
|
||||
if (empty($arguments['destination_dir'])) {
|
||||
$arguments['destination_dir'] = $this->destinationDir($field_info, $instance);
|
||||
}
|
||||
|
||||
$return = array();
|
||||
$delta = 0;
|
||||
// Note that what $value represents depends on the file class -
|
||||
// MigrateFileUri expects a filespec/URI, MigrateFileFid expects a file ID,
|
||||
// etc.
|
||||
foreach ($values as $value) {
|
||||
if ($value) {
|
||||
// If the parent entity doesn't have an explicit uid, give ownership
|
||||
// to the anonymous account
|
||||
$owner = isset($entity->uid) ? $entity->uid : 0;
|
||||
// Call the MigrateFileInterface implementation to do the real work
|
||||
$source = new $file_class($arguments);
|
||||
$file = $source->processFile($value, $owner);
|
||||
|
||||
// Assuming we got back a valid file ID, build the proper field
|
||||
// array out of it. We assume that if we did not get back a fid, the
|
||||
// MigrateFile class has saved a message indicating why.
|
||||
if ($file) {
|
||||
$field_array = array('fid' => $file->fid);
|
||||
$return[$language][] = $this->buildFieldArray($field_array, $arguments, $delta);
|
||||
}
|
||||
}
|
||||
$delta++;
|
||||
}
|
||||
|
||||
return $return;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine where the migrated file should go.
|
||||
*
|
||||
* @param $field_info
|
||||
* Field API info on the general field.
|
||||
* @param $instance
|
||||
* Field API info on the field instance for this entity type.
|
||||
* @return string
|
||||
* Directory relative to the Drupal public files directory.
|
||||
*/
|
||||
protected function destinationDir($field_info, $instance) {
|
||||
$destination_dir = file_field_widget_uri($field_info, $instance);
|
||||
return $destination_dir;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add any type-specific subfields to a file field array.
|
||||
*
|
||||
* @param $field_array
|
||||
* The field array so far (generally will just contain a fid).
|
||||
* @param $arguments
|
||||
* Array of arguments passed to the field handler, from which we'll extract
|
||||
* our own subfields.
|
||||
* @param $delta
|
||||
* Index of field values being worked on, for pulling the corresponding
|
||||
* subfield values if we have an array of them.
|
||||
*/
|
||||
abstract protected function buildFieldArray($field_array, $arguments, $delta);
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle for file fields.
|
||||
*/
|
||||
class MigrateFileFieldHandler extends MigrateFileFieldBaseHandler {
|
||||
public function __construct() {
|
||||
$this->registerTypes(array('file'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of MigrateFieldHandler::fields().
|
||||
* Note that file and image fields support slightly different field lists.
|
||||
*
|
||||
* @param $type
|
||||
* The file field type - 'file' or 'image'
|
||||
* @param $parent_field
|
||||
* Name of the parent field.
|
||||
* @param Migration $migration
|
||||
* The migration context for the parent field. We can look at the mappings
|
||||
* and determine which subfields are relevant.
|
||||
* @return array
|
||||
*/
|
||||
public function fields($type, $parent_field, $migration = NULL) {
|
||||
$fields = parent::fields($type, $parent_field, $migration);
|
||||
$fields += array(
|
||||
'description' => t('Subfield: String to be used as the description value'),
|
||||
'display' => t('Subfield: String to be used as the display value'),
|
||||
);
|
||||
return $fields;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of MigrateFileFieldBaseHandler::buildFieldArray().
|
||||
*/
|
||||
protected function buildFieldArray($field_array, $arguments, $delta) {
|
||||
if (isset($arguments['description'])) {
|
||||
if (is_array($arguments['description'])) {
|
||||
$field_array['description'] = $arguments['description'][$delta];
|
||||
}
|
||||
else {
|
||||
$field_array['description'] = $arguments['description'];
|
||||
}
|
||||
}
|
||||
else {
|
||||
$field_array['description'] = '';
|
||||
}
|
||||
|
||||
if (isset($arguments['display'])) {
|
||||
if (is_array($arguments['display'])) {
|
||||
$field_array['display'] = $arguments['display'][$delta];
|
||||
}
|
||||
else {
|
||||
$field_array['display'] = $arguments['display'];
|
||||
}
|
||||
}
|
||||
else {
|
||||
$field_array['display'] = 1;
|
||||
}
|
||||
return $field_array;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle for image fields;
|
||||
*/
|
||||
class MigrateImageFieldHandler extends MigrateFileFieldBaseHandler {
|
||||
public function __construct() {
|
||||
$this->registerTypes(array('image'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of MigrateFieldHandler::fields().
|
||||
* Note that file and image fields support slightly different field lists.
|
||||
*
|
||||
* @param $type
|
||||
* The file field type - 'file' or 'image'
|
||||
* @param $parent_field
|
||||
* Name of the parent field.
|
||||
* @param Migration $migration
|
||||
* The migration context for the parent field. We can look at the mappings
|
||||
* and determine which subfields are relevant.
|
||||
* @return array
|
||||
*/
|
||||
public function fields($type, $parent_field, $migration = NULL) {
|
||||
$fields = parent::fields($type, $parent_field, $migration);
|
||||
$fields += array(
|
||||
'alt' => t('Subfield: String to be used as the alt value'),
|
||||
'title' => t('Subfield: String to be used as the title value'),
|
||||
);
|
||||
return $fields;
|
||||
}
|
||||
|
||||
/**
|
||||
* Implementation of MigrateFileFieldBaseHandler::buildFieldArray().
|
||||
*/
|
||||
protected function buildFieldArray($field_array, $arguments, $delta) {
|
||||
if (isset($arguments['alt'])) {
|
||||
if (is_array($arguments['alt'])) {
|
||||
$field_array['alt'] = $arguments['alt'][$delta];
|
||||
}
|
||||
else {
|
||||
$field_array['alt'] = $arguments['alt'];
|
||||
}
|
||||
}
|
||||
if (isset($arguments['title'])) {
|
||||
if (is_array($arguments['title'])) {
|
||||
$field_array['title'] = $arguments['title'][$delta];
|
||||
}
|
||||
else {
|
||||
$field_array['title'] = $arguments['title'];
|
||||
}
|
||||
}
|
||||
return $field_array;
|
||||
}
|
||||
}
|
||||
|
||||
class MigrateNodeReferenceFieldHandler extends MigrateSimpleFieldHandler {
|
||||
public function __construct() {
|
||||
parent::__construct(array(
|
||||
'value_key' => 'nid',
|
||||
'skip_empty' => TRUE,
|
||||
));
|
||||
$this->registerTypes(array('node_reference'));
|
||||
}
|
||||
}
|
||||
|
||||
class MigrateUserReferenceFieldHandler extends MigrateSimpleFieldHandler {
|
||||
public function __construct() {
|
||||
parent::__construct(array(
|
||||
'value_key' => 'uid',
|
||||
'skip_empty' => TRUE,
|
||||
));
|
||||
$this->registerTypes(array('user_reference'));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user