449 lines
17 KiB
PHP
449 lines
17 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
/**
|
|
* SPDX-FileCopyrightText: Sebastian Krupinski <krupinski01@gmail.com>
|
|
* SPDX-License-Identifier: AGPL-3.0-or-later
|
|
*/
|
|
|
|
namespace KTXM\ProviderLocalPeople\Providers\Personal;
|
|
|
|
use KTXF\People\Collection\CollectionBaseInterface;
|
|
use KTXF\People\Collection\CollectionMutableInterface;
|
|
use KTXF\People\Entity\EntityMutableInterface;
|
|
use KTXF\People\Service\ServiceBaseInterface;
|
|
use KTXF\People\Service\ServiceCollectionMutableInterface;
|
|
use KTXF\People\Service\ServiceEntityMutableInterface;
|
|
use KTXF\Resource\Delta\Delta;
|
|
use KTXF\Resource\Delta\DeltaCollection;
|
|
use KTXF\Resource\Exceptions\InvalidParameterException;
|
|
use KTXF\Resource\Filter\Filter;
|
|
use KTXF\Resource\Filter\IFilter;
|
|
use KTXF\Resource\Range\IRange;
|
|
use KTXF\Resource\Range\RangeTally;
|
|
use KTXF\Resource\Range\RangeType;
|
|
use KTXF\Resource\Sort\ISort;
|
|
use KTXF\Resource\Sort\Sort;
|
|
use KTXM\ProviderLocalPeople\Store\Personal\Store;
|
|
|
|
class PersonalService implements ServiceBaseInterface, ServiceCollectionMutableInterface, ServiceEntityMutableInterface {
|
|
|
|
public const JSON_TYPE = ServiceBaseInterface::JSON_TYPE;
|
|
|
|
private const PROVIDER_IDENTIFIER = 'default';
|
|
private const SERVICE_IDENTIFIER = 'personal';
|
|
private const SERVICE_LABEL = 'Personal Calendar Service';
|
|
|
|
protected array $serviceCollectionCache = [];
|
|
protected ?string $serviceTenantId = null;
|
|
protected ?string $serviceUserId = null;
|
|
protected ?bool $serviceEnabled = true;
|
|
|
|
private array $serviceAbilities = [
|
|
self::CAPABILITY_COLLECTION_LIST => true,
|
|
self::CAPABILITY_COLLECTION_LIST_FILTER => [
|
|
self::CAPABILITY_COLLECTION_FILTER_LABEL => 's:100:256:256',
|
|
],
|
|
self::CAPABILITY_COLLECTION_LIST_SORT => [
|
|
self::CAPABILITY_COLLECTION_SORT_LABEL,
|
|
self::CAPABILITY_COLLECTION_SORT_RANK,
|
|
],
|
|
self::CAPABILITY_COLLECTION_EXTANT => true,
|
|
self::CAPABILITY_COLLECTION_FETCH => true,
|
|
self::CAPABILITY_COLLECTION_CREATE => true,
|
|
self::CAPABILITY_COLLECTION_UPDATE => true,
|
|
self::CAPABILITY_COLLECTION_DELETE => true,
|
|
self::CAPABILITY_ENTITY_LIST => true,
|
|
self::CAPABILITY_ENTITY_LIST_FILTER => [
|
|
self::CAPABILITY_ENTITY_FILTER_ALL => 's:200:256:256',
|
|
self::CAPABILITY_ENTITY_FILTER_ID => 's:100:256:256',
|
|
self::CAPABILITY_ENTITY_FILTER_URID => 's:100:256:256',
|
|
self::CAPABILITY_ENTITY_FILTER_LABEL => 's:100:256:256',
|
|
],
|
|
self::CAPABILITY_ENTITY_LIST_SORT => [
|
|
self::CAPABILITY_ENTITY_SORT_ID,
|
|
self::CAPABILITY_ENTITY_SORT_URID,
|
|
],
|
|
self::CAPABILITY_ENTITY_LIST_RANGE => [
|
|
self::CAPABILITY_ENTITY_RANGE_TALLY => [
|
|
self::CAPABILITY_ENTITY_RANGE_TALLY_ABSOLUTE,
|
|
self::CAPABILITY_ENTITY_RANGE_TALLY_RELATIVE
|
|
],
|
|
],
|
|
self::CAPABILITY_ENTITY_DELTA => true,
|
|
self::CAPABILITY_ENTITY_EXTANT => true,
|
|
self::CAPABILITY_ENTITY_FETCH => true,
|
|
self::CAPABILITY_ENTITY_CREATE => true,
|
|
self::CAPABILITY_ENTITY_UPDATE => true,
|
|
self::CAPABILITY_ENTITY_DELETE => true,
|
|
];
|
|
|
|
public function __construct(
|
|
private Store $store,
|
|
) {}
|
|
|
|
public function initialize(string $tenantId, string $userId): self {
|
|
$this->serviceTenantId = $tenantId;
|
|
$this->serviceUserId = $userId;
|
|
return $this;
|
|
}
|
|
|
|
public function jsonSerialize(): array {
|
|
return array_filter([
|
|
self::JSON_PROPERTY_TYPE => self::JSON_TYPE,
|
|
self::JSON_PROPERTY_PROVIDER => self::PROVIDER_IDENTIFIER,
|
|
self::JSON_PROPERTY_IDENTIFIER => self::SERVICE_IDENTIFIER,
|
|
self::JSON_PROPERTY_LABEL => self::SERVICE_LABEL,
|
|
self::JSON_PROPERTY_ENABLED => $this->serviceEnabled,
|
|
self::JSON_PROPERTY_CAPABILITIES => $this->serviceAbilities,
|
|
self::JSON_PROPERTY_LOCATION => null,
|
|
self::JSON_PROPERTY_IDENTITY => null,
|
|
self::JSON_PROPERTY_AUXILIARY => [],
|
|
], fn($v) => $v !== null);
|
|
}
|
|
|
|
public function capable(string $value): bool {
|
|
if (isset($this->serviceAbilities[$value])) {
|
|
return (bool)$this->serviceAbilities[$value];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public function capabilities(): array {
|
|
return $this->serviceAbilities;
|
|
}
|
|
|
|
public function provider(): string
|
|
{
|
|
return self::PROVIDER_IDENTIFIER;
|
|
}
|
|
|
|
public function identifier(): string {
|
|
return self::SERVICE_IDENTIFIER;
|
|
}
|
|
|
|
public function getLabel(): string {
|
|
return (string)self::SERVICE_LABEL;
|
|
}
|
|
|
|
public function getEnabled(): bool {
|
|
return (bool)$this->serviceEnabled;
|
|
}
|
|
|
|
public function setEnabled(bool $enabled): static
|
|
{
|
|
$this->serviceEnabled = $enabled;
|
|
return $this;
|
|
}
|
|
|
|
public function getLocation(): null
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public function getIdentity(): null
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public function getAuxiliary(): array
|
|
{
|
|
return [];
|
|
}
|
|
|
|
// Collection operations
|
|
|
|
public function collectionList(string|int|null $location, ?IFilter $filter = null, ?ISort $sort = null): array {
|
|
$entries = $this->store->collectionList($this->serviceTenantId, $this->serviceUserId, $filter, $sort);
|
|
$this->serviceCollectionCache = $entries;
|
|
return $entries ?? [];
|
|
}
|
|
|
|
public function collectionListFilter(): Filter {
|
|
return new Filter($this->serviceAbilities[self::CAPABILITY_COLLECTION_LIST_FILTER] ?? []);
|
|
}
|
|
|
|
public function collectionListSort(): Sort {
|
|
return new Sort($this->serviceAbilities[self::CAPABILITY_COLLECTION_LIST_SORT] ?? []);
|
|
}
|
|
|
|
public function collectionExtant(string|int $location, string|int ...$identifiers): array {
|
|
$resolvedIdentifiers = $identifiers !== [] ? $identifiers : [$location];
|
|
$response = [];
|
|
|
|
foreach ($resolvedIdentifiers as $identifier) {
|
|
if (isset($this->serviceCollectionCache[$identifier])) {
|
|
$response[$identifier] = true;
|
|
continue;
|
|
}
|
|
|
|
$exists = $this->store->collectionExtant($this->serviceTenantId, $this->serviceUserId, (string)$identifier);
|
|
$response[$identifier] = $exists;
|
|
|
|
if ($exists) {
|
|
$collection = $this->store->collectionFetch($this->serviceTenantId, $this->serviceUserId, (string)$identifier);
|
|
if ($collection !== null) {
|
|
$this->serviceCollectionCache[$identifier] = $collection;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $response;
|
|
}
|
|
|
|
public function collectionFetch(string|int $identifier): ?CollectionBaseInterface {
|
|
// determine if collection is cached
|
|
if (isset($this->serviceCollectionCache[$identifier])) {
|
|
return $this->serviceCollectionCache[$identifier];
|
|
}
|
|
// retrieve from store
|
|
$collection = $this->store->collectionFetch($this->serviceTenantId, $this->serviceUserId, (string)$identifier);
|
|
if ($collection !== null) {
|
|
$collectionIdentifier = $collection->identifier();
|
|
if ($collectionIdentifier !== null) {
|
|
$this->serviceCollectionCache[(string) $collectionIdentifier] = $collection;
|
|
}
|
|
return $collection;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function collectionFresh(): CollectionResource {
|
|
return new CollectionResource();
|
|
}
|
|
|
|
public function collectionCreate(string|int|null $location, CollectionMutableInterface $collection, array $options = []): CollectionBaseInterface {
|
|
// convert collection to a native type if needed
|
|
if (!($collection instanceof CollectionResource)) {
|
|
$nativeCollection = new CollectionResource();
|
|
$nativeCollection->jsonDeserialize($collection->jsonSerialize());
|
|
} else {
|
|
$nativeCollection = clone $collection;
|
|
}
|
|
// create collection in store
|
|
$result = $this->store->collectionCreate($this->serviceTenantId, $this->serviceUserId, $nativeCollection);
|
|
$resultIdentifier = $result->identifier();
|
|
if ($resultIdentifier !== null) {
|
|
$this->serviceCollectionCache[(string) $resultIdentifier] = $result;
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function collectionUpdate(string|int $id, CollectionMutableInterface $collection): CollectionBaseInterface {
|
|
// validate id
|
|
if (!is_string($id)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$id' is not valid");
|
|
}
|
|
// validate ownership
|
|
if ($this->collectionExtant($id) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$id' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// convert collection to a native type if needed
|
|
if (!($collection instanceof CollectionResource)) {
|
|
$nativeCollection = new CollectionResource();
|
|
$data = $collection->jsonSerialize();
|
|
$data[CollectionResource::JSON_PROPERTY_IDENTIFIER] = $id;
|
|
$nativeCollection->jsonDeserialize($data);
|
|
} else {
|
|
$nativeCollection = clone $collection;
|
|
if ($nativeCollection->identifier() === null) {
|
|
$data = $nativeCollection->jsonSerialize();
|
|
$data[CollectionResource::JSON_PROPERTY_IDENTIFIER] = $id;
|
|
$nativeCollection->jsonDeserialize($data);
|
|
}
|
|
}
|
|
// modify collection in store
|
|
$result = $this->store->collectionModify($this->serviceTenantId, $this->serviceUserId, $nativeCollection);
|
|
return $result;
|
|
}
|
|
|
|
public function collectionDelete(string|int $id, bool $force = false, bool $recursive = false): bool {
|
|
// validate id
|
|
if (!is_string($id)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$id' is not valid");
|
|
}
|
|
// validate ownership
|
|
if ($this->collectionExtant($id) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$id' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// destroy collection in store
|
|
if ($this->store->collectionDestroyById($this->serviceTenantId, $this->serviceUserId, $id)) {
|
|
unset($this->serviceCollectionCache[$id]);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Entity operations
|
|
|
|
public function entityList(string|int $collection, ?IFilter $filter = null, ?ISort $sort = null, ?IRange $range = null, ?array $options = null): array {
|
|
// validate id
|
|
if (!is_string($collection)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' is not valid");
|
|
}
|
|
// validate ownership
|
|
if ($this->collectionExtant($collection) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// retrieve entities from store
|
|
$entries = $this->store->entityList($this->serviceTenantId, $this->serviceUserId, $collection, $filter, $sort, $range, $options);
|
|
return $entries ?? [];
|
|
}
|
|
|
|
public function entityListFilter(): Filter {
|
|
return new Filter($this->serviceAbilities[self::CAPABILITY_ENTITY_LIST_FILTER] ?? []);
|
|
}
|
|
|
|
public function entityListSort(): Sort {
|
|
return new Sort($this->serviceAbilities[self::CAPABILITY_ENTITY_LIST_SORT] ?? []);
|
|
}
|
|
|
|
public function entityListRange(RangeType $type): IRange {
|
|
// validate type
|
|
if ($type === RangeType::TALLY) {
|
|
return new RangeTally();
|
|
}
|
|
if ($type === RangeType::DATE) {
|
|
return new RangeDate();
|
|
}
|
|
throw new InvalidParameterException("Invalid: Entity range of type '{$type->value}' is not valid");
|
|
}
|
|
|
|
public function entityExtant(string|int $collection, string|int ...$identifiers): array {
|
|
// validate id
|
|
if (!is_string($collection)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' is not valid");
|
|
}
|
|
// validate ownership
|
|
if ($this->collectionExtant($collection) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// retrieve entity status from store
|
|
return $this->store->entityExtant($collection, ...$identifiers);
|
|
}
|
|
|
|
public function entityDelta(string|int $collection, string $signature, string $detail = 'ids'): Delta {
|
|
// validate id
|
|
if (!is_string($collection)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' is not valid");
|
|
}
|
|
// validate ownership
|
|
if ($this->collectionExtant($collection) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// retrieve entity delta from store
|
|
$delta = $this->store->chronicleReminisce($this->serviceTenantId, $collection, $signature);
|
|
|
|
return new Delta(
|
|
new DeltaCollection($delta['additions'] ?? []),
|
|
new DeltaCollection($delta['modifications'] ?? []),
|
|
new DeltaCollection($delta['deletions'] ?? []),
|
|
$delta['signature'] ?? ''
|
|
);
|
|
}
|
|
|
|
public function entityFetch(string|int $collection, string|int ...$identifiers): array {
|
|
// validate id
|
|
if (!is_string($collection)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' is not valid");
|
|
}
|
|
// validate ownership
|
|
if ($this->collectionExtant($collection) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// retrieve entity from store
|
|
$entries = $this->store->entityFetch($this->serviceTenantId, $this->serviceUserId, $collection, ...$identifiers);
|
|
return $entries ?? [];
|
|
}
|
|
|
|
public function entityFresh(): EntityResource {
|
|
return new EntityResource();
|
|
}
|
|
|
|
public function entityCreate(string|int $collection, EntityMutableInterface $entity, array $options = []): EntityResource {
|
|
// validate collection identifier
|
|
if (!is_string($collection)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' is not valid");
|
|
}
|
|
// validate collection extant and ownership
|
|
if ($this->collectionExtant($collection) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// convert entity to a native type if needed
|
|
if (!($entity instanceof EntityResource)) {
|
|
$nativeEntity = $this->entityFresh();
|
|
$nativeEntity->jsonDeserialize($entity->jsonSerialize());
|
|
} else {
|
|
$nativeEntity = clone $entity;
|
|
}
|
|
// create entity in store (store will handle userId and collection)
|
|
$result = $this->store->entityCreate($this->serviceTenantId, $this->serviceUserId, $collection, $nativeEntity);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function entityUpdate(string|int $collection, string|int $identifier, EntityMutableInterface $entity): EntityResource {
|
|
// validate collection identifier
|
|
if (!is_string($collection)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' is not valid");
|
|
}
|
|
// validate entity identifier
|
|
if (!is_string($identifier)) {
|
|
throw new InvalidParameterException("Invalid: Entity identifier '$identifier' is not valid");
|
|
}
|
|
// validate collection extant and ownership
|
|
if ($this->collectionExtant($collection) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// validate entity extant and ownership
|
|
$extant = $this->store->entityExtant($this->serviceTenantId, $this->serviceUserId, $collection, $identifier);
|
|
if (!isset($extant[$identifier]) || $extant[$identifier] === false) {
|
|
throw new InvalidParameterException("Invalid: Entity identifier '$identifier' does not exist or does not belong to collection '$collection' or user '{$this->serviceUserId}'");
|
|
}
|
|
|
|
// convert entity to a native type if needed
|
|
if (!($entity instanceof Entity)) {
|
|
$nativeEntity = $this->entityFresh();
|
|
$nativeEntity->jsonDeserialize($entity->jsonSerialize());
|
|
} else {
|
|
$nativeEntity = clone $entity;
|
|
}
|
|
|
|
// modify entity in store
|
|
$result = $this->store->entityModify($this->serviceTenantId, $this->serviceUserId, $collection, $identifier, $nativeEntity);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function entityDelete(string|int $collection, string|int $identifier): EntityMutableInterface {
|
|
// validate collection identifier
|
|
if (!is_string($collection)) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' is not valid");
|
|
}
|
|
// validate entity identifier
|
|
if (!is_string($identifier)) {
|
|
throw new InvalidParameterException("Invalid: Entity identifier '$identifier' is not valid");
|
|
}
|
|
// validate collection extant and ownership
|
|
if ($this->collectionExtant($collection) === false) {
|
|
throw new InvalidParameterException("Invalid: Collection identifier '$collection' does not exist or does not belong to user '{$this->serviceUserId}'");
|
|
}
|
|
// validate entity extant and ownership
|
|
$extant = $this->store->entityExtant($this->serviceTenantId, $this->serviceUserId, $collection, $identifier);
|
|
if (!isset($extant[$identifier]) || $extant[$identifier] === false) {
|
|
throw new InvalidParameterException("Invalid: Entity identifier '$identifier' does not exist or does not belong to collection '$collection' or user '{$this->serviceUserId}'");
|
|
}
|
|
// fetch entity before destruction to return it
|
|
$entities = $this->store->entityFetch($this->serviceTenantId, $this->serviceUserId, $collection, $identifier);
|
|
$entity = $entities[$identifier] ?? $this->entityFresh();
|
|
|
|
// destroy entity in store
|
|
$this->store->entityDestroyById($this->serviceTenantId, $this->serviceUserId, $collection, $identifier);
|
|
|
|
return $entity;
|
|
}
|
|
|
|
}
|