Service.php

Go to the documentation of this file.

<?php
 
namespace Drupal\dkan_metastore;
 
use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
use Drupal\dkan_common\DataModifierPluginTrait;
use Drupal\dkan_common\Plugin\DataModifierManager;
use Drupal\dkan_data\Reference\Dereferencer;
use Drupal\dkan_metastore\Exception\CannotChangeUuidException;
use Drupal\dkan_metastore\Exception\ExistingObjectException;
use Drupal\dkan_metastore\Exception\MissingObjectException;
use Drupal\dkan_metastore\Exception\UnmodifiedObjectException;
use Drupal\dkan_metastore\Factory\Sae;
use Drupal\dkan_schema\SchemaRetriever;
use Symfony\Component\DependencyInjection\ContainerInterface;
 
class Service implements ContainerInjectionInterface {
  use DataModifierPluginTrait;
 
  private $saeFactory;
 
  private $schemaRetriever;
 
  public static function create(ContainerInterface $container) {
    return new Service(
      $container->get('dkan_schema.schema_retriever'),
      $container->get('dkan_metastore.sae_factory')
    );
  }
 
  public function __construct(SchemaRetriever $schemaRetriever, Sae $saeFactory) {
    $this->schemaRetriever = $schemaRetriever;
    $this->saeFactory = $saeFactory;
  }
 
  public function setDataModifierPlugins(DataModifierManager $pluginManager) {
    $this->pluginManager = $pluginManager;
    $this->plugins = $this->discover();
  }
 
  public function getSchemas() {
    $schemas = [];
    foreach ($this->schemaRetriever->getAllIds() as $id) {
      $schema = $this->schemaRetriever->retrieve($id);
      $schemas[$id] = json_decode($schema);
    }
    return $schemas;
  }
 
  public function getSchema($identifier) {
    $schema = $this->schemaRetriever->retrieve($identifier);
    $schema = json_decode($schema);
 
    return $schema;
  }
 
  public function getAll($schema_id): array {
 
    $datasets = $this->getEngine($schema_id)->get();
 
    // $datasets is an array of JSON encoded string. Needs to be unflattened.
    $unflattened = array_map(
      function ($json_string) use ($schema_id) {
        if (!empty($this->plugins)) {
          $json_string = $this->modifyData($schema_id, $json_string);
        }
        return json_decode($json_string);
      },
      $datasets
    );
 
    return $unflattened;
  }
 
  public function get($schema_id, $identifier): string {
    $data = $this->getEngine($schema_id)
      ->get($identifier);
    if (!empty($this->plugins)) {
      $data = $this->modifyData($schema_id, $data);
    }
    return $data;
  }
 
  private function modifyData(string $schema_id, string $data) {
    $dataObj = json_decode($data);
 
    foreach ($this->plugins as $plugin) {
      if ($plugin->requiresModification($schema_id, $dataObj)) {
        $dataObj = $plugin->modify($schema_id, $dataObj);
      }
    }
 
    return json_encode($dataObj);
  }
 
  public function getResources($schema_id, $identifier): array {
 
    // Load this dataset's metadata with both data and identifiers.
    if (function_exists('drupal_static')) {
      drupal_static('dkan_data_dereference_method', Dereferencer::DEREFERENCE_OUTPUT_REFERENCE_IDS);
    }
 
    $json = $this->getEngine($schema_id)
      ->get($identifier);
    $data = json_decode($json);
    /* @todo decouple from POD. */
    $resources = $data->distribution;
 
    return $resources;
  }
 
  public function post($schema_id, string $data): string {
    // If resource already exists, return HTTP 409 Conflict and existing uri.
    $decoded = json_decode($data, TRUE);
    if (isset($decoded['identifier'])) {
      $identifier = $decoded['identifier'];
      if ($this->objectExists($schema_id, $identifier)) {
        throw new ExistingObjectException("{$schema_id}/{$identifier} already exists.");
      }
    }
 
    return $this->getEngine($schema_id)->post($data);
  }
 
  public function put($schema_id, $identifier, string $data): array {
    $obj = json_decode($data);
    if (isset($obj->identifier) && $obj->identifier != $identifier) {
      throw new CannotChangeUuidException("Identifier cannot be modified");
    }
    elseif ($this->objectExists($schema_id, $identifier) && $this->objectIsEquivalent($schema_id, $identifier, $data)) {
      throw new UnmodifiedObjectException("No changes to {$schema_id} with identifier {$identifier}.");
    }
    else {
      return $this->proceedWithPut($schema_id, $identifier, $data);
    }
  }
 
  private function proceedWithPut($schema_id, $identifier, string $data): array {
    if ($this->objectExists($schema_id, $identifier)) {
      $this->getEngine($schema_id)->put($identifier, $data);
      return ['identifier' => $identifier, 'new' => FALSE];
    }
    else {
      $this->getEngine($schema_id)->post($data);
      return ['identifier' => $identifier, 'new' => TRUE];
    }
  }
 
  public function patch($schema_id, $identifier, $data) {
    $engine = $this->getEngine($schema_id);
    if ($this->objectExists($schema_id, $identifier)) {
      $engine->patch($identifier, $data);
      return $identifier;
    }
 
    throw new MissingObjectException("No data with the identifier {$identifier} was found.");
  }
 
  public function delete($schema_id, $identifier) {
    $engine = $this->getEngine($schema_id);
 
    $engine->delete($identifier);
 
    return $identifier;
  }
 
  public function getCatalog() {
    $catalog = $this->getSchema('catalog');
    $catalog->dataset = $this->getAll('dataset');
 
    return $catalog;
  }
 
  private function objectExists($schemaId, $identifier) {
    try {
      $this->getEngine($schemaId)->get($identifier);
      return TRUE;
    }
    catch (\Exception $e) {
      return FALSE;
    }
  }
 
  private function objectIsEquivalent(string $schema_id, string $identifier, string $new_metadata) {
    $existing_metadata = $this->getEngine($schema_id)->get($identifier);
    return json_decode($new_metadata) == json_decode($existing_metadata);
  }
 
  private function getEngine($schemaId) {
    return $this->saeFactory->getInstance($schemaId);
  }
 
}