Referencer.php

Go to the documentation of this file.

<?php
 
namespace Drupal\metastore\Reference;
 
use Drupal\Core\Config\ConfigFactoryInterface;
 
use Drupal\common\LoggerTrait;
use Drupal\common\Resource;
use Drupal\common\UrlHostTokenResolver;
use Drupal\metastore\Exception\AlreadyRegistered;
use Drupal\metastore\ResourceMapper;
use Drupal\metastore\Service;
 
use Contracts\FactoryInterface;
use GuzzleHttp\Client as GuzzleClient;
 
class Referencer {
  use HelperTrait;
  use LoggerTrait;
 
  protected const DEFAULT_MIME_TYPE = 'text/plain';
 
  private $storageFactory;
 
  public function __construct(ConfigFactoryInterface $configService, FactoryInterface $storageFactory) {
    $this->setConfigService($configService);
    $this->storageFactory = $storageFactory;
    $this->setLoggerFactory(\Drupal::service('logger.factory'));
  }
 
  public function reference($data) {
    if (!is_object($data)) {
      throw new \Exception("data must be an object.");
    }
    // Cycle through the dataset properties we seek to reference.
    foreach ($this->getPropertyList() as $property_id) {
      if (isset($data->{$property_id})) {
        $data->{$property_id} = $this->referenceProperty($property_id, $data->{$property_id});
      }
    }
    return $data;
  }
 
  private function referenceProperty(string $property_id, $data) {
    if (is_array($data)) {
      return $this->referenceMultiple($property_id, $data);
    }
    else {
      // Case for $data being an object or a string.
      return $this->referenceSingle($property_id, $data);
    }
  }
 
  private function referenceMultiple(string $property_id, array $values) : array {
    $result = [];
    foreach ($values as $value) {
      $data = $this->referenceSingle($property_id, $value);
      if (NULL !== $data) {
        $result[] = $data;
      }
    }
    return $result;
  }
 
  private function referenceSingle(string $property_id, $value) {
 
    if ($property_id == 'distribution') {
      $value = $this->distributionHandling($value);
    }
 
    $uuid = $this->checkExistingReference($property_id, $value);
    if (!$uuid) {
      $uuid = $this->createPropertyReference($property_id, $value);
    }
    if ($uuid) {
      return $uuid;
    }
    else {
      $this->log(
        'value_referencer',
        'Neither found an existing nor could create a new reference for property_id: @property_id with value: @value',
        [
          '@property_id' => $property_id,
          '@value' => var_export($value, TRUE),
        ]
      );
      return NULL;
    }
  }
 
  private function distributionHandling($distribution): object {
    // Ensure the supplied distribution has a valid resource before attempting
    // to register it with the resource mapper.
    if (is_object($distribution) && isset($distribution->downloadURL)) {
      // Register this distribution's resource with the resource mapper and
      // replace the download URL with a unique ID registered in the resource
      // mapper.
      $distribution->downloadURL = $this->registerWithResourceMapper(
        $this->hostify($distribution->downloadURL), $this->getMimeType($distribution));
    }
 
    return $distribution;
  }
 
  private function registerWithResourceMapper(string $downloadUrl, string $mimeType): string {
    try {
      // Create a new resource using the supplied resource details.
      $resource = new Resource($downloadUrl, $mimeType);
 
      // Attempt to register the url with the resource file mapper.
      if ($this->getFileMapper()->register($resource)) {
        // Upon successful registration, replace the download URL with a unique
        // ID generated by the resource mapper.
        $downloadUrl = $resource->getUniqueIdentifier();
      }
    }
    catch (AlreadyRegistered $e) {
      $info = json_decode($e->getMessage());
 
      // If resource mapper registration failed due to this resource already
      // being registered, generate a new version of the resource and update the
      // download URL with the new version ID.
      if (isset($info[0]->identifier)) {
        $stored = $this->getFileMapper()->get($info[0]->identifier, Resource::DEFAULT_SOURCE_PERSPECTIVE);
        $downloadUrl = $this->handleExistingResource($info, $stored, $mimeType);
      }
    }
 
    return $downloadUrl;
  }
 
  private function handleExistingResource($info, $stored, $mimeType) {
    if ($info[0]->perspective == Resource::DEFAULT_SOURCE_PERSPECTIVE &&
      (ResourceMapper::newRevision() == 1 || $stored->getMimeType() != $mimeType)) {
      $new = $stored->createNewVersion();
      // Update the MIME type, since this may be updated by the user.
      $new->changeMimeType($mimeType);
 
      $this->getFileMapper()->registerNewVersion($new);
      $downloadUrl = $new->getUniqueIdentifier();
    }
    else {
      $downloadUrl = $stored->getUniqueIdentifier();
    }
    return $downloadUrl;
  }
 
  private function getFileMapper(): ResourceMapper {
    return \Drupal::service('dkan.metastore.resource_mapper');
  }
 
  public static function hostify(string $resourceUrl): string {
    // Get HTTP server public files URL and extract the host.
    $serverPublicFilesUrl = UrlHostTokenResolver::getServerPublicFilesUrl();
    $serverPublicFilesUrl = isset($serverPublicFilesUrl) ? parse_url($serverPublicFilesUrl) : NULL;
    $serverHost = $serverPublicFilesUrl['host'] ?? \Drupal::request()->getHost();
    // Determine whether the resource URL has the same host as this server.
    $resourceParsedUrl = parse_url($resourceUrl);
    if (isset($resourceParsedUrl['host']) && $resourceParsedUrl['host'] == $serverHost) {
      // Swap out the host portion of the resource URL with the localhost token.
      $resourceParsedUrl['host'] = UrlHostTokenResolver::TOKEN;
      $resourceUrl = self::unparseUrl($resourceParsedUrl);
    }
    return $resourceUrl;
  }
 
  private static function unparseUrl($parsedUrl) {
    $url = '';
    $urlParts = [
      'scheme',
      'host',
      'port',
      'user',
      'pass',
      'path',
      'query',
      'fragment',
    ];
 
    foreach ($urlParts as $part) {
      if (!isset($parsedUrl[$part])) {
        continue;
      }
      $url .= ($part == "port") ? ':' : '';
      $url .= ($part == "query") ? '?' : '';
      $url .= ($part == "fragment") ? '#' : '';
      $url .= $parsedUrl[$part];
      $url .= ($part == "scheme") ? '://' : '';
    }
 
    return $url;
  }
 
  private function getLocalMimeType(string $downloadUrl): ?string {
    $mime_type = NULL;
 
    // Retrieve and decode the file name from the supplied download URL's path.
    $filename = \Drupal::service('file_system')->basename($downloadUrl);
    $filename = urldecode($filename);
 
    // Attempt to load the file by file name.
    $files = \Drupal::entityTypeManager()
      ->getStorage('file')
      ->loadByProperties(['filename' => $filename]);
    $file = reset($files);
 
    // If a valid file was found for the given file name, extract the file's
    // mime type...
    if ($file !== FALSE) {
      $mime_type = $file->getMimeType();
    }
    // Otherwise, log an error notifying the user that a file was not found.
    else {
      $this->log('value_referencer', 'Unable to determine mime type of file with name "@name", because no file was found with that name.', [
        '@name' => $filename,
      ]);
    }
 
    return $mime_type;
  }
 
  private function getRemoteMimeType(string $downloadUrl): ?string {
    $mime_type = NULL;
 
    // Perform HTTP Head request against the supplied URL in order to determine
    // the content type of the remote resource.
    $client = new GuzzleClient();
    $response = $client->head($downloadUrl);
    // Extract the full value of the content type header.
    $content_type = $response->getHeader('Content-Type');
    // Attempt to extract the mime type from the content type header.
    if (isset($content_type[0])) {
      $mime_type = $content_type[0];
    }
 
    return $mime_type;
  }
 
  private function getMimeType($distribution): string {
    $mimeType = "text/plain";
 
    // If we have a mediaType set, use that.
    if (isset($distribution->mediaType)) {
      $mimeType = $distribution->mediaType;
    }
    // Fall back if we have an importable format set.
    elseif (isset($distribution->format) && $distribution->format == 'csv') {
      $mimeType = 'text/csv';
    }
    elseif (isset($distribution->format) && $distribution->format == 'tsv') {
      $mimeType = 'text/tab-separated-values';
    }
    // Otherwise, determine the proper mime type using the distribution's
    // download URL.
    elseif (isset($distribution->downloadURL)) {
      // Determine whether the supplied distribution has a local or remote
      // resource.
      $is_local = $distribution->downloadURL !== $this->hostify($distribution->downloadURL);
      $mimeType = $is_local ?
        $this->getLocalMimeType($distribution->downloadURL) :
        $this->getRemoteMimeType($distribution->downloadURL);
    }
 
    return $mimeType ?? self::DEFAULT_MIME_TYPE;
  }
 
  private function checkExistingReference(string $property_id, $data) {
    $storage = $this->storageFactory->getInstance($property_id);
    $nodes = $storage->getEntityStorage()->loadByProperties([
      'field_data_type' => $property_id,
      'title' => Service::metadataHash($data),
    ]);
 
    if ($node = reset($nodes)) {
      // If an existing but orphaned data node is found,
      // change the state back to published.
      // @ToDo: if the referencing node is in a draft state, do not publish the referenced node.
      $node->set('moderation_state', 'published');
      $node->save();
      return $node->uuid();
    }
    return NULL;
  }
 
  private function createPropertyReference(string $property_id, $value) {
    // Create json metadata for the reference.
    $data = new \stdClass();
    $data->identifier = $this->getUuidService()->generate($property_id, $value);
    $data->data = $value;
    $json = json_encode($data);
 
    // Create node to store this reference.
    $storage = $this->storageFactory->getInstance($property_id);
    $entity_uuid = $storage->store($json, $data->identifier);
    return $entity_uuid;
  }
 
}