class MigrationLookup

class MigrationLookup extends ProcessPluginBase implements ContainerFactoryPluginInterface {
    
    /**
     * The migration to be executed.
     *
     * @var \Drupal\migrate\Plugin\MigrationInterface
     */
    protected $migration;
    
    /**
     * The migrate lookup service.
     *
     * @var \Drupal\migrate\MigrateLookupInterface
     */
    protected $migrateLookup;
    
    /**
     * The migrate stub service.
     *
     * @var \Drupal\migrate\MigrateStubInterface
     */
    protected $migrateStub;
    
    /**
     * Constructs a MigrationLookup object.
     *
     * @param array $configuration
     *   A configuration array containing information about the plugin instance.
     * @param string $plugin_id
     *   The plugin_id for the plugin instance.
     * @param mixed $plugin_definition
     *   The plugin implementation definition.
     * @param \Drupal\migrate\Plugin\MigrationInterface $migration
     *   The Migration the plugin is being used in.
     * @param \Drupal\migrate\MigrateLookupInterface $migrate_lookup
     *   The migrate lookup service.
     * @param \Drupal\migrate\MigrateStubInterface $migrate_stub
     *   The migrate stub service.
     */
    public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration, MigrateLookupInterface $migrate_lookup, MigrateStubInterface $migrate_stub) {
        parent::__construct($configuration, $plugin_id, $plugin_definition);
        $this->migration = $migration;
        $this->migrateLookup = $migrate_lookup;
        $this->migrateStub = $migrate_stub;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration = NULL) {
        return new static($configuration, $plugin_id, $plugin_definition, $migration, $container->get('migrate.lookup'), $container->get('migrate.stub'));
    }
    
    /**
     * {@inheritdoc}
     *
     * @throws \Drupal\migrate\MigrateSkipProcessException
     * @throws \Drupal\migrate\MigrateException
     */
    public function transform($value, MigrateExecutableInterface $migrate_executable, Row $row, $destination_property) {
        $lookup_migration_ids = (array) $this->configuration['migration'];
        $self = FALSE;
        $destination_ids = NULL;
        $source_id_values = [];
        foreach ($lookup_migration_ids as $lookup_migration_id) {
            $lookup_value = $value;
            if ($lookup_migration_id == $this->migration
                ->id()) {
                $self = TRUE;
            }
            if (isset($this->configuration['source_ids'][$lookup_migration_id])) {
                $lookup_value = array_values($row->getMultiple($this->configuration['source_ids'][$lookup_migration_id]));
            }
            $lookup_value = (array) $lookup_value;
            $this->skipInvalid($lookup_value);
            $source_id_values[$lookup_migration_id] = $lookup_value;
            // Re-throw any PluginException as a MigrateException so the executable
            // can shut down the migration.
            try {
                $destination_id_array = $this->migrateLookup
                    ->lookup($lookup_migration_id, $lookup_value);
            } catch (PluginNotFoundException $e) {
                $destination_id_array = [];
            } catch (MigrateException $e) {
                throw $e;
            } catch (\Exception $e) {
                throw new MigrateException(sprintf('A %s was thrown while processing this migration lookup', gettype($e)), $e->getCode(), $e);
            }
            if ($destination_id_array) {
                $destination_ids = array_values(reset($destination_id_array));
                break;
            }
        }
        if (!$destination_ids && !empty($this->configuration['no_stub'])) {
            return NULL;
        }
        if (!$destination_ids && ($self || isset($this->configuration['stub_id']) || count($lookup_migration_ids) == 1)) {
            // If the lookup didn't succeed, figure out which migration will do the
            // stubbing.
            if ($self) {
                $stub_migration = $this->migration
                    ->id();
            }
            elseif (isset($this->configuration['stub_id'])) {
                $stub_migration = $this->configuration['stub_id'];
            }
            else {
                $stub_migration = reset($lookup_migration_ids);
            }
            // Rethrow any exception as a MigrateException so the executable can shut
            // down the migration.
            try {
                $destination_ids = $this->migrateStub
                    ->createStub($stub_migration, $source_id_values[$stub_migration], [], FALSE);
            } catch (\LogicException $e) {
                // For BC reasons, we must allow attempting to stub a derived migration.
            } catch (PluginNotFoundException $e) {
                // For BC reasons, we must allow attempting to stub a non-existent
                // migration.
            } catch (MigrateException $e) {
                throw $e;
            } catch (MigrateSkipRowException $e) {
                throw $e;
            } catch (\Exception $e) {
                throw new MigrateException(sprintf('%s was thrown while attempting to stub: %s', get_class($e), $e->getMessage()), $e->getCode(), $e);
            }
        }
        if ($destination_ids) {
            if (count($destination_ids) == 1) {
                return reset($destination_ids);
            }
            else {
                return $destination_ids;
            }
        }
    }
    
    /**
     * Skips the migration process entirely if the value is invalid.
     *
     * @param array $value
     *   The incoming value to check.
     *
     * @throws \Drupal\migrate\MigrateSkipProcessException
     */
    protected function skipInvalid(array $value) {
        if (!array_filter($value, [
            $this,
            'isValid',
        ])) {
            throw new MigrateSkipProcessException();
        }
    }
    
    /**
     * Determines if the value is valid for lookup.
     *
     * The only values considered invalid are: NULL, FALSE, [] and "".
     *
     * @param string $value
     *   The value to test.
     *
     * @return bool
     *   Return true if the value is valid.
     */
    protected function isValid($value) {
        return !in_array($value, [
            NULL,
            FALSE,
            [],
            "",
        ], TRUE);
    }

}