Resource.php

Go to the documentation of this file.

<?php
 
namespace Drupal\common;
 
use Procrastinator\HydratableTrait;
use Procrastinator\JsonSerializeTrait;
 
class Resource implements \JsonSerializable {
  use HydratableTrait, JsonSerializeTrait;
 
  const DEFAULT_SOURCE_PERSPECTIVE = 'source';
 
  private $filePath;
  private $identifier;
  private $mimeType;
  private $perspective;
  private $version;
 
  public function __construct($file_path, $mime_type, $perspective = self::DEFAULT_SOURCE_PERSPECTIVE) {
    // @todo generate UUID instead.
    $this->identifier = md5($file_path);
    $this->filePath = $file_path;
    $this->mimeType = $mime_type;
    $this->perspective = $perspective;
    // @todo Create a timestamp property and generate uuid for version.
    $this->version = time();
  }
 
  public function createNewVersion() {
    $newVersion = time();
    if ($newVersion == $this->version) {
      $newVersion++;
    }
 
    return $this->createCommon('version', $newVersion);
  }
 
  public function createNewPerspective($perspective, $uri) {
    $new = $this->createCommon('perspective', $perspective);
    $new->changeFilePath($uri);
    return $new;
  }
 
  public function changeFilePath($newPath) {
    $this->filePath = $newPath;
  }
 
  private function createCommon($property, $value) {
    $current = $this->{$property};
    $new = $value;
    $this->{$property} = $new;
    $newResource = clone $this;
    $this->{$property} = $current;
    return $newResource;
  }
 
  public function getIdentifier() {
    return $this->identifier;
  }
 
  public function getFilePath() {
    return $this->filePath;
  }
 
  public function getFolder() {
    return dirname($this->filePath);
  }
 
  public function getMimeType() {
    return $this->mimeType;
  }
 
  public function getVersion() {
    return $this->version;
  }
 
  public function getPerspective() {
    return $this->perspective;
  }
 
  public function getUniqueIdentifier() {
    return "{$this->identifier}__{$this->version}__{$this->perspective}";
  }
 
  public function jsonSerialize() {
    return $this->serialize();
  }
 
  public static function parseUniqueIdentifier(string $uid): array {
    $pieces = explode("__", $uid);
    if (count($pieces) != 3) {
      throw new \Exception("Badly constructed unique identifier {$uid}");
    }
    return [
      'identifier' => $pieces[0],
      'version' => $pieces[1],
      'perspective' => $pieces[2],
    ];
  }
 
  public static function getIdentifierAndVersion($string) {
    // Complete unique identifier.
    try {
      $parts = self::parseUniqueIdentifier($string);
      return [$parts['identifier'], $parts['version']];
    }
    catch (\Exception $e) {
    }
 
    // Partial identifier.
    if (substr_count($string, '__') > 0) {
      $parts = explode("__", $string);
      if (count($parts) == 2) {
        return $parts;
      }
    }
 
    $distribution = self::getDistribution($string);
 
    // Are we dealing with a distribution id?
    if (isset($distribution->data->{"%Ref:downloadURL"})) {
      $resource = $distribution->data->{"%Ref:downloadURL"}[0]->data;
      return [$resource->identifier, $resource->version];
    }
 
    throw new \Exception("Could not find identifier and version for {$string}");
  }
 
  private static function getDistribution($identifier) {
    $factory = \Drupal::service('dkan.metastore.storage');
 
    $storage = $factory->getInstance('distribution');
 
    $distroJson = $storage->retrieve($identifier);
    return json_decode($distroJson);
  }
 
}