AbterPhp\Website\Orm\DataMappers\ContentListItemSqlDataMapper

Complexity

Total Complexity

11

Size/Duplication

Total Lines	203
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	update()	0	26	1
A	getAll()	0	5	1
A	add()	0	23	1
A	getPage()	0	20	3
A	delete()	0	12	1
A	loadEntity()	0	12	1
A	getById()	0	11	1
A	getByListId()	0	9	1
A	getBaseQuery()	0	19	1

<?php

declare(strict_types=1);

namespace AbterPhp\Website\Orm\DataMappers;

use AbterPhp\Framework\Domain\Entities\IStringerEntity;
use AbterPhp\Website\Domain\Entities\ContentListItem as Entity;
use Opulence\Orm\DataMappers\SqlDataMapper;
use Opulence\QueryBuilders\MySql\QueryBuilder;
use Opulence\QueryBuilders\MySql\SelectQuery;
use PDO;

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

        $query = (new QueryBuilder())
            ->insert(
                'list_items',
                [
                    'id'        => [$entity->getId(), PDO::PARAM_STR],
                    'list_id'   => [$entity->getListId(), PDO::PARAM_STR],
                    'name'      => [$entity->getName(), PDO::PARAM_STR],
                    'name_href' => [$entity->getNameHref(), PDO::PARAM_STR],
                    'body'      => [$entity->getBody(), PDO::PARAM_STR],
                    'body_href' => [$entity->getBodyHref(), PDO::PARAM_STR],
                    'img_src'   => [$entity->getImgSrc(), PDO::PARAM_STR],
                    'img_href'  => [$entity->getImgHref(), PDO::PARAM_STR],
                    'img_alt'   => [$entity->getImgAlt(), PDO::PARAM_STR],
                ]
            );

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

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

        $query = (new QueryBuilder())
            ->update('list_items', 'list_items', ['deleted' => [1, PDO::PARAM_INT]])
            ->where('id = ?')
            ->addUnnamedPlaceholderValue($entity->getId(), PDO::PARAM_STR);

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

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

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

The expression return $this->read($query->getSql(), array(), 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.

    }

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

        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);

The expression return $this->read($sql, $params, 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.

    }

    /**
     * @param int|string $id
     *
     * @return Entity|null
     * @throws \Opulence\Orm\OrmException
     */
    public function getById($id)
    {
        $query = $this->getBaseQuery()->andWhere('list_items.id = :list_item_id');

        $parameters = [
            'list_item_id' => [$id, PDO::PARAM_STR],
        ];

        $sql = $query->getSql();

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

The expression return $this->read($sql, $parameters, self::VALUE_TYPE_ENTITY, true) also could return the type array which is incompatible with the documented return type AbterPhp\Website\Domain\Entities\ContentListItem|null.

    }

    /**
     * @param string $listId
     *
     * @return array
     * @throws \Opulence\Orm\OrmException
     */
    public function getByListId(string $listId): array
    {
        $query = $this->getBaseQuery()->andWhere('list_items.list_id = :list_id');

        $parameters = [
            'list_id' => [$listId, PDO::PARAM_STR],
        ];

        return $this->read($query->getSql(), $parameters, self::VALUE_TYPE_ARRAY);

The expression return $this->read($query->getSql(), $parameters, 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.

    }

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

        $query = (new QueryBuilder())
            ->update(
                'list_items',
                'list_items',
                [
                    'list_id'   => [$entity->getListId(), PDO::PARAM_STR],
                    'name'      => [$entity->getName(), PDO::PARAM_STR],
                    'name_href' => [$entity->getNameHref(), PDO::PARAM_STR],
                    'body'      => [$entity->getBody(), PDO::PARAM_STR],
                    'body_href' => [$entity->getBodyHref(), PDO::PARAM_STR],
                    'img_src'   => [$entity->getImgSrc(), PDO::PARAM_STR],
                    'img_href'  => [$entity->getImgHref(), PDO::PARAM_STR],
                    'img_alt'   => [$entity->getImgAlt(), PDO::PARAM_STR],
                ]
            )
            ->where('id = ?')
            ->andWhere('list_items.deleted_at IS NULL')
            ->addUnnamedPlaceholderValue($entity->getId(), PDO::PARAM_STR);

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

    /**
     * @param array $hash
     *
     * @return Entity
     */
    protected function loadEntity(array $hash)
    {
        return new Entity(
            $hash['id'],
            $hash['list_id'],
            $hash['name'],
            $hash['name_href'],
            $hash['body'],
            $hash['body_href'],
            $hash['img_src'],
            $hash['img_href'],
            $hash['img_alt']
        );
    }

    /**
     * @return SelectQuery
     */
    private function getBaseQuery(): SelectQuery
    {
        /** @var SelectQuery $query */
        $query = (new QueryBuilder())
            ->select(
                'list_items.id',
                'list_items.list_id',
                'list_items.name',
                'list_items.name_href',
                'list_items.body',
                'list_items.body_href',
                'list_items.img_src',
                'list_items.img_href',
                'list_items.img_alt'
            )
            ->from('list_items')
            ->where('list_items.deleted_at IS NULL');

        return $query;
    }
}