AbstractDaftObjectEasyDBRepository::DaftObjectExistsInDatabase() - Code Metrics - Inspection of "adjusting tests & implementation" - SignpostMarv/daft-db-object - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( bacb55...6daee1 )

by SignpostMarv

created 2019-02-23 18:21 UTC

DaftObjectExistsInDatabase() A

↳ Parent: AbstractDaftObjectEasyDBRepository

Complexity

Conditions	2
Paths	2

Size

Total Lines	18
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes

Metric	Value
eloc	11
dl	0
loc	18
rs	9.9
c	0
b	0
f	0
ccs	7
cts	7
cp	1
cc	2
nc	2
nop	1
crap	2

<?php
/**
* Base daft objects.
*
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftObject;

use ParagonIE\EasyDB\EasyDB;

/**
* @template TDbObj as SuitableForRepositoryType
*
* @template-extends DaftObjectMemoryRepository<TDbObj>
*/
abstract class AbstractDaftObjectEasyDBRepository extends DaftObjectMemoryRepository
{
    const ARG_SECOND = 2;

    const BOOL_DOES_NOT_EXIST = false;

    const BOOL_TRUE_AS_INT = 1;

    const BOOL_FALSE_AS_INT = 0;

    const COUNT_EMPTY_ARRAY = 0;

    /**
    * @var EasyDB
    */
    protected $db;

    /**
    * {@inheritdoc}
    *
    * @psalm-param class-string<TDbObj> $type
    */
    protected function __construct(string $type, EasyDB $db, ...$args)
    {
        parent::__construct($type, ...$args);
        $this->db = $db;
    }

    /**
    * {@inheritdoc}
    *
    * @psalm-param class-string<TDbObj> $type
    * @psalm-param EasyDB $args[0]
    *
    * @psalm-return AbstractDaftObjectEasyDBRepository<TDbObj>
    */
    public static function DaftObjectRepositoryByType(
        string $type,
        ...$args
    ) : DaftObjectRepository {
        /**
        * @psalm-var array{0:EasyDB}
        */
        $args = $args;

        return new static($type, ...$args);
    }

    /**
    * {@inheritdoc}
    *
    * @psalm-param TDbObj $object
    * @psalm-param EasyDB $args[0]
    *
    * @return static
    *
    * @psalm-return AbstractDaftObjectEasyDBRepository<TDbObj>
    */
    public static function DaftObjectRepositoryByDaftObject(
        SuitableForRepositoryType $object,
        ...$args
    ) : DaftObjectRepository {
        /**
        * @psalm-var class-string<TDbObj>
        */
        $className = get_class($object);

        return static::DaftObjectRepositoryByType($className, ...$args);
    }

    /**
    * @param scalar|(scalar|array|object|null)[] $id
    */
    public function RemoveDaftObjectById($id) : void
    {
        $id = array_values(is_array($id) ? $id : [$id]);

        $idkv = self::DaftObjectIdPropertiesFromType($this->type, $id);

        $this->db->delete($this->DaftObjectDatabaseTable(), $this->ModifyTypesForDatabase($idkv));

        $this->ForgetDaftObjectById($id);
    }

    public function RememberDaftObjectData(
        SuitableForRepositoryType $object,
        bool $assumeDoesNotExist = self::BOOL_DOES_NOT_EXIST
    ) : void {
        $id = [];

        foreach ($object::DaftObjectIdProperties() as $prop) {
            $id[$prop] = $object->__get($prop);
        }

        $this->db->tryFlatTransaction(function () use ($id, $object, $assumeDoesNotExist) : void {
            $exists =
                $assumeDoesNotExist
                    ? self::BOOL_DOES_NOT_EXIST
                    : $this->DaftObjectExistsInDatabase($id);
            $cols = $this->RememberDaftObjectDataCols($object, $exists);

            /**
            * @var array<string, string>
            */
            $cols = array_combine($cols, $cols);

            $this->RememberDaftObjectDataUpdate($exists, $id, $this->ModifyTypesForDatabase(
                array_map([$object, '__get'], $cols)
            ));
        });
    }

    /**
    * @return array<string, mixed>
    */
    protected function ModifyTypesForDatabase(array $values) : array
    {
        /**
        * @var array<string, mixed>
        */
        $out = array_map(
            /**
            * @param mixed $val
            *
            * @return mixed
            */
            function ($val) {
                return
                    is_bool($val)
                        ? (
                            $val
                                ? self::BOOL_TRUE_AS_INT
                                : self::BOOL_FALSE_AS_INT
                        )
                        : $val;
            },
            $values
        );

        return $out;
    }

    abstract protected function DaftObjectDatabaseTable() : string;

    /**
    * {@inheritdoc}
    */
    protected function RecallDaftObjectFromData($id) : ? SuitableForRepositoryType
    {
        $idkv = self::DaftObjectIdPropertiesFromType($this->type, $id);
        $type = $this->type;

        if (true === $this->DaftObjectExistsInDatabase($idkv)) {
            /**
            * @var array[]
            */
            $data = $this->db->safeQuery(
                (
                    'SELECT * FROM ' .
                    $this->db->escapeIdentifier($this->DaftObjectDatabaseTable()) .
                    ' WHERE ' .
                    implode(' AND ', array_map(
                        function (string $col) : string {
                            return $this->db->escapeIdentifier($col) . ' = ?';
                        },
                        array_keys($idkv)
                    )) .
                    ' LIMIT 1'
                ),
                array_values($idkv)
            );

            return new $type($data[0]);
        }

        return null;
    }

    /**
    * @param mixed $id
    *
    * @psalm-param class-string<TDbObj> $type
    *
    * @return array<string, mixed>
    */
    private static function DaftObjectIdPropertiesFromType(string $type, $id) : array
    {
        /**
        * @var array<int, string>
        */
        $idProps = array_values($type::DaftObjectIdProperties());

        if (is_scalar($id) && 1 === count($idProps)) {
            $id = [$id];
        }

        /**
        * @var array<string, mixed>
        */
        $idkv = [];

        if (is_array($id)) {
            foreach ($idProps as $i => $prop) {
                /**
                * @var scalar|array|object|null
                */
                $propVal = $id[$i];

                $idkv[$prop] = $propVal;
            }
        }

        return $idkv;
    }

    /**
    * @return string[]
    */
    private function RememberDaftObjectDataCols(DaftObject $object, bool $exists) : array
    {
        $cols = $object::DaftObjectExportableProperties();

        if ($exists) {
            $changed = $object->ChangedProperties();
            $cols = array_filter($cols, function (string $prop) use ($changed) : bool {
                return in_array($prop, $changed, DefinitionAssistant::IN_ARRAY_STRICT_MODE);
            });
        }

        return $cols;
    }

    private function RememberDaftObjectDataUpdate(bool $exists, array $id, array $values) : void
    {
        if (count($values) > self::COUNT_EMPTY_ARRAY) {
            if (false === $exists) {
                $this->db->insert($this->DaftObjectDatabaseTable(), $values);
            } else {
                $this->db->update($this->DaftObjectDatabaseTable(), $values, $id);
            }
        }
    }

    /**
    * @param array<string, mixed> $id
    */
    private function DaftObjectExistsInDatabase(array $id) : bool
    {
        $where = [];

        foreach (array_keys($id) as $col) {
            $where[] = $this->db->escapeIdentifier($col) . ' = ?';
        }

        return
            $this->db->single(
                (
                    'SELECT COUNT(*) FROM ' .
                    $this->db->escapeIdentifier($this->DaftObjectDatabaseTable()) .
                    ' WHERE ' .
                    implode(' AND ', $where)
                ),
                array_values($id)
            ) >= 1;
    }
}


1		<?php
2		/**
3		* Base daft objects.
4		*
5		* @author SignpostMarv
6		*/
7		declare(strict_types=1);
8
9		namespace SignpostMarv\DaftObject;
10
11		use ParagonIE\EasyDB\EasyDB;
12
13		/**
14		* @template TDbObj as SuitableForRepositoryType
15		*
16		* @template-extends DaftObjectMemoryRepository<TDbObj>
17		*/
18		abstract class AbstractDaftObjectEasyDBRepository extends DaftObjectMemoryRepository
19		{
20		const ARG_SECOND = 2;
21
22		const BOOL_DOES_NOT_EXIST = false;
23
24		const BOOL_TRUE_AS_INT = 1;
25
26		const BOOL_FALSE_AS_INT = 0;
27
28		const COUNT_EMPTY_ARRAY = 0;
29
30		/**
31		* @var EasyDB
32		*/
33		protected $db;
34
35		/**
36		* {@inheritdoc}
37		*
38		* @psalm-param class-string<TDbObj> $type
39		*/
40	6	protected function __construct(string $type, EasyDB $db, ...$args)
41		{
42	6	parent::__construct($type, ...$args);
43	6	$this->db = $db;
44	6	}
45
46		/**
47		* {@inheritdoc}
48		*
49		* @psalm-param class-string<TDbObj> $type
50		* @psalm-param EasyDB $args[0]
51		*
52		* @psalm-return AbstractDaftObjectEasyDBRepository<TDbObj>
53	8	*/
54		public static function DaftObjectRepositoryByType(
55		string $type,
56		...$args
57		) : DaftObjectRepository {
58		/**
59		* @psalm-var array{0:EasyDB}
60	8	*/
61		$args = $args;
62	8
63	8	return new static($type, ...$args);
64	8	}
65	8
66		/**
67		* {@inheritdoc}
68	6	*
69		* @psalm-param TDbObj $object
70		* @psalm-param EasyDB $args[0]
71		*
72		* @return static
73		*
74		* @psalm-return AbstractDaftObjectEasyDBRepository<TDbObj>
75		*/
76		public static function DaftObjectRepositoryByDaftObject(
77		SuitableForRepositoryType $object,
78		...$args
79		) : DaftObjectRepository {
80	6	/**
81		* @psalm-var class-string<TDbObj>
82		*/
83		$className = get_class($object);
84
85		return static::DaftObjectRepositoryByType($className, ...$args);
86		}
87	6
88		/**
89	6	* @param scalar\|(scalar\|array\|object\|null)[] $id
90	6	*/
91	6	public function RemoveDaftObjectById($id) : void
92	6	{
93		$id = array_values(is_array($id) ? $id : [$id]);
94
95		$idkv = self::DaftObjectIdPropertiesFromType($this->type, $id);
96
97		$this->db->delete($this->DaftObjectDatabaseTable(), $this->ModifyTypesForDatabase($idkv));
98	6
99		$this->ForgetDaftObjectById($id);
100	6	}
101
102		public function RememberDaftObjectData(
103		SuitableForRepositoryType $object,
104		bool $assumeDoesNotExist = self::BOOL_DOES_NOT_EXIST
105		) : void {
106	6	$id = [];
107
108	6	foreach ($object::DaftObjectIdProperties() as $prop) {
109		$id[$prop] = $object->__get($prop);
110	6	}
111
112	6	$this->db->tryFlatTransaction(function () use ($id, $object, $assumeDoesNotExist) : void {
113		$exists =
114	6	$assumeDoesNotExist
115	6	? self::BOOL_DOES_NOT_EXIST
116		: $this->DaftObjectExistsInDatabase($id);
117	6	$cols = $this->RememberDaftObjectDataCols($object, $exists);
118
119		/**
120		* @var array<string, string>
121	6	*/
122		$cols = array_combine($cols, $cols);
123	6
124	6	$this->RememberDaftObjectDataUpdate($exists, $id, $this->ModifyTypesForDatabase(
125		array_map([$object, '__get'], $cols)
126		));
127		});
128		}
129	6
130	2	/**
131	6	* @return array<string, mixed>
132	6	*/
133		protected function ModifyTypesForDatabase(array $values) : array
134		{
135		/**
136		* @var array<string, mixed>
137	6	*/
138		$out = array_map(
139	6	/**
140	6	* @param mixed $val
141		*
142	6	* @return mixed
143	6	*/
144		function ($val) {
145		return
146		is_bool($val)
147		? (
148	6	$val
149		? self::BOOL_TRUE_AS_INT
150		: self::BOOL_FALSE_AS_INT
151		)
152		: $val;
153	6	},
154		$values
155		);
156
157		return $out;
158		}
159
160		abstract protected function DaftObjectDatabaseTable() : string;
161	6
162		/**
163	2	* {@inheritdoc}
164	2	*/
165	2	protected function RecallDaftObjectFromData($id) : ? SuitableForRepositoryType
166		{
167	6	$idkv = self::DaftObjectIdPropertiesFromType($this->type, $id);
168	6	$type = $this->type;
169	6
170		if (true === $this->DaftObjectExistsInDatabase($idkv)) {
171		/**
172	6	* @var array[]
173		*/
174		$data = $this->db->safeQuery(
175		(
176		'SELECT * FROM ' .
177		$this->db->escapeIdentifier($this->DaftObjectDatabaseTable()) .
178		' WHERE ' .
179		implode(' AND ', array_map(
180	6	function (string $col) : string {
181		return $this->db->escapeIdentifier($col) . ' = ?';
182	6	},
183	6	array_keys($idkv)
184		)) .
185	6	' LIMIT 1'
186		),
187		array_values($idkv)
188		);
189	6
190		return new $type($data[0]);
191		}
192	6
193	6	return null;
194	6	}
195
196	6	/**
197	6	* @param mixed $id
198	6	*
199		* @psalm-param class-string<TDbObj> $type
200	6	*
201		* @return array<string, mixed>
202	6	*/
203		private static function DaftObjectIdPropertiesFromType(string $type, $id) : array
204		{
205	6	/**
206		* @var array<int, string>
207		*/
208	4	$idProps = array_values($type::DaftObjectIdProperties());
209
210		if (is_scalar($id) && 1 === count($idProps)) {
211		$id = [$id];
212		}
213
214		/**
215		* @var array<string, mixed>
216		*/
217		$idkv = [];
218	6
219		if (is_array($id)) {
220		foreach ($idProps as $i => $prop) {
221		/**
222		* @var scalar\|array\|object\|null
223	6	*/
224		$propVal = $id[$i];
225	6
226	2	$idkv[$prop] = $propVal;
227		}
228		}
229
230		return $idkv;
231		}
232	6
233		/**
234	6	* @return string[]
235	6	*/
236		private function RememberDaftObjectDataCols(DaftObject $object, bool $exists) : array
237		{
238		$cols = $object::DaftObjectExportableProperties();
239	6
240		if ($exists) {
241	6	$changed = $object->ChangedProperties();
242		$cols = array_filter($cols, function (string $prop) use ($changed) : bool {
243		return in_array($prop, $changed, DefinitionAssistant::IN_ARRAY_STRICT_MODE);
244		});
245	6	}
246
247		return $cols;
248	8	}
249
250		private function RememberDaftObjectDataUpdate(bool $exists, array $id, array $values) : void
251		{
252		if (count($values) > self::COUNT_EMPTY_ARRAY) {
253	8	if (false === $exists) {
254	2	$this->db->insert($this->DaftObjectDatabaseTable(), $values);
255	2	} else {
256	2	$this->db->update($this->DaftObjectDatabaseTable(), $values, $id);
257	2	}
258	2	}
259	2	}
260
261		/**
262		* @param array<string, mixed> $id
263	6	*/
264		private function DaftObjectExistsInDatabase(array $id) : bool
265		{
266		$where = [];
267
268		foreach (array_keys($id) as $col) {
269	6	$where[] = $this->db->escapeIdentifier($col) . ' = ?';
270		}
271	6
272		return
273	6	$this->db->single(
274	4	(
275		'SELECT COUNT(*) FROM ' .
276	4	$this->db->escapeIdentifier($this->DaftObjectDatabaseTable()) .
277	4	' WHERE ' .
278		implode(' AND ', $where)
279		),
280	6	array_values($id)
281		) >= 1;
282		}
283		}
284

SignpostMarv / daft-db-object

Push — master ( bacb55...6daee1 )

DaftObjectExistsInDatabase() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like