UserLanguageSqlDataMapper::getPage() - Code Metrics - abterphp/admin - Measure and Improve Code Quality continuously with Scrutinizer

UserLanguageSqlDataMapper::getPage() A
last analyzed 2023-01-23 22:21 UTC

↳ Parent: UserLanguageSqlDataMapper

Complexity

Conditions	4
Paths	8

Size

Total Lines	23
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	13
c	1
b	0
f	0
dl	0
loc	23
rs	9.8333
cc	4
nc	8
nop	5

<?php

declare(strict_types=1);

namespace AbterPhp\Admin\Orm\DataMappers;

use AbterPhp\Admin\Domain\Entities\UserLanguage as Entity;
use AbterPhp\Framework\Domain\Entities\IStringerEntity;
use Opulence\Orm\DataMappers\SqlDataMapper;
use Opulence\Orm\OrmException;
use Opulence\QueryBuilders\Expression;
use Opulence\QueryBuilders\InvalidQueryException;
use Opulence\QueryBuilders\MySql\QueryBuilder;
use Opulence\QueryBuilders\SelectQuery;

/** @phan-file-suppress PhanTypeMismatchArgument */
class UserLanguageSqlDataMapper extends SqlDataMapper implements IUserLanguageDataMapper
{
    /**
     * @param IStringerEntity $entity
     */
    public function add($entity)
    {
        assert($entity instanceof Entity, new \InvalidArgumentException());

        $query = (new QueryBuilder())
            ->insert(
                'user_languages',
                [
                    'id'         => $entity->getId(),
                    'identifier' => $entity->getIdentifier(),
                    'name'       => $entity->getName(),
                ]
            );

        $statement = $this->writeConnection->prepare($query->getSql());
        $statement->bindValues($query->getParameters());
        $statement->execute();
    }

    /**
     * @param IStringerEntity $entity
     *
     * @throws InvalidQueryException
     */
    public function delete($entity)
    {
        assert($entity instanceof Entity, new \InvalidArgumentException());

        $query = (new QueryBuilder())
            ->update(
                'user_languages',
                'user_languages',
                ['deleted_at' => new Expression('NOW()')]
            )
            ->where('id = ?')
            ->addUnnamedPlaceholderValue($entity->getId(), \PDO::PARAM_STR);

        $statement = $this->writeConnection->prepare($query->getSql());
        $statement->bindValues($query->getParameters());
        $statement->execute();
    }

    /**
     * @return Entity[]
     * @throws OrmException
     */
    public function getAll(): array
    {
        $query = $this->getBaseQuery();

        $sql = $query->getSql();

        return $this->read($sql, [], self::VALUE_TYPE_ARRAY);

    }

    /**
     * @param int      $limitFrom
     * @param int      $pageSize
     * @param string[] $orders
     * @param array    $conditions
     * @param array    $params
     *
     * @return Entity[]
     * @throws OrmException
     */
    public function getPage(int $limitFrom, int $pageSize, array $orders, array $conditions, array $params): array
    {
        $query = $this->getBaseQuery()
            ->limit($pageSize)
            ->offset($limitFrom);

        if (!$orders) {

            $query->orderBy('created_at ASC');
        }
        foreach ($orders as $order) {
            $query->addOrderBy($order);
        }

        foreach ($conditions as $condition) {
            $query->andWhere($condition);
        }

        $replaceCount = 1;

        $sql = $query->getSql();
        $sql = str_replace('SELECT', 'SELECT SQL_CALC_FOUND_ROWS', $sql, $replaceCount);

        return $this->read($sql, $params, self::VALUE_TYPE_ARRAY);

    }

    /**
     * @param string $id
     *
     * @return Entity|null
     * @throws OrmException
     */
    public function getById($id)
    {
        $query = $this->getBaseQuery()->andWhere('user_languages.id = :user_language_id');

        $sql    = $query->getSql();
        $params = [
            'user_language_id' => [$id, \PDO::PARAM_STR],
        ];

        return $this->read($sql, $params, self::VALUE_TYPE_ENTITY, true);

    }

    /**
     * @param string $identifier
     *
     * @return Entity|null
     * @throws OrmException
     */
    public function getByIdentifier(string $identifier): ?Entity
    {
        $query = $this->getBaseQuery()->andWhere('identifier = :identifier');

        $sql    = $query->getSql();
        $params = [
            'identifier' => [$identifier, \PDO::PARAM_STR],
        ];

        return $this->read($sql, $params, self::VALUE_TYPE_ENTITY, true);

    }

    /**
     * @param IStringerEntity $entity
     *
     * @throws InvalidQueryException
     */
    public function update($entity)
    {
        assert($entity instanceof Entity, new \InvalidArgumentException());

        $query = (new QueryBuilder())
            ->update(
                'user_languages',
                'user_languages',
                [
                    'identifier' => [$entity->getIdentifier(), \PDO::PARAM_STR],
                    'name'       => [$entity->getName(), \PDO::PARAM_STR],
                ]
            )
            ->where('id = ?')
            ->andWhere('deleted_at IS NULL')
            ->addUnnamedPlaceholderValue($entity->getId(), \PDO::PARAM_STR);

        $sql    = $query->getSql();
        $params = $query->getParameters();

        $statement = $this->writeConnection->prepare($sql);
        $statement->bindValues($params);
        $statement->execute();
    }

    /**
     * @param array $hash
     *
     * @return Entity
     */
    protected function loadEntity(array $hash): Entity
    {
        return new Entity(
            $hash['id'],
            $hash['identifier'],
            $hash['name']
        );
    }

    /**
     * @return SelectQuery
     */
    private function getBaseQuery(): SelectQuery
    {
        return (new QueryBuilder())
            ->select(
                'user_languages.id',
                'user_languages.identifier',
                'user_languages.name'
            )
            ->from('user_languages')
            ->where('user_languages.deleted_at IS NULL');
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace AbterPhp\Admin\Orm\DataMappers;
6
7			use AbterPhp\Admin\Domain\Entities\UserLanguage as Entity;
8			use AbterPhp\Framework\Domain\Entities\IStringerEntity;
9			use Opulence\Orm\DataMappers\SqlDataMapper;
10			use Opulence\Orm\OrmException;
11			use Opulence\QueryBuilders\Expression;
12			use Opulence\QueryBuilders\InvalidQueryException;
13			use Opulence\QueryBuilders\MySql\QueryBuilder;
14			use Opulence\QueryBuilders\SelectQuery;
15
16			/** @phan-file-suppress PhanTypeMismatchArgument */
17			class UserLanguageSqlDataMapper extends SqlDataMapper implements IUserLanguageDataMapper
18			{
19			/**
20			* @param IStringerEntity $entity
21			*/
22			public function add($entity)
23			{
24			assert($entity instanceof Entity, new \InvalidArgumentException());
25
26			$query = (new QueryBuilder())
27			->insert(
28			'user_languages',
29			[
30			'id' => $entity->getId(),
31			'identifier' => $entity->getIdentifier(),
32			'name' => $entity->getName(),
33			]
34			);
35
36			$statement = $this->writeConnection->prepare($query->getSql());
37			$statement->bindValues($query->getParameters());
38			$statement->execute();
39			}
40
41			/**
42			* @param IStringerEntity $entity
43			*
44			* @throws InvalidQueryException
45			*/
46			public function delete($entity)
47			{
48			assert($entity instanceof Entity, new \InvalidArgumentException());
49
50			$query = (new QueryBuilder())
51			->update(
52			'user_languages',
53			'user_languages',
54			['deleted_at' => new Expression('NOW()')]
55			)
56			->where('id = ?')
57			->addUnnamedPlaceholderValue($entity->getId(), \PDO::PARAM_STR);
58
59			$statement = $this->writeConnection->prepare($query->getSql());
60			$statement->bindValues($query->getParameters());
61			$statement->execute();
62			}
63
64			/**
65			* @return Entity[]
66			* @throws OrmException
67			*/
68			public function getAll(): array
69			{
70			$query = $this->getBaseQuery();
71
72			$sql = $query->getSql();
73
74			return $this->read($sql, [], self::VALUE_TYPE_ARRAY);
			0 ignored issues – show Bug Best Practice introduced 2019-04-10 12:04 UTC by Report Bug Copy Issue Report The expression `return $this->read($sql,...self::VALUE_TYPE_ARRAY)` could return the type `null` which is incompatible with the type-hinted return `array`. Consider adding an additional type-check to rule them out. Loading history...
75			}
76
77			/**
78			* @param int $limitFrom
79			* @param int $pageSize
80			* @param string[] $orders
81			* @param array $conditions
82			* @param array $params
83			*
84			* @return Entity[]
85			* @throws OrmException
86			*/
87			public function getPage(int $limitFrom, int $pageSize, array $orders, array $conditions, array $params): array
88			{
89			$query = $this->getBaseQuery()
90			->limit($pageSize)
91			->offset($limitFrom);
92
93			if (!$orders) {
			0 ignored issues – show Bug Best Practice introduced 2020-01-19 07:41 UTC by Report Bug Copy Issue Report The expression `$orders` of type `string[]` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
94			$query->orderBy('created_at ASC');
95			}
96			foreach ($orders as $order) {
97			$query->addOrderBy($order);
98			}
99
100			foreach ($conditions as $condition) {
101			$query->andWhere($condition);
102			}
103
104			$replaceCount = 1;
105
106			$sql = $query->getSql();
107			$sql = str_replace('SELECT', 'SELECT SQL_CALC_FOUND_ROWS', $sql, $replaceCount);
108
109			return $this->read($sql, $params, self::VALUE_TYPE_ARRAY);
			0 ignored issues – show Bug Best Practice introduced 2019-04-10 12:04 UTC by Report Bug Copy Issue Report The expression `return $this->read($sql,...self::VALUE_TYPE_ARRAY)` could return the type `null` which is incompatible with the type-hinted return `array`. Consider adding an additional type-check to rule them out. Loading history...
110			}
111
112			/**
113			* @param string $id
114			*
115			* @return Entity\|null
116			* @throws OrmException
117			*/
118			public function getById($id)
119			{
120			$query = $this->getBaseQuery()->andWhere('user_languages.id = :user_language_id');
121
122			$sql = $query->getSql();
123			$params = [
124			'user_language_id' => [$id, \PDO::PARAM_STR],
125			];
126
127			return $this->read($sql, $params, self::VALUE_TYPE_ENTITY, true);
			0 ignored issues – show Bug Best Practice introduced 2019-04-10 12:04 UTC by Report Bug Copy Issue Report The expression `return $this->read($sql,...ALUE_TYPE_ENTITY, true)` also could return the type `array` which is incompatible with the documented return type `AbterPhp\Admin\Domain\Entities\UserLanguage\|null`. Loading history...
128			}
129
130			/**
131			* @param string $identifier
132			*
133			* @return Entity\|null
134			* @throws OrmException
135			*/
136			public function getByIdentifier(string $identifier): ?Entity
137			{
138			$query = $this->getBaseQuery()->andWhere('identifier = :identifier');
139
140			$sql = $query->getSql();
141			$params = [
142			'identifier' => [$identifier, \PDO::PARAM_STR],
143			];
144
145			return $this->read($sql, $params, self::VALUE_TYPE_ENTITY, true);
			0 ignored issues – show Bug Best Practice introduced 2019-04-10 12:04 UTC by Report Bug Copy Issue Report The expression `return $this->read($sql,...ALUE_TYPE_ENTITY, true)` could return the type `array` which is incompatible with the type-hinted return `AbterPhp\Admin\Domain\Entities\UserLanguage\|null`. Consider adding an additional type-check to rule them out. Loading history...
146			}
147
148			/**
149			* @param IStringerEntity $entity
150			*
151			* @throws InvalidQueryException
152			*/
153			public function update($entity)
154			{
155			assert($entity instanceof Entity, new \InvalidArgumentException());
156
157			$query = (new QueryBuilder())
158			->update(
159			'user_languages',
160			'user_languages',
161			[
162			'identifier' => [$entity->getIdentifier(), \PDO::PARAM_STR],
163			'name' => [$entity->getName(), \PDO::PARAM_STR],
164			]
165			)
166			->where('id = ?')
167			->andWhere('deleted_at IS NULL')
168			->addUnnamedPlaceholderValue($entity->getId(), \PDO::PARAM_STR);
169
170			$sql = $query->getSql();
171			$params = $query->getParameters();
172
173			$statement = $this->writeConnection->prepare($sql);
174			$statement->bindValues($params);
175			$statement->execute();
176			}
177
178			/**
179			* @param array $hash
180			*
181			* @return Entity
182			*/
183			protected function loadEntity(array $hash): Entity
184			{
185			return new Entity(
186			$hash['id'],
187			$hash['identifier'],
188			$hash['name']
189			);
190			}
191
192			/**
193			* @return SelectQuery
194			*/
195			private function getBaseQuery(): SelectQuery
196			{
197			return (new QueryBuilder())
198			->select(
199			'user_languages.id',
200			'user_languages.identifier',
201			'user_languages.name'
202			)
203			->from('user_languages')
204			->where('user_languages.deleted_at IS NULL');
205			}
206			}
207

abterphp / admin

UserLanguageSqlDataMapper::getPage() A last analyzed 2023-01-23 22:21 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

UserLanguageSqlDataMapper::getPage() A
last analyzed 2023-01-23 22:21 UTC