Resource.php

Go to the documentation of this file.

<?php
 
namespace Drupal\dkan_datastore\Service;
 
use Drupal\dkan_datastore\Storage\JobStoreFactory;
use Procrastinator\Result;
use FileFetcher\FileFetcher;
use Dkan\Datastore\Resource as R;
use Drupal\Core\Entity\EntityRepository;
use Drupal\Core\File\FileSystem;
use Drupal\node\NodeInterface;
 
class Resource {
  const DEFAULT_TIMELIMIT = 50;
 
  private $uuid;
  private $entityRepository;
  private $fileSystem;
  private $jobStoreFactory;
 
  public function __construct(
    string $uuid,
    EntityRepository $entityRepository,
    FileSystem $fileSystem,
    JobStoreFactory $jobStoreFactory
  ) {
    $this->uuid = $uuid;
    $this->entityRepository = $entityRepository;
    $this->fileSystem = $fileSystem;
    $this->jobStoreFactory = $jobStoreFactory;
  }
 
  public function get($useFileFetcher = FALSE, $runFileFetcher = TRUE): ?R {
    $node = $this->entityRepository->loadEntityByUuid('node', $this->uuid);
    if (!$node) {
      return NULL;
    }
 
    if ($useFileFetcher == TRUE) {
      return $this->getResourceFromFileFetcher($node, $runFileFetcher);
    }
    else {
      return new R($node->id(), $this->getResourceFilePathFromNode($node), $this->getMimeType($node));
    }
  }
 
  public function remove() {
    $fileFetcher = $this->getFileFetcher();
    $filePath = $fileFetcher->getStateProperty('destination');
    if (file_exists($filePath)) {
      unlink($filePath);
    }
    $this->jobStoreFactory->getInstance(FileFetcher::class)->remove($this->uuid);
  }
 
  public function getResult(): Result {
    $fileFetcher = $this->getFileFetcher();
    return isset($fileFetcher) ? $fileFetcher->getResult() : new Result();
  }
 
  protected function getFileFetcherInstance($filePath, $tmpDirectory) {
    $fileFetcher = FileFetcher::get($this->uuid, $this->jobStoreFactory->getInstance(FileFetcher::class), [
      'filePath' => $filePath,
      'temporaryDirectory' => $tmpDirectory,
    ]);
    $fileFetcher->setTimeLimit(self::DEFAULT_TIMELIMIT);
    return $fileFetcher;
  }
 
  public function getFileFetcher(): FileFetcher {
 
    $node = $this->entityRepository->loadEntityByUuid('node', $this->uuid);
 
    if (!$node) {
      throw new \Exception("No node found for uuid {$this->uuid}");
    }
 
    $filePath = $this->getResourceFilePathFromNode($node);
 
    $tmpDirectory = $this->fileSystem->realpath("public://") . "/dkan-tmp";
    $this->fileSystem->prepareDirectory($tmpDirectory, FileSystem::CREATE_DIRECTORY | FileSystem::MODIFY_PERMISSIONS);
 
    return $this->getFileFetcherInstance($filePath, $tmpDirectory);
  }
 
  private function getResourceFilePathFromNode(NodeInterface $node): string {
 
    $meta = $node->get('field_json_metadata')->getString();
 
    if (!isset($meta)) {
      throw new \Exception("Entity for {$node->uuid()} does not have required field `field_json_metadata`.");
    }
 
    $metadata = json_decode($meta);
 
    if (!($metadata instanceof \stdClass)) {
      throw new \Exception("Invalid metadata information or missing file information.");
    }
 
    if (isset($metadata->data->downloadURL)) {
      return $metadata->data->downloadURL;
    }
 
    throw new \Exception("Invalid metadata information or missing file information.");
  }
 
  private function getResourceFromFileFetcher($node, $runFileFetcher) {
    $fileFetcher = $this->getFileFetcher($this->uuid);
 
    if ($runFileFetcher) {
      $fileFetcher->run();
    }
 
    if ($fileFetcher->getResult()->getStatus() != Result::DONE) {
      return NULL;
    }
 
    $json = $fileFetcher->getResult()->getData();
    $fileData = json_decode($json);
    return new R($node->id(), $fileData->destination, $this->getMimeType($node));
  }
 
  private function getMimeType(NodeInterface $node) : ?string {
    $metadata = json_decode($node->get('field_json_metadata')->getString());
    return $metadata->data->mediaType ?? NULL;
  }
 
}