Temporal::__construct() - Code Metrics - Inspection of "override and reference end setter api" - tarantool-php/mapper - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 36b4aa...109cdc )

by Dmitry

created 2019-12-11 11:00 UTC

Temporal::__construct() A

↳ Parent: Temporal

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

declare(strict_types=1);

namespace Tarantool\Mapper\Plugin;

use Carbon\Carbon;
use Exception;
use Tarantool\Mapper\Mapper;
use Tarantool\Mapper\Entity;
use Tarantool\Mapper\Plugin;
use Tarantool\Mapper\Plugin\Temporal\Aggregator;
use Tarantool\Client\Schema\Criteria;
use Tarantool\Mapper\Plugin\Temporal\Schema;

class Temporal extends Plugin
{
    private $actor;
    private $timestamps = [];
    private $aggregator;

    public function __construct(Mapper $mapper)
    {
        $this->mapper = $mapper;
        $this->schema = new Schema($mapper);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->aggregator = new Aggregator($this);
    }

    public function getReference($entity, $id, $target, $date)
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_reference_state')) {
            return;
        }

        $entity = $this->entityNameToId($entity);
        $target = $this->entityNameToId($target);
        $date = $this->getTimestamp($date);

        $rows = $this->mapper->getClient()->getSpace('_temporal_reference_state')
            ->select(Criteria::key([$entity, $id, $target, $date])->andLimit(1)->andLeIterator());

        if (count($rows)) {
            $row = $rows[0];
            if ([$entity, $id, $target] == [$row[0], $row[1], $row[2]]) {
                $state = $this->mapper->findOne('_temporal_reference_state', [
                    'entity' => $entity,
                    'id' => $id,
                    'target' => $target,
                    'begin' => $row[3]
                ]);
                if (!$state->end || $state->end >= $date) {
                    return $state->targetId;
                }
            }
        }
    }

    public function getAggregator()
    {
        return $this->aggregator;
    }

    public function getReferenceLog($entity, $id, $target)
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_reference')) {
            return [];
        }
        $log = [];
        $params = [
            'entity' => $this->entityNameToId($entity),
            'id' => $id,
            'target' => $this->entityNameToId($target),
        ];
        foreach ($this->mapper->find('_temporal_reference', $params) as $reference) {
            $log[] = $reference;
        }
        return $log;
    }

    public function getReferenceStates($entity, $entityId, $target, $begin, $end)
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_reference_state')) {
            return;
        }

        $states = $this->mapper->find('_temporal_reference_state', [
            'entity' => $this->entityNameToId($entity),
            'id' => $entityId,
            'target' => $this->entityNameToId($target),
        ]);

        $begin = $this->getTimestamp($begin);
        $end = $this->getTimestamp($end);

        $slices = [];
        foreach ($states as $state) {
            if ($state->begin < $end && ($begin < $state->end || !$state->end)) {
                $slices[] = [
                    'begin' => +date('Ymd', max($state->begin, $begin)),
                    'end' => +date('Ymd', min($state->end ?: $end, $end)),
                    'value' => $state->targetId,
                ];
            }
        }

        return $slices;
    }

    public function getReferences($target, $targetId, $source, $date)
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_reference_aggregate')) {
            return [];
        }

        $target = $this->entityNameToId($target);
        $source = $this->entityNameToId($source);
        $date = $this->getTimestamp($date);

        $rows = $this->mapper->getClient()->getSpace('_temporal_reference_aggregate')
            ->select(Criteria::key([$target, $targetId, $source, $date])->andLimit(1)->andLeIterator());

        if (count($rows)) {
            $row = $rows[0];
            if ([$target, $targetId, $source] == [$row[0], $row[1], $row[2]]) {
                $state = $this->mapper->findOne('_temporal_reference_aggregate', [
                    'entity' => $target,
                    'id'     => $targetId,
                    'source' => $source,
                    'begin'  => $row[3]
                ]);

                if (!$state->end || $state->end > $date) {
                    return $state->data;
                }
            }
        }
        return [];
    }

    public function reference(array $reference)
    {
        $reference = $this->parseConfig($reference);

        foreach ($reference as $k => $v) {
            if (!in_array($k, ['entity', 'id', 'begin', 'end', 'data'])) {
                $reference['entity'] = $k;
                $reference['id'] = $v;
                unset($reference[$k]);
            }
        }

        if (!array_key_exists('entity', $reference)) {
            throw new Exception("no entity defined");
        }

        if (count($reference['data']) != 1) {
            throw new Exception("Invalid reference configuration");
        }

        [$targetName] = array_keys($reference['data']);

        $reference['target'] = $this->entityNameToId($targetName);
        $reference['targetId'] = $reference['data'][$targetName];


        // set entity id
        $entityName = $reference['entity'];
        $reference['entity'] = $this->entityNameToId($entityName);
        $reference['actor'] = $this->actor;
        $reference['timestamp'] = Carbon::now()->timestamp;

        $this->schema->init('reference');
        $this->mapper->create('_temporal_reference', $reference);

        $this->aggregator->updateReferenceState($entityName, $reference['id'], $targetName);
    }

    public function getLinksLog($entity, $entityId, $filter = [])
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_link')) {
            return [];
        }

        $entity = $this->entityNameToId($entity);

        $nodes = $this->mapper->find('_temporal_link', [
            'entity' => $entity,
            'entityId' => $entityId,
        ]);

        $links = [];

        foreach ($nodes as $node) {
            foreach ($this->aggregator->getLeafs($node) as $leaf) {
                $entityName = $this->entityIdToName($leaf->entity);
                $link = [
                    $entityName => $leaf->entityId,
                    'id'        => $leaf->id,
                    'begin'     => $leaf->begin,
                    'end'       => $leaf->end,
                    'timestamp' => $leaf->timestamp,
                    'actor'     => $leaf->actor,
                    'idle'      => property_exists($leaf, 'idle') ? $leaf->idle : 0,
                ];

                $current = $leaf;
                while ($current->parent) {
                    $current = $this->mapper->findOne('_temporal_link', $current->parent);
                    $entityName = $this->entityIdToName($current->entity);
                    $link[$entityName] = $current->entityId;
                }

                if (count($filter)) {
                    foreach ($filter as $required) {
                        if (!array_key_exists($required, $link)) {
                            continue 2;
                        }
                    }
                }
                $links[] = $link;
            }
        }

        return $links;
    }

    public function getLinks($entity, $id, $date)
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_link_aggregate')) {
            return [];
        }

        $links = $this->getData($entity, $id, $date, '_temporal_link_aggregate');
        foreach ($links as $i => $source) {
            $link = array_key_exists(1, $source) ? ['data' => $source[1]] : [];
            foreach ($source[0] as $spaceId => $entityId) {
                $spaceName = $this->mapper->findOne('_temporal_entity', $spaceId)->name;
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $link[$spaceName] = $entityId;
            }
            $links[$i] = $link;
        }
        return $links;
    }

    public function getState($entity, $id, $date)
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_override_aggregate')) {
            return [];
        }

        return $this->getData($entity, $id, $date, '_temporal_override_aggregate');
    }

    private function getData($entity, $id, $date, $space)
    {
        $entity = $this->entityNameToId($entity);
        $date = $this->getTimestamp($date);

        $rows = $this->mapper->getClient()->getSpace($space)
            ->select(Criteria::key([$entity, $id, $date])->andLimit(1)->andLeIterator());

        if (count($rows) && $rows[0][0] == $entity && $rows[0][1] == $id) {
            $state = $this->mapper->findOne($space, [
                'entity' => $entity,
                'id' => $id,
                'begin' => $rows[0][2]
            ]);
            if (!$state->end || $state->end >= $date) {
                return $state->data;
            }
        }

        return [];
    }

    public function getOverrides(string $entityName, int $id) : array
    {
        if (!$this->mapper->getSchema()->hasSpace('_temporal_override')) {
            return [];
        }

        return $this->mapper->find('_temporal_override', [
            'entity' => $this->entityNameToId($entityName),
            'id' => $id,
        ]);
    }

    public function override(array $override)
    {
        $override = $this->parseConfig($override);

        foreach ($override as $k => $v) {
            if (!in_array($k, ['entity', 'id', 'begin', 'end', 'data'])) {
                $override['entity'] = $k;
                $override['id'] = $v;
                unset($override[$k]);
            }
        }

        if (!array_key_exists('entity', $override)) {
            throw new Exception("no entity defined");
        }

        // set entity id
        $entityName = $override['entity'];
        $override['entity'] = $this->entityNameToId($entityName);
        $override['actor'] = $this->actor;
        $override['timestamp'] = Carbon::now()->timestamp;

        $this->schema->init('override');
        $this->mapper->create('_temporal_override', $override);

        $this->aggregator->updateOverrideAggregation($entityName, $override['id']);
    }

    public function setLinkIdle($id, $flag)
    {
        $link = $this->mapper->findOrFail('_temporal_link', $id);

        $idled = property_exists($link, 'idle') && $link->idle > 0;

        if ($idled && !$flag || !$idled && $flag) {
            return $this->toggleLinkIdle($link);
        }
    }

    public function toggleLinkIdle(Entity $link)
    {
        if (property_exists($link, 'idle') && $link->idle) {
            $link->idle = 0;

        } else {
            $link->idle = time();
        }
        $link->save();

        $this->aggregator->updateLinkAggregation($link);
    }

    public function setReferenceIdle($entity, $id, $target, $targetId, $begin, $actor, $timestamp, $flag)
    {
        $reference = $this->mapper->findOrFail('_temporal_reference', [
            'entity' => $this->entityNameToId($entity),
            'id' => $id,
            'target' => $this->entityNameToId($target),
            'targetId' => $targetId,
            'begin' => $begin,
            'actor' => $actor,
            'timestamp' => $timestamp,
        ]);
        $idled = property_exists($reference, 'idle') && $reference->idle > 0;

        if ($idled && !$flag || !$idled && $flag) {
            return $this->toggleReferenceIdle($entity, $id, $target, $targetId, $begin, $actor, $timestamp);
        }
    }

    public function toggleReferenceIdle($entity, $id, $target, $targetId, $begin, $actor, $timestamp)
    {
        $reference = $this->mapper->findOrFail('_temporal_reference', [
            'entity' => $this->entityNameToId($entity),
            'id' => $id,
            'target' => $this->entityNameToId($target),
            'targetId' => $targetId,
            'begin' => $begin,
            'actor' => $actor,
            'timestamp' => $timestamp,
        ]);

        if (property_exists($reference, 'idle') && $reference->idle) {
            $reference->idle = 0;

        } else {
            $reference->idle = time();
        }
        $reference->save();

        $this->aggregator->updateReferenceState($entity, $id, $target);
    }

    public function setOverrideIdle($entity, $id, $begin, $actor, $timestamp, $flag)
    {
        $override = $this->mapper->findOrFail('_temporal_override', [
            'entity' => $this->entityNameToId($entity),
            'id' => $id,
            'begin' => $begin,
            'actor' => $actor,
            'timestamp' => $timestamp,
        ]);
        $idled = property_exists($override, 'idle') && $override->idle > 0;

        if ($idled && !$flag || !$idled && $flag) {
            return $this->toggleOverrideIdle($entity, $id, $begin, $actor, $timestamp);
        }
    }

    public function toggleOverrideIdle($entity, $id, $begin, $actor, $timestamp)
    {
        $override = $this->mapper->findOrFail('_temporal_override', [
            'entity' => $this->entityNameToId($entity),
            'id' => $id,
            'begin' => $begin,
            'actor' => $actor,
            'timestamp' => $timestamp,
        ]);

        if (property_exists($override, 'idle') && $override->idle) {
            $override->idle = 0;

        } else {
            $override->idle = time();
        }
        $override->save();

        $this->aggregator->updateOverrideAggregation($entity, $id);
    }

    public function setReferenceEnd($entity, $id, $target, $targetId, $begin, $actor, $timestamp, $end)
    {
        $reference = $this->mapper->findOrFail('_temporal_reference', [
            'entity' => $this->entityNameToId($entity),
            'id' => $id,
            'target' => $this->entityNameToId($target),
            'targetId' => $targetId,
            'begin' => $begin,
            'actor' => $actor,
            'timestamp' => $timestamp,
        ]);
        if ($reference->end != $end) {
            $reference->end = $end;

            $reference->save();
            $this->aggregator->updateReferenceState($entity, $id, $target);
        }
    }

    public function setOverrideEnd($entity, $id, $begin, $actor, $timestamp, $end)
    {
        $override = $this->mapper->findOrFail('_temporal_override', [
            'entity' => $this->entityNameToId($entity),
            'id' => $id,
            'begin' => $begin,
            'actor' => $actor,
            'timestamp' => $timestamp,
        ]);
        if ($override->end != $end) {
            $override->end = $end;

            $override->save();
            $this->aggregator->updateOverrideAggregation($entity, $id);
        }
    }


    public function link(array $link)
    {
        $link = $this->parseConfig($link);

        $this->schema->init('link');

        $config = [];
        foreach ($link as $entity => $id) {
            if (!in_array($entity, ['begin', 'end', 'data'])) {
                $config[$entity] = $id;
            }
        }

        ksort($config);
        $node = null;

        foreach (array_keys($config) as $i => $entity) {
            $id = $config[$entity];
            $spaceId = $this->entityNameToId($entity);
            $params = [
                'entity'   => $spaceId,
                'entityId' => $id,
                'parent'   => $node ? $node->id : 0,
            ];
            if (count($config) == $i+1) {
                $params['begin'] = $link['begin'];
                $params['timestamp'] = 0;
            }
            $node = $this->mapper->findOrCreate('_temporal_link', $params);
        }

        if (!$node || !$node->parent) {

            throw new Exception("Invalid link configuration");
        }

        $node->begin = $link['begin'];

        $node->end = $link['end'];

        $node->actor = $this->actor;

        $node->timestamp = Carbon::now()->timestamp;

        if (array_key_exists('data', $link)) {
            $node->data = $link['data'];

        }

        $node->save();

        $this->aggregator->updateLinkAggregation($node);
    }

    public function getActor()
    {
        return $this->actor;
    }

    public function setActor($actor)
    {
        $this->actor = $actor;
        return $this;
    }

    private function getTimestamp($string)
    {
        if (Carbon::hasTestNow() || !array_key_exists($string, $this->timestamps)) {
            if (strlen(''.$string) == 8 && is_numeric($string)) {
                $value = Carbon::createFromFormat('Ymd', $string)->setTime(0, 0, 0)->timestamp;
            } else {
                $value = Carbon::parse($string)->timestamp;
            }
            if (Carbon::hasTestNow()) {
                return $value;
            }
            $this->timestamps[$string] = $value;
        }
        return $this->timestamps[$string];
    }

    private function parseConfig(array $data)
    {
        if (!$this->actor) {
            throw new Exception("actor is undefined");
        }

        if (array_key_exists('actor', $data)) {
            throw new Exception("actor is defined");
        }

        if (array_key_exists('timestamp', $data)) {
            throw new Exception("timestamp is defined");
        }

        foreach (['begin', 'end'] as $field) {
            if (array_key_exists($field, $data) && $data[$field]) {
                $data[$field] = $this->getTimestamp($data[$field]);
            } else {
                $data[$field] = 0;
            }
        }

        return $data;
    }

    public function entityNameToId($name)
    {
        if (!$this->mapper->hasPlugin(Sequence::class)) {
            $this->mapper->getPlugin(Sequence::class);
        }

        $this->mapper->getSchema()->once(__CLASS__.'@entity', function (Mapper $mapper) {

            $this->mapper->getSchema()
                ->createSpace('_temporal_entity', [
                    'id'   => 'unsigned',
                    'name' => 'string',
                ])
                ->addIndex(['id'])
                ->addIndex(['name']);
        });

        return $this->mapper->findOrCreate('_temporal_entity', compact('name'))->id;
    }

    public function entityIdToName($id)
    {
        return $this->mapper->findOne('_temporal_entity', compact('id'))->name;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Tarantool\Mapper\Plugin;
6
7			use Carbon\Carbon;
8			use Exception;
9			use Tarantool\Mapper\Mapper;
10			use Tarantool\Mapper\Entity;
11			use Tarantool\Mapper\Plugin;
12			use Tarantool\Mapper\Plugin\Temporal\Aggregator;
13			use Tarantool\Client\Schema\Criteria;
14			use Tarantool\Mapper\Plugin\Temporal\Schema;
15
16			class Temporal extends Plugin
17			{
18			private $actor;
19			private $timestamps = [];
20			private $aggregator;
21
22			public function __construct(Mapper $mapper)
23			{
24			$this->mapper = $mapper;
25			$this->schema = new Schema($mapper);
			0 ignored issues – show Bug introduced 2017-09-12 11:29 UTC by Report Bug Copy Issue Report The property `schema` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
26			$this->aggregator = new Aggregator($this);
27			}
28
29			public function getReference($entity, $id, $target, $date)
30			{
31			if (!$this->mapper->getSchema()->hasSpace('_temporal_reference_state')) {
32			return;
33			}
34
35			$entity = $this->entityNameToId($entity);
36			$target = $this->entityNameToId($target);
37			$date = $this->getTimestamp($date);
38
39			$rows = $this->mapper->getClient()->getSpace('_temporal_reference_state')

tarantool-php / mapper

Push — master ( 36b4aa...109cdc )

Temporal::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like