Пример #1
0
 public function unresolveDependencies($subset = false, $subtype = false)
 {
     // Create a clone of the definition so we don't muck up the entity cache.
     $this->unresolved_definition = $subset === false ? $this->entity->definition : $subset;
     if (!is_object($this->unresolved_definition)) {
         $this->unresolved_definition = (object) $this->unresolved_definition;
     }
     // Generate the list of handlers for each of the fields.
     $handlers = DefinitionHandlerRegistry::getFieldHandlers($this->entity, $this->unresolved_definition, $subtype);
     foreach ($handlers as $field_name => $handler) {
         if (!isset($this->unresolved_definition->{$field_name})) {
             continue;
         }
         foreach ($handler['handlers'] as $single_handler) {
             if (!$single_handler instanceof DefinitionHandlerBase) {
                 continue;
             }
             try {
                 $single_handler->entity =& $this->entity;
                 $single_handler->unresolved_definition =& $this->unresolved_definition;
                 $single_handler->unhandleField($this->entity->type(), $handler['type'], $field_name, $this->unresolved_definition->{$field_name});
             } catch (\Exception $ex) {
                 $message = t('Error processing field "@fieldName" - "@message"', array('@fieldName' => $field_name, '@message' => $ex->getMessage()));
                 \watchdog('publisher', $message, array(), WATCHDOG_WARNING);
                 $this->errors[] = $ex;
             }
         }
     }
 }
Пример #2
0
 public function resolveDependencies($recurse = true, $subset = false, $child = false, $subtype = false)
 {
     // Check to see if the resolved definition already exists in the cached list.
     $cached_resolutions =& drupal_static('publisher_cached_resolutions', array());
     $key = $this->base_entity->uuid() . '|' . $this->base_entity->type();
     if ($this->base_entity->supportsRevisions()) {
         $key .= '|' . $this->base_entity->vuuid();
     }
     $key .= $recurse ? '|recurse' : '';
     if (array_key_exists($key, $cached_resolutions) && $child === false && $subset === false) {
         $this->dependencies = array_replace_recursive($this->dependencies, $cached_resolutions[$key]['dependencies']);
         $this->relationships = array_merge($this->relationships, $cached_resolutions[$key]['relationships']);
         $this->resolved_definition = $cached_resolutions[$key]['resolved_definition'];
         return;
     }
     if (count($cached_resolutions) > 200) {
         // For memory consumption purposes.
         drupal_static_reset('publisher_cached_resolutions');
     }
     // Create a clone of the definition so we don't muck up the entity cache.
     $this->resolved_definition = $subset !== false ? $subset : clone $this->entity->definition;
     if (!is_object($this->resolved_definition)) {
         $this->resolved_definition = (object) $this->resolved_definition;
     }
     // Generate the list of handlers for each of the fields.
     $handlers = DefinitionHandlerRegistry::getFieldHandlers($this->entity, $this->resolved_definition, $subtype);
     foreach ($handlers as $field_name => $handler) {
         if (!isset($this->resolved_definition->{$field_name})) {
             continue;
         }
         foreach ($handler['handlers'] as $single_handler) {
             if (!$single_handler instanceof DefinitionHandlerBase) {
                 continue;
             }
             try {
                 $single_handler->dependencies =& $this->dependencies;
                 $single_handler->entity =& $this->entity;
                 $single_handler->original_entity = $this->base_entity;
                 if (property_exists($single_handler, 'relationships')) {
                     $single_handler->relationships =& $this->relationships;
                 }
                 $single_handler->handleField($this->entity->type(), $handler['type'], $field_name, $this->resolved_definition->{$field_name});
             } catch (\Exception $ex) {
                 $message = t('Error processing field "@fieldName" - "@message"', array('@fieldName' => $field_name, '@message' => $ex->getMessage()));
                 \watchdog('publisher', $message, array(), WATCHDOG_WARNING);
                 $this->errors[] = $ex;
             }
         }
     }
     // Now, recursion.
     if ($recurse) {
         foreach ($this->dependencies as $identifier => $dependency) {
             // If the dependency has already been handled, skip it.
             if (array_key_exists($identifier, self::$handled_dependencies)) {
                 continue;
             }
             // Add the dependency to the list of handled ones.
             self::$handled_dependencies[$identifier] = $dependency;
             // Load the entity and get its dependencies.
             $entity = Entity::loadByUUID($dependency['uuid'], $dependency['entity_type']);
             // If for some reason the entity fails, we need to just skip it.
             if (!$entity) {
                 continue;
             }
             // Make sure the entity is not the current entity to prevent infinite loop.
             if ($entity->uuid() == $this->entity->uuid()) {
                 continue;
             }
             $resolver = new self($entity, false, $this->dependencies);
             $resolver->relationships =& $this->relationships;
             $resolver->metadata =& $this->metadata;
             $resolver->resolveDependencies(true, false, true);
             $this->dependencies = $resolver->dependencies();
         }
     }
     // Add a dependency for the entity itself if it doesn't already exist.
     if (!array_key_exists($this->base_entity->uuid(), $this->dependencies) || $this->base_entity->supportsRevisions() && !empty($this->dependencies[$this->base_entity->uuid()]['original_revision']) && $this->base_entity->revision() > $this->dependencies[$this->base_entity->uuid()]['original_revision']) {
         $this->dependencies[$this->base_entity->uuid()] = HandlerBase::createReferenceDefinition($this->base_entity);
     }
     // Pass the entity through the entity handlers.
     if (!array_key_exists($this->base_entity->uuid(), $this->metadata) && $recurse) {
         $this->metadata[$this->base_entity->uuid()] = array();
         foreach (EntityHandlerRegistry::getEntityHandlers($this->base_entity) as $handler) {
             if (!$handler instanceof EntityHandlerBase) {
                 continue;
             }
             $handler->entity =& $this->entity;
             $handler->original_entity = $this->base_entity;
             $handler->dependencies =& $this->dependencies;
             $handler->handleEntity($this->metadata[$this->base_entity->uuid()]);
         }
     }
     // Update the cache record.
     $cached_resolutions[$key] = array('dependencies' => $this->dependencies, 'relationships' => $this->relationships, 'resolved_definition' => $this->resolved_definition);
     if (!$child) {
         $dependency_dependencies =& drupal_static('publisher_dependency_dependencies', array());
         foreach ($dependency_dependencies as $source => $dependencies) {
             if (array_key_exists($source, $this->dependencies)) {
                 if (!array_key_exists('dependencies', $this->dependencies[$source]) || !is_array($this->dependencies[$source]['dependencies'])) {
                     $this->dependencies[$source]['dependencies'] = array();
                 }
                 $this->dependencies[$source]['dependencies'] = array_replace_recursive($this->dependencies[$source]['dependencies'], $dependencies);
                 $this->dependencies[$source]['dependencies'] = array_unique($this->dependencies[$source]['dependencies']);
             }
         }
         // Update the relationships.
         $this->updateRelationships();
         // Loop through all the dependencies and perform cleanup tasks.
         foreach ($this->dependencies as $dependency_key => &$dependency) {
             // Cleanup the sources.
             if (array_key_exists('sources', $dependency) && is_array($dependency['sources'])) {
                 $dependency['sources'] = array_unique($dependency['sources']);
             }
         }
         // Loop through again for the required stuff.
         foreach ($this->dependencies as $dependency_key => &$dependency) {
             // Create the 'required' key.
             if (array_key_exists('has_relationship', $dependency) && $dependency['has_relationship']) {
                 $dependency['required'] = false;
                 continue;
             }
             $this->dependencies[$dependency_key]['required'] = true;
             if (array_key_exists('sources', $this->dependencies[$dependency_key]) && is_array($this->dependencies[$dependency_key]['sources']) && count($this->dependencies[$dependency_key]['sources']) > 0) {
                 // Mark dependencies as not required only if all of their parent paths
                 // are marked as having relationships.
                 $sources = array();
                 foreach ($this->dependencies[$dependency_key]['sources'] as $source_uuid) {
                     $sources[] = $this->dependencies[$source_uuid];
                 }
                 $paths = $this->getAllParentTrails($sources);
                 $paths_with_notrequired = 0;
                 foreach ($paths as $path) {
                     foreach ($path as $item) {
                         if (!array_key_exists('required', $this->dependencies[$item]) || !$this->dependencies[$item]['required']) {
                             $paths_with_notrequired++;
                             break;
                         }
                     }
                 }
                 if ($paths_with_notrequired == count($paths)) {
                     $this->dependencies[$dependency_key]['required'] = false;
                 }
             } else {
                 // If the dependency doesn't have any sources, it is not
                 // required.
                 $this->dependencies[$dependency_key]['required'] = false;
             }
         }
         // Now, loop through the dependencies again and fill in their
         // 'required_if' values. If a dependency is marked as not required,
         // go through its trails and find the lowest parent that is marked
         // as having a relationship and add it to the 'required_if' list
         // if it isn't already there.
         foreach ($this->dependencies as $dependency_key => &$dependency) {
             $dependency['required_if'] = array();
             // If the dependency is marked as required already, is a relationship,
             // or doesn't have any sources, skip it.
             if ($dependency['required']) {
                 continue;
             }
             if (!array_key_exists('sources', $dependency) || !is_array($dependency['sources'])) {
                 continue;
             }
             // Loop through its parent trails to find the non-required items.
             $required_if = array();
             $sources = array();
             foreach ($dependency['sources'] as $source_uuid) {
                 // If the source UUID is the owner of the relationship, don't add it.
                 $skip = false;
                 foreach ($this->relationships as $relationship) {
                     if ($relationship['source_uuid'] == $source_uuid && $relationship['destination_uuid'] == $dependency['uuid']) {
                         $skip = true;
                         break;
                     }
                 }
                 if ($skip) {
                     continue;
                 }
                 $sources[] = $this->dependencies[$source_uuid];
             }
             $paths = $this->getAllParentTrails($sources);
             foreach ($paths as $path) {
                 $found = false;
                 foreach ($path as $index => $item) {
                     if (array_key_exists('has_relationship', $this->dependencies[$item]) && $this->dependencies[$item]['has_relationship']) {
                         $found = true;
                         $required_if[] = array_slice($path, 0, $index + 1);
                         break;
                     }
                 }
                 if (!$found) {
                     if (count($path) === 1) {
                         $required_if[] = $path;
                     } else {
                         for ($i = 1; $i < count($path); $i++) {
                             $required_if[] = array_slice($path, 0, $i);
                         }
                     }
                 }
             }
             // Add it to the dependency.
             $required_if_entities = array();
             foreach ($required_if as $path) {
                 $required_if_entities[] = end($path);
             }
             $dependency['required_if'] = array_unique($required_if_entities);
         }
         // Reset the dependency dependencies cache.
         drupal_static_reset('publisher_dependency_dependencies');
         // Finally, perform the topological sort on the dependencies.
         $this->topologicalSortDependencies();
     }
 }