729 lines
20 KiB
PHP
729 lines
20 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
/**
|
|
* SPDX-FileCopyrightText: Sebastian Krupinski <krupinski01@gmail.com>
|
|
* SPDX-License-Identifier: AGPL-3.0-or-later
|
|
*/
|
|
|
|
namespace KTXM\ChronoProviderLocal\Store\Personal;
|
|
|
|
use KTXC\Db\DataStore;
|
|
use KTXF\Resource\Filter\Filter;
|
|
use KTXF\Resource\Filter\FilterComparisonOperator;
|
|
use KTXF\Resource\Filter\FilterConjunctionOperator;
|
|
use KTXF\Resource\Range\Range;
|
|
use KTXF\Resource\Range\RangeType;
|
|
use KTXF\Resource\Sort\Sort;
|
|
use KTXF\Utile\UUID;
|
|
use KTXM\ChronoProviderLocal\Providers\Personal\Collection;
|
|
use KTXM\ChronoProviderLocal\Providers\Personal\Entity;
|
|
|
|
class Store {
|
|
|
|
protected string $_CollectionTable = 'chrono_provider_local_collection';
|
|
protected string $_CollectionClass = 'KTXM\ChronoProviderLocal\Providers\Personal\Collection';
|
|
protected string $_EntityTable = 'chrono_provider_local_entity';
|
|
protected string $_EntityClass = 'KTXM\ChronoProviderLocal\Providers\Personal\Entity';
|
|
protected string $_ChronicleTable = 'chrono_provider_local_chronicle';
|
|
|
|
protected array $_CollectionFilterAttributeMap = [
|
|
'id' => 'cid',
|
|
'label' => 'label',
|
|
'description' => 'description',
|
|
];
|
|
|
|
protected array $_CollectionFilterAttributeComparatorDefault = [
|
|
'id' => FilterComparisonOperator::IN,
|
|
'label' => FilterComparisonOperator::LIKE,
|
|
'description' => FilterComparisonOperator::LIKE,
|
|
];
|
|
|
|
protected array $_EntityFilterAttributeMap = [
|
|
'id' => 'eid',
|
|
'label' => 'data.label',
|
|
'startsOn' => 'data.startsOn',
|
|
'endsOn' => 'data.endsOn',
|
|
'locations' => 'data.locations',
|
|
'participants' => 'data.participants',
|
|
];
|
|
|
|
public function __construct(
|
|
protected readonly DataStore $_store
|
|
) { }
|
|
|
|
protected function constructFilter(array $map, Filter $filter): array {
|
|
$mongoFilter = [];
|
|
|
|
foreach ($filter->conditions() as $entry) {
|
|
if (!isset($map[$entry['attribute']])) {
|
|
continue;
|
|
}
|
|
|
|
$attribute = $map[$entry['attribute']];
|
|
$value = $entry['value'];
|
|
$comparator = $entry['comparator'] ?? FilterComparisonOperator::EQ;
|
|
|
|
$condition = match ($comparator) {
|
|
FilterComparisonOperator::EQ => $value,
|
|
FilterComparisonOperator::NEQ => ['$ne' => $value],
|
|
FilterComparisonOperator::GT => ['$gt' => $value],
|
|
FilterComparisonOperator::GTE => ['$gte' => $value],
|
|
FilterComparisonOperator::LT => ['$lt' => $value],
|
|
FilterComparisonOperator::LTE => ['$lte' => $value],
|
|
FilterComparisonOperator::IN => ['$in' => is_array($value) ? $value : [$value]],
|
|
FilterComparisonOperator::NIN => ['$nin' => is_array($value) ? $value : [$value]],
|
|
FilterComparisonOperator::LIKE => ['$regex' => $value, '$options' => 'i'],
|
|
FilterComparisonOperator::NLIKE => ['$not' => ['$regex' => $value, '$options' => 'i']],
|
|
default => $value
|
|
};
|
|
|
|
if (isset($mongoFilter[$attribute])) {
|
|
// Handle conjunction
|
|
if ($entry['conjunction'] === FilterConjunctionOperator::OR) {
|
|
$mongoFilter['$or'][] = [$attribute => $condition];
|
|
} else {
|
|
// AND conjunction - merge with existing
|
|
if (is_array($mongoFilter[$attribute]) && !isset($mongoFilter[$attribute]['$and'])) {
|
|
$mongoFilter[$attribute] = ['$and' => [$mongoFilter[$attribute], $condition]];
|
|
} else {
|
|
$mongoFilter[$attribute] = $condition;
|
|
}
|
|
}
|
|
} else {
|
|
$mongoFilter[$attribute] = $condition;
|
|
}
|
|
}
|
|
|
|
return $mongoFilter;
|
|
}
|
|
|
|
protected function constructSort(array $map, Sort $sort): array {
|
|
$mongoSort = [];
|
|
|
|
foreach ($sort->conditions() as $entry) {
|
|
if (!isset($map[$entry['attribute']])) {
|
|
continue;
|
|
}
|
|
|
|
$attribute = $map[$entry['attribute']];
|
|
$direction = $entry['direction'] ? 1 : -1;
|
|
$mongoSort[$attribute] = $direction;
|
|
}
|
|
|
|
return $mongoSort;
|
|
}
|
|
|
|
/**
|
|
* retrieve collections from data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param Filter $filter filter options
|
|
* @param Sort $sort sort options
|
|
*
|
|
* @return array<string, Collection>
|
|
*/
|
|
public function collectionList(string $tenantId, string $userId, ?Filter $filter = null, ?Sort $sort = null): array {
|
|
$query = ['tid' => $tenantId, 'uid' => $userId];
|
|
|
|
// Apply filter if provided
|
|
if ($filter !== null) {
|
|
$filterConditions = $this->constructFilter($this->_CollectionFilterAttributeMap, $filter);
|
|
$query = array_merge($query, $filterConditions);
|
|
}
|
|
|
|
$options = [];
|
|
|
|
// Apply sort if provided
|
|
if ($sort !== null) {
|
|
$sortConditions = $this->constructSort($this->_CollectionFilterAttributeMap, $sort);
|
|
$options['sort'] = $sortConditions;
|
|
}
|
|
|
|
$cursor = $this->_store->selectCollection($this->_CollectionTable)->find($query, $options);
|
|
$list = [];
|
|
foreach ($cursor as $entry) {
|
|
$entry = (new Collection())->fromStore($entry);
|
|
$list[$entry->id()] = $entry;
|
|
}
|
|
return $list;
|
|
}
|
|
|
|
/**
|
|
* confirm if collections exist in data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user id
|
|
* @param string $id collection id
|
|
*
|
|
*/
|
|
public function collectionExtant(string $tenantId, string $userId, string $identifier): bool {
|
|
$cursor = $this->_store->selectCollection($this->_CollectionTable)->findOne([
|
|
'tid' => $tenantId,
|
|
'uid' => $userId,
|
|
'cid' => $identifier
|
|
]);
|
|
return $cursor !== null;
|
|
}
|
|
|
|
/**
|
|
* retrieve collection from data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param string $identifier collection identifier
|
|
*
|
|
* @return Collection
|
|
*/
|
|
public function collectionFetch(string $tenantId, string $userId, string $identifier): ?Collection {
|
|
$cursor = $this->_store->selectCollection($this->_CollectionTable)->findOne([
|
|
'tid' => $tenantId,
|
|
'uid' => $userId,
|
|
'cid' => $identifier
|
|
]);
|
|
if ($cursor === null) {
|
|
return null;
|
|
}
|
|
$entry = (new Collection())->fromStore($cursor);
|
|
return $entry;
|
|
}
|
|
|
|
/**
|
|
* fresh instance of a collection entity
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @return Collection
|
|
*/
|
|
public function collectionFresh(): Collection {
|
|
return new $this->_CollectionClass;
|
|
}
|
|
|
|
/**
|
|
* create a collection entry in the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param Collection $entity
|
|
*
|
|
* @return Collection
|
|
*/
|
|
public function collectionCreate(string $tenantId, string $userId, Collection $entity): Collection {
|
|
// convert entity to store format
|
|
$data = $entity->toStore();
|
|
// prepare data for creation
|
|
$data['tid'] = $tenantId;
|
|
$data['uid'] = $userId;
|
|
$data['cid'] = UUID::v4();
|
|
$data['createdOn'] = date('c');
|
|
$data['modifiedOn'] = $data['createdOn'];
|
|
// create entry
|
|
$result = $this->_store->selectCollection($this->_CollectionTable)->insertOne($data);
|
|
if ($result->getInsertedCount() === 1) {
|
|
$entity = new Collection();
|
|
$entity->fromStore($data);
|
|
}
|
|
return $entity;
|
|
}
|
|
|
|
/**
|
|
* modify a collection entry in the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param Collection $entity
|
|
*
|
|
* @return Collection
|
|
*/
|
|
public function collectionModify(string $tenantId, string $userId, Collection $entity): Collection {
|
|
// convert entity to store format
|
|
$data = $entity->toStore();
|
|
// prepare data for modification
|
|
$cid = $entity->id();
|
|
$data['modifiedOn'] = date('c');
|
|
unset($data['_id'], $data['tid'], $data['uid'], $data['cid']);
|
|
// modify entry
|
|
$this->_store->selectCollection($this->_CollectionTable)->updateOne(
|
|
['tid' => $tenantId, 'uid' => $userId, 'cid' => $cid],
|
|
['$set' => $data]
|
|
);
|
|
return $entity;
|
|
}
|
|
|
|
/**
|
|
* delete a collection entry from the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param Collection $entity
|
|
*
|
|
* @return Collection
|
|
*/
|
|
public function collectionDestroy(string $tenantId, string $userId, Collection $entity): Collection {
|
|
return $this->collectionDestroyById($tenantId, $userId, $entity->id()) ? $entity : $entity;
|
|
}
|
|
|
|
/**
|
|
* delete a collection entry from the data store by ID and user
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param string $collectionId collection identifier
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function collectionDestroyById(string $tenantId, string $userId, string $collectionId): bool {
|
|
$result = $this->_store->selectCollection($this->_CollectionTable)->deleteOne([
|
|
'tid' => $tenantId,
|
|
'uid' => $userId,
|
|
'cid' => $collectionId
|
|
]);
|
|
|
|
return $result->getDeletedCount() === 1;
|
|
}
|
|
|
|
/**
|
|
* retrieve entities from data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $collection collection identifier
|
|
* @param Filter $filter filter options
|
|
* @param Sort $sort sort options
|
|
* @param Range $range range options
|
|
*
|
|
* @return array of entities
|
|
*/
|
|
public function entityList(string $tenantId, string $userId, string $collectionId, ?Filter $filter = null, ?Sort $sort = null, ?Range $range = null, ?array $options = null): array {
|
|
$query = ['tid' => $tenantId, 'uid' => $userId, 'cid' => $collectionId];
|
|
|
|
// Apply filter if provided
|
|
if ($filter !== null) {
|
|
$filterConditions = $this->constructFilter($this->_EntityFilterAttributeMap, $filter);
|
|
$query = array_merge($query, $filterConditions);
|
|
}
|
|
|
|
$findOptions = [];
|
|
|
|
// Apply sort if provided
|
|
if ($sort !== null) {
|
|
$sortConditions = $this->constructSort($this->_EntityFilterAttributeMap, $sort);
|
|
$findOptions['sort'] = $sortConditions;
|
|
}
|
|
|
|
// Apply range/pagination if provided
|
|
if ($range !== null) {
|
|
if ($range->type() === RangeType::TALLY) {
|
|
// For TALLY ranges, use position (skip) and tally (limit)
|
|
/** @var \KTXF\Resource\Range\IRangeTally $rangeTally */
|
|
$rangeTally = $range;
|
|
$findOptions['skip'] = $rangeTally->getPosition();
|
|
$findOptions['limit'] = $rangeTally->getTally();
|
|
} elseif ($range->type() === RangeType::DATE) {
|
|
// For DATE ranges, filter by date fields
|
|
/** @var \KTXF\Resource\Range\IRangeDate $rangeDate */
|
|
$rangeDate = $range;
|
|
$query['data.startsOn'] = [
|
|
'\$gte' => $rangeDate->getStart()->format('c'),
|
|
'\$lte' => $rangeDate->getEnd()->format('c')
|
|
];
|
|
}
|
|
}
|
|
|
|
$cursor = $this->_store->selectCollection($this->_EntityTable)->find($query, $findOptions);
|
|
$list = [];
|
|
foreach ($cursor as $entry) {
|
|
$entity = (new Entity())->fromStore($entry);
|
|
$list[$entity->id()] = $entity;
|
|
}
|
|
return $list;
|
|
}
|
|
|
|
/**
|
|
* confirm if entity(ies) exist in data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $collection collection identifier
|
|
* @param string ...$identifiers entity identifiers (eid UUID strings)
|
|
*
|
|
* @return array<string,bool>
|
|
*/
|
|
public function entityExtant(string $tenantId, string $userId, string $collectionId, string ...$identifiers): array {
|
|
|
|
// Query for all entity IDs at once, but only retrieve the eid field (projection)
|
|
$cursor = $this->_store->selectCollection($this->_EntityTable)->find(
|
|
[
|
|
'tid' => $tenantId,
|
|
'uid' => $userId,
|
|
'cid' => $collectionId,
|
|
'eid' => ['$in' => $identifiers]
|
|
],
|
|
[
|
|
'projection' => ['eid' => 1, '_id' => 0]
|
|
]
|
|
);
|
|
|
|
// Build flat array of found IDs
|
|
$found = [];
|
|
foreach ($cursor as $entry) {
|
|
$found[] = $entry['eid'];
|
|
}
|
|
|
|
$result = array_fill_keys($found, true);
|
|
$result = array_merge($result, array_fill_keys(array_diff($identifiers, $found), false));
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* retrieve entity(ies) from data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $collection collection identifier
|
|
* @param string ...$identifiers entity identifiers (eid UUID strings)
|
|
*
|
|
* @return array<Entity>
|
|
*/
|
|
public function entityFetch(string $tenantId, string $userId, string $collectionId, string ...$identifiers): array {
|
|
// Query for entities using eid field
|
|
$cursor = $this->_store->selectCollection($this->_EntityTable)->find([
|
|
'tid' => $tenantId,
|
|
'uid' => $userId,
|
|
'cid' => $collectionId,
|
|
'eid' => ['$in' => $identifiers]
|
|
]);
|
|
|
|
$list = [];
|
|
foreach ($cursor as $entry) {
|
|
$entity = (new Entity())->fromStore($entry);
|
|
$list[$entity->id()] = $entity;
|
|
}
|
|
|
|
return $list;
|
|
}
|
|
|
|
/**
|
|
* fresh instance of a entity
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @return Entity
|
|
*/
|
|
public function entityFresh(): Entity {
|
|
return new Entity();
|
|
}
|
|
|
|
/**
|
|
* create a entity entry in the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param Entity $entity entity to create
|
|
*
|
|
* @return Entity
|
|
*/
|
|
/**
|
|
* create a entity entry in the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param string $collection collection identifier
|
|
* @param Entity $entity entity to create
|
|
*
|
|
* @return Entity
|
|
*/
|
|
public function entityCreate(string $tenantId, string $userId, string $collectionId, Entity $entity): Entity {
|
|
// convert entity to store format
|
|
$data = $entity->toStore();
|
|
// assign identifiers and timestamps
|
|
$data['tid'] = $tenantId;
|
|
$data['uid'] = $userId;
|
|
$data['cid'] = $collectionId;
|
|
$data['eid'] = UUID::v4();
|
|
$data['createdOn'] = date('c');
|
|
$data['createdBy'] = $userId;
|
|
$data['modifiedOn'] = $data['createdOn'];
|
|
$data['modifiedBy'] = $data['createdBy'];
|
|
|
|
$result = $this->_store->selectCollection($this->_EntityTable)->insertOne($data);
|
|
|
|
if ($result->getInsertedCount() === 1) {
|
|
$eid = $data['eid'];
|
|
$entity->fromStore(['eid' => $eid, 'tid' => $tenantId, 'uid' => $userId, 'cid' => $collectionId]);
|
|
// Chronicle the creation (operation 1)
|
|
$this->chronicleDocument($tenantId, $collectionId, $eid, 1);
|
|
}
|
|
|
|
return $entity;
|
|
}
|
|
|
|
/**
|
|
* modify a entity entry in the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param string $collection collection identifier
|
|
* @param string $identifier entity identifier
|
|
* @param Entity $entity entity to modify
|
|
*
|
|
* @return Entity
|
|
*/
|
|
public function entityModify(string $tenantId, string $userId, string $collectionId, string $identifier, Entity $entity): Entity {
|
|
// convert entity to store format
|
|
$data = $entity->toStore();
|
|
$data['modifiedOn'] = date('c');
|
|
$data['modifiedBy'] = $userId;
|
|
// Remove identifiers from update data (they shouldn't change)
|
|
unset($data['_id'], $data['tid'], $data['uid'], $data['cid'], $data['eid']);
|
|
|
|
$result = $this->_store->selectCollection($this->_EntityTable)->updateOne(
|
|
['tid' => $tenantId, 'uid' => $userId, 'cid' => $collectionId, 'eid' => $identifier],
|
|
['$set' => $data]
|
|
);
|
|
|
|
if ($result->getModifiedCount() > 0) {
|
|
// Chronicle the modification (operation 2)
|
|
$this->chronicleDocument($tenantId, $collectionId, $identifier, 2);
|
|
}
|
|
|
|
return $entity;
|
|
}
|
|
|
|
/**
|
|
* delete a entity from the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param string $collection collection identifier
|
|
* @param Entity $entity entity to delete
|
|
*
|
|
* @return Entity
|
|
*/
|
|
public function entityDestroy(string $tenantId, string $userId, string $collectionId, Entity $entity): Entity {
|
|
$identifier = $entity->id();
|
|
|
|
$result = $this->_store->selectCollection($this->_EntityTable)->deleteOne([
|
|
'tid' => $tenantId,
|
|
'uid' => $userId,
|
|
'cid' => $collectionId,
|
|
'eid' => $identifier
|
|
]);
|
|
|
|
if ($result->getDeletedCount() === 1) {
|
|
// Chronicle the deletion (operation 3)
|
|
$this->chronicleDocument($tenantId, $collectionId, $identifier, 3);
|
|
}
|
|
|
|
return $entity;
|
|
}
|
|
|
|
/**
|
|
* delete a entity from the data store by ID
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $userId user identifier
|
|
* @param string $collection collection identifier
|
|
* @param string $entityId entity identifier
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function entityDestroyById(string $tenantId, string $userId, string $collectionId, string $identifier): bool {
|
|
$result = $this->_store->selectCollection($this->_EntityTable)->deleteOne([
|
|
'tid' => $tenantId,
|
|
'uid' => $userId,
|
|
'cid' => $collectionId,
|
|
'eid' => $identifier
|
|
]);
|
|
|
|
if ($result->getDeletedCount() === 1) {
|
|
// Chronicle the deletion (operation 3)
|
|
$this->chronicleDocument($tenantId, $collectionId, $identifier, 3);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* chronicle a operation to an entity to the data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $tid tenant identifier
|
|
* @param string $cid collection identifier
|
|
* @param string $eid entity identifier
|
|
* @param int $operation operation type (1 - Created, 2 - Modified, 3 - Deleted)
|
|
*/
|
|
private function chronicleDocument(string $tid, string $cid, string $eid, int $operation): void {
|
|
// retrieve current token from collection
|
|
$collection = $this->_store->selectCollection($this->_CollectionTable)->findOne([
|
|
'cid' => $cid
|
|
], [
|
|
'projection' => ['signature' => 1, '_id' => 0]
|
|
]);
|
|
|
|
$signature = $collection['signature'] ?? 0;
|
|
|
|
// document operation in chronicle
|
|
$this->_store->selectCollection($this->_ChronicleTable)->insertOne([
|
|
'tid' => $tid,
|
|
'cid' => $cid,
|
|
'eid' => $eid,
|
|
'operation' => $operation,
|
|
'signature' => $signature,
|
|
'mutatedOn' => time(),
|
|
]);
|
|
|
|
// increment token atomically
|
|
$this->_store->selectCollection($this->_CollectionTable)->updateOne(
|
|
['cid' => $cid],
|
|
['$inc' => ['signature' => 1]]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* reminisce operations to entities in data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $cid collection id
|
|
* @param bool $encode weather to encode the result
|
|
*
|
|
* @return int|float|string
|
|
*/
|
|
public function chronicleApex(string $tid, string $cid, bool $encode = true): int|float|string {
|
|
|
|
// Use aggregation pipeline to find max signature
|
|
$cursor = $this->_store->selectCollection($this->_ChronicleTable)->aggregate([
|
|
[
|
|
'$match' => ['tid' => $tid, 'cid' => $cid]
|
|
],
|
|
[
|
|
'$group' => [
|
|
'_id' => null,
|
|
'maxToken' => ['$max' => '$signature']
|
|
]
|
|
]
|
|
]);
|
|
|
|
$result = $cursor->toArray();
|
|
$stampApex = !empty($result) ? ($result[0]['maxToken'] ?? 0) : 0;
|
|
|
|
if ($encode) {
|
|
return base64_encode((string)max(0, $stampApex));
|
|
} else {
|
|
return max(0, $stampApex);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* reminisce operations to entities in data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param string $collection collection id
|
|
* @param string $signature encoded token
|
|
*
|
|
* @return array
|
|
*/
|
|
public function chronicleReminisce(string $tenantId, string $collectionId, string $signature): array {
|
|
|
|
// retrieve apex signature
|
|
$tokenApex = $this->chronicleApex($tenantId, $collectionId, false);
|
|
// determine nadir signature
|
|
$tokenNadir = !empty($signature) ? base64_decode($signature) : '';
|
|
$initial = !is_numeric($tokenNadir);
|
|
$tokenNadir = $initial ? 0 : (int)$tokenNadir;
|
|
|
|
// Build aggregation pipeline to retrieve additions/modifications/deletions
|
|
$matchStage = [
|
|
'$match' => [
|
|
'tid' => $tenantId,
|
|
'cid' => $collectionId
|
|
]
|
|
];
|
|
|
|
// If not initial sync, filter by signature range
|
|
if (!$initial) {
|
|
$matchStage['$match']['signature'] = [
|
|
'$gt' => $tokenNadir,
|
|
'$lte' => (int)$tokenApex
|
|
];
|
|
}
|
|
|
|
$pipeline = [
|
|
$matchStage,
|
|
[
|
|
'$group' => [
|
|
'_id' => '$eid',
|
|
'operation' => ['$max' => '$operation'],
|
|
'eid' => ['$first' => '$eid']
|
|
]
|
|
]
|
|
];
|
|
|
|
// For initial sync, exclude deleted entries
|
|
if ($initial) {
|
|
$pipeline[] = [
|
|
'$match' => [
|
|
'operation' => ['$ne' => 3]
|
|
]
|
|
];
|
|
}
|
|
|
|
// define place holder
|
|
$chronicle = ['additions' => [], 'modifications' => [], 'deletions' => [], 'signature' => base64_encode((string)$tokenApex)];
|
|
|
|
// execute aggregation
|
|
$cursor = $this->_store->selectCollection($this->_ChronicleTable)->aggregate($pipeline);
|
|
|
|
// process result
|
|
foreach ($cursor as $entry) {
|
|
switch ($entry['operation']) {
|
|
case 1:
|
|
$chronicle['additions'][] = $entry['eid'];
|
|
break;
|
|
case 2:
|
|
$chronicle['modifications'][] = $entry['eid'];
|
|
break;
|
|
case 3:
|
|
$chronicle['deletions'][] = $entry['eid'];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// return chronicle
|
|
return $chronicle;
|
|
|
|
}
|
|
|
|
/**
|
|
* delete chronicle entries for a specific collection(s) from data store
|
|
*
|
|
* @since Release 1.0.0
|
|
*
|
|
* @param array $identifiers collection of identifiers
|
|
*/
|
|
private function chronicleExpungeByCollectionId(array $identifiers): void {
|
|
// Delete chronicle entries for the specified collection identifiers
|
|
$this->_store->selectCollection($this->_ChronicleTable)->deleteMany([
|
|
'cid' => ['$in' => $identifiers]
|
|
]);
|
|
}
|
|
|
|
}
|