<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\DTORequest;

/**
 * @api
 * Interface CategoryDataRequestInterface
 * @package App\DataManagerFeatureApi\DTORequest
 *
 * Request object for a category creation
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 **/
interface CategoryDataRequestInterface
{
    /**
     * @return int|null
     */
    public function getId(): ?int;

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void;

    /**
     * @return string|null
     */
    public function getTitle(): ?string;

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void;

    /**
     * @return string|null
     */
    public function getContent(): ?string;

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void;

    /**
     * @return string|null
     */
    public function getSlug(): ?string;

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void;

    /**
     * @return bool
     */
    public function isActive(): bool;

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\DTORequest;

/**
 * @api
 * Interface PostDataRequestInterface
 * @package App\DataManagerFeatureApi\DTORequest
 *
 * Request object for a post creation
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface PostDataRequestInterface
{
    /**
     * @return int|null
     */
    public function getId(): ?int;

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void;

    /**
     * @return string|null
     */
    public function getTitle(): ?string;

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void;

    /**
     * @return string|null
     */
    public function getContent(): ?string;

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void;

    /**
     * @return string|null
     */
    public function getSlug(): ?string;

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void;

    /**
     * @return bool
     */
    public function isPublished(): bool;

    /**
     * @param bool $published
     */
    public function setPublished(bool $published): void;

    /**
     * @param int|null $id
     * @return void
     */
    public function setCategoryId(int $id = null): void;

    /**
     * @return int|null
     */
    public function getCategoryId(): ?int;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\DTORequestFactory;

use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;

/**
 * @api
 * Interface CategoryDataRequestFactoryInterface
 * @package App\DataManagerFeatureApi\DTORequestFactory
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 **/
interface CategoryDataRequestFactoryInterface
{
    /**
     * @return CategoryDataRequestInterface
     */
    public function create(): CategoryDataRequestInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\DTORequestFactory;

use App\DataManagerFeatureApi\DTORequest\PostDataRequestInterface;

/**
 * @api
 * Interface PostDataRequestFactoryInterface
 * @package App\DataManagerFeatureApi\DTORequestFactory
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface PostDataRequestFactoryInterface
{
    /**
     * @return PostDataRequestInterface
     */
    public function create(): PostDataRequestInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\DTOResponse;

/**
 * @api
 * Interface CategoryDataResponseInterface
 * @package App\DataManagerFeatureApi\DTOResponse
 *
 * Module response object. This object will be returned for other features usage.
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 **/
interface CategoryDataResponseInterface
{
    /**
     * @return int|null
     */
    public function getId(): ?int;

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void;

    /**
     * @return string|null
     */
    public function getTitle(): ?string;

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void;

    /**
     * @return string|null
     */
    public function getContent(): ?string;

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void;

    /**
     * @return string
     */
    public function getSlug(): string;

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void;

    /**
     * @return bool
     */
    public function isActive(): bool;

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\DTOResponse;

/**
 * @api
 * Interface PostDataResponseInterface
 * @package App\DataManagerFeatureApi\DTOResponse
 *
 * Module response object. This object will be returned for other features usage.
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface PostDataResponseInterface
{
    /**
     * @return int|null
     */
    public function getId(): ?int;

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void;

    /**
     * @return string|null
     */
    public function getTitle(): ?string;

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void;

    /**
     * @return string|null
     */
    public function getContent(): ?string;

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void;

    /**
     * @return string|null
     */
    public function getSlug(): ?string;

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void;

    /**
     * @return bool
     */
    public function isPublished(): bool;

    /**
     * @param bool $published
     */
    public function setPublished(bool $published): void;

    /**
     * @return string|null
     */
    public function getUpdatedAt(): ?string;

    /**
     * @param string|null $updatedAt
     * @return void
     */
    public function setUpdatedAt(?string $updatedAt = null): void;

    /**
     * @return string|null
     */
    public function getCreatedAt(): ?string;

    /**
     * @param string|null $createdAt
     * @return void
     */
    public function setCreatedAt(string $createdAt = null): void;

    /**
     * @param int|null $id
     * @return void
     */
    public function setCategoryId(int $id = null): void;

    /**
     * @return int|null
     */
    public function getCategoryId(): ?int;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\Service;

use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;
use App\DataManagerFeatureApi\DTOResponse\CategoryDataResponseInterface;

/**
 * @api
 * Interface CategoryDataServiceInterface
 * @package App\DataManagerFeatureApi\Service
 *
 * Api service for categories management
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 **/
interface CategoryDataServiceInterface
{
    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array;

    /**
     * @param int $categoryId
     * @return CategoryDataResponseInterface|null
     */
    public function getById(int $categoryId): ?CategoryDataResponseInterface;

    /**
     * @param CategoryDataRequestInterface $dtoRequest
     * @return CategoryDataResponseInterface
     */
    public function save(CategoryDataRequestInterface $dtoRequest): CategoryDataResponseInterface;

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void;

    /**
     * @param string $slug
     * @return CategoryDataResponseInterface|null
     */
    public function getBySlug(string $slug): ?CategoryDataResponseInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DataManagerFeatureApi\Service;

use App\DataManagerFeatureApi\DTORequest\PostDataRequestInterface;
use App\DataManagerFeatureApi\DTOResponse\PostDataResponseInterface;

/**
 * @api
 * Interface PostDataServiceInterface
 * @package App\DataManagerFeatureApi\Service
 *
 * Api service for posts management
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface PostDataServiceInterface
{
    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array;

    /**
     * @param int $postId
     * @return PostDataResponseInterface|null
     */
    public function getById(int $postId): ?PostDataResponseInterface;

    /**
     * @param PostDataRequestInterface $dtoRequest
     * @return PostDataResponseInterface
     */
    public function save(PostDataRequestInterface $dtoRequest): PostDataResponseInterface;

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void;

    /**
     * @param string $slug
     * @return PostDataResponseInterface|null
     */
    public function getBySlug(string $slug): ?PostDataResponseInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Domain\Entity;

use App\DoctrineDataFeature\Infrastructure\Repository\CategoryRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

/**
 * Class Category
 * Doctrine entity determination
 *
 * @package App\DoctrineDataFeature\Infrastructure\Entity\Doctrine
 */
#[ORM\Entity(repositoryClass: CategoryRepository::class)]
class Category
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $title = null;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
    private ?string $content = null;

    #[ORM\Column(length: 255, unique: true)]
    private ?string $slug = null;

    #[ORM\Column]
    private bool $isActive = false;

    /**
     * @param int|null $id
     */
    public function setId(?int $id): void
    {
        $this->id = $id;
    }

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string $title
     * @return $this
     */
    public function setTitle(string $title): self
    {
        $this->title = $title;
        return $this;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     * @return $this
     */
    public function setContent(?string $content): self
    {
        $this->content = $content;
        return $this;
    }

    /**
     * @return string|null
     */
    public function getSlug(): ?string
    {
        return $this->slug;
    }

    /**
     * @param string $slug
     * @return $this
     */
    public function setSlug(string $slug): self
    {
        $this->slug = $slug;
        return $this;
    }

    /**
     * @return bool
     */
    public function getIsActive(): bool
    {
        return $this->isActive;
    }

    /**
     * @param bool $active
     * @return $this
     */
    public function setActive(bool $active): self
    {
        $this->isActive = $active;
        return $this;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Domain\Entity;

use App\DoctrineDataFeature\Infrastructure\Repository\PostRepository;
use DateTime;
use DateTimeInterface;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

/**
 * Class Post
 * Doctrine entity determination
 *
 * @package App\DoctrineDataFeature\Domain\Entity
 */
#[ORM\Entity(repositoryClass: PostRepository::class)]
#[ORM\HasLifecycleCallbacks]
class Post
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    private ?string $title = null;

    #[ORM\Column(type: Types::TEXT, nullable: true)]
    private ?string $content = null;

    #[ORM\Column(length: 255, unique: true)]
    private ?string $slug = null;

    #[ORM\Column]
    private bool $isPublished = false;

    #[ORM\Column(type: "datetime", nullable: true)]
    private ?DateTimeInterface $createdAt = null;

    #[ORM\Column(type: "datetime", nullable: true)]
    private ?DateTimeInterface $updatedAt = null;

    #[ORM\ManyToOne(targetEntity: Category::class, inversedBy: 'posts')]
    private Category|null $category = null;

    /**
     * @param int|null $id
     */
    public function setId(?int $id): void
    {
        $this->id = $id;
    }

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string $title
     * @return $this
     */
    public function setTitle(string $title): self
    {
        $this->title = $title;
        return $this;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     * @return $this
     */
    public function setContent(?string $content): self
    {
        $this->content = $content;
        return $this;
    }

    /**
     * @return string|null
     */
    public function getSlug(): ?string
    {
        return $this->slug;
    }

    /**
     * @param string $slug
     * @return $this
     */
    public function setSlug(string $slug): self
    {
        $this->slug = $slug;
        return $this;
    }

    /**
     * @return bool
     */
    public function isPublished(): bool
    {
        return $this->isPublished;
    }

    /**
     * @param bool $published
     * @return $this
     */
    public function setPublished(bool $published): self
    {
        $this->isPublished = $published;
        return $this;
    }

    /**
     * @return Category|null
     */
    public function getCategory(): ?Category
    {
        return $this->category;
    }

    /**
     * @param Category|null $category
     * @return Post
     */
    public function setCategory(?Category $category): self
    {
        $this->category = $category;
        return $this;
    }

    /**
     * @return DateTimeInterface|null
     */
    public function getCreatedAt(): ?DateTimeInterface
    {
        return $this->createdAt;
    }

    /**
     * @param DateTimeInterface|null $timestamp
     * @return $this
     */
    public function setCreatedAt(?DateTimeInterface $timestamp): self
    {
        $this->createdAt = $timestamp;
        return $this;
    }

    /**
     * @return DateTimeInterface|null
     */
    public function getUpdatedAt(): ?DateTimeInterface
    {
        return $this->updatedAt;
    }

    /**
     * @param DateTimeInterface|null $timestamp
     * @return $this
     */
    public function setUpdatedAt(?DateTimeInterface $timestamp): self
    {
        $this->updatedAt = $timestamp;
        return $this;
    }

    #[ORM\PrePersist]
    #[ORM\PreUpdate]
    /**
     * @return void
     */
    protected function updateTimestamps(): void
    {
        $dateTimeNow = new DateTime('now');

        $this->setUpdatedAt($dateTimeNow);

        if ($this->getCreatedAt() === null) {
            $this->setCreatedAt($dateTimeNow);
        }
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Domain\Repository;

use App\DoctrineDataFeature\Domain\Entity\Category;

/**
 * Interface CategoryRepositoryInterface
 * @package App\DoctrineDataFeature\Domain\Repository
 *
 * Domain layer NEVER implements repository. Domain doesn't know anything about data storages.
 * Domain uses behavior description, repository must be implemented in Infrastructure layer according to a source
 * (eg. DB, Session and so on)
 **/
interface CategoryRepositoryInterface
{
    /**
     * @param Category $category
     * @return Category
     */
    public function save(Category $category): Category;

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array;

    /**
     * @param int $id
     * @return object|null
     */
    public function getById(int $id): ?object;

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void;

    /**
     * @param object $category
     * @return void
     */
    public function delete(object $category): void;

    /**
     * @param string $slug
     * @return object|null
     */
    public function getBySlug(string $slug): ?object;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Domain\Repository;

use App\DoctrineDataFeature\Domain\Entity\Post;

/**
 * Interface PostRepositoryInterface
 * @package App\DoctrineDataFeature\Domain\Repository
 *
 * Domain layer NEVER implements repository. Domain doesn't know anything about data storages.
 * Domain uses behavior description, repository must be implemented in Infrastructure layer according to a source
 * (eg. DB, Session and so on)
 */
interface PostRepositoryInterface
{
    /**
     * @param Post $post
     * @return Post
     */
    public function save(Post $post): Post;

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array;

    /**
     * @param int $id
     * @return object|null
     */
    public function getById(int $id): ?object;

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void;

    /**
     * @param object $post
     * @return void
     */
    public function delete(object $post): void;

    /**
     * @param string $slug
     * @return object|null
     */
    public function getBySlug(string $slug): ?object;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Infrastructure\Repository;

use App\DoctrineDataFeature\Domain\Entity\Category;
use App\DoctrineDataFeature\Domain\Repository\CategoryRepositoryInterface;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\ORM\NonUniqueResultException;
use Doctrine\Persistence\ManagerRegistry;
use InvalidArgumentException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * Class CategoryRepository
 * Work directly with data storage
 *
 * @package App\DoctrineDataFeature\Infrastructure\Persistence\Doctrine
 *
 * @method Category|null find($id, $lockMode = null, $lockVersion = null)
 * @method Category|null findOneBy(array $criteria, array $orderBy = null)
 * @method Category[]    findAll()
 * @method Category[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
 **/
class CategoryRepository extends ServiceEntityRepository implements CategoryRepositoryInterface
{
    /**
     * @param ManagerRegistry $registry
     */
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Category::class);
    }

    /**
     * @param Category $category
     * @return Category
     */
    public function save(Category $category): Category
    {
        if ($category->getId()) {
            $this->_em->merge($category);
        } else {
            $this->_em->persist($category);
        }

        $this->_em->flush();

        return $category;
    }

    /**
     * @return object[]
     */
    public function getList(array $criteria = null): array
    {
        if (!$criteria) {
            return $this->findAll();
        }

        return $this->findBy($criteria);
    }

    /**
     * @param int $id
     * @return Category|null
     */
    public function getById(int $id): ?Category
    {
        return $this->find($id);
    }

    /**
     * @param string $slug
     * @return object|null
     * @throws NonUniqueResultException
     */
    public function getBySlug(string $slug): ?object
    {
        $qb = $this->createQueryBuilder('q')
            ->where('q.slug = :slug')
            ->setParameter('slug', $slug);

        $query = $qb->getQuery();

        return $query->setMaxResults(1)->getOneOrNullResult();
    }

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void
    {
        $category = $this->find($id);

        if (!$category) {
            throw new NotFoundHttpException(sprintf("The category with ID '%s' doesn't exist", $id));
        }

        $this->delete($category);
    }

    /**
     * @param object $category
     * @return void
     */
    public function delete(object $category): void
    {
        if (!$category instanceof Category) {
            throw new InvalidArgumentException(
                sprintf('You can only pass %s entity to this repository.', Category::class)
            );
        }

        $this->_em->remove($category);
        $this->_em->flush();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Infrastructure\Repository;

use App\DoctrineDataFeature\Domain\Entity\Post;
use App\DoctrineDataFeature\Domain\Repository\PostRepositoryInterface;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\ORM\NonUniqueResultException;
use Doctrine\Persistence\ManagerRegistry;
use InvalidArgumentException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * Class PostRepository
 * Work directly with data storage
 *
 * @package App\DoctrineDataFeature\Infrastructure\Repository
 *
 * @method Post|null find($id, $lockMode = null, $lockVersion = null)
 * @method Post|null findOneBy(array $criteria, array $orderBy = null)
 * @method Post[]    findAll()
 * @method Post[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
 */
class PostRepository extends ServiceEntityRepository implements PostRepositoryInterface
{
    /**
     * @param ManagerRegistry $registry
     */
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Post::class);
    }

    /**
     * @param Post $post
     * @return Post
     */
    public function save(Post $post): Post
    {
        if ($post->getId()) {
            $this->_em->merge($post);
        } else {
            $this->_em->persist($post);
        }

        $this->_em->flush();

        return $post;
    }

    /**
     * @return object[]
     */
    public function getList(array $criteria = null): array
    {
        if (!$criteria) {
            return $this->findAll();
        }

        return $this->findBy($criteria);
    }

    /**
     * @param int $id
     * @return Post|null
     */
    public function getById(int $id): ?Post
    {
        return $this->find($id);
    }

    /**
     * @param string $slug
     * @return object|null
     * @throws NonUniqueResultException
     */
    public function getBySlug(string $slug): ?object
    {
        $qb = $this->createQueryBuilder('q')
            ->where('q.slug = :slug')
            ->setParameter('slug', $slug);

        $query = $qb->getQuery();

        return $query->setMaxResults(1)->getOneOrNullResult();
    }

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void
    {
        $post = $this->find($id);

        if (!$post) {
            throw new NotFoundHttpException(sprintf("The post with ID '%s' doesn't exist", $id));
        }

        $this->delete($post);
    }

    /**
     * @param object $post
     * @return void
     */
    public function delete(object $post): void
    {
        if (!$post instanceof Post) {
            throw new InvalidArgumentException(
                sprintf('You can only pass %s entity to this repository.', Post::class)
            );
        }

        $this->_em->remove($post);
        $this->_em->flush();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\ApiService;

use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;
use App\DataManagerFeatureApi\DTOResponse\CategoryDataResponseInterface;
use App\DataManagerFeatureApi\Service\CategoryDataServiceInterface;
use App\DoctrineDataFeature\Application\DataMapper\DataMapperInterface;
use App\DoctrineDataFeature\Domain\Repository\CategoryRepositoryInterface;

/**
 * Class CategoryService
 * @package App\DoctrineDataFeature\Application\ApiService
 *
 * This class is for external usage (outside this feature) only
 * Use CategoryDataServiceInterface for data manipulating and return DTOResponse here
 *
 * Don't return Domain entity outside the feature!
 **/
class CategoryService implements CategoryDataServiceInterface
{
    private DataMapperInterface $dataMapper;
    private CategoryRepositoryInterface $categoryRepository;

    /**
     * Use DI for injecting appropriate objects here
     * @param DataMapperInterface $dataMapper
     * @param CategoryRepositoryInterface $categoryRepository
     */
    public function __construct(
        DataMapperInterface $dataMapper,
        CategoryRepositoryInterface $categoryRepository
    ) {
        $this->dataMapper = $dataMapper;
        $this->categoryRepository = $categoryRepository;
    }

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array
    {
        $list = [];
        $result = $this->categoryRepository->getList($criteria);

        foreach ($result as $item) {
            $list[] = $this->dataMapper->toResponse($item);
        }

        return $list;
    }

    /**
     * @param int $categoryId
     * @return CategoryDataResponseInterface|null
     */
    public function getById(int $categoryId): ?CategoryDataResponseInterface
    {
        $entity = $this->categoryRepository->getById($categoryId);
        return $entity ? $this->dataMapper->toResponse($entity) : null;
    }

    /**
     * @param CategoryDataRequestInterface $dtoRequest
     * @return CategoryDataResponseInterface
     */
    public function save(CategoryDataRequestInterface $dtoRequest): CategoryDataResponseInterface
    {
        $entity = $this->dataMapper->toEntity($dtoRequest);
        $this->categoryRepository->save($entity);

        return $this->dataMapper->toResponse($entity);
    }

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void
    {
        $this->categoryRepository->deleteById($id);
    }

    /**
     * @param string $slug
     * @return CategoryDataResponseInterface|null
     */
    public function getBySlug(string $slug): ?CategoryDataResponseInterface
    {
        $entity = $this->categoryRepository->getBySlug($slug);
        return $entity ? $this->dataMapper->toResponse($entity) : null;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\ApiService;

use App\DataManagerFeatureApi\DTORequest\PostDataRequestInterface;
use App\DataManagerFeatureApi\DTOResponse\PostDataResponseInterface;
use App\DataManagerFeatureApi\Service\PostDataServiceInterface;
use App\DoctrineDataFeature\Application\DataMapper\DataMapperInterface;
use App\DoctrineDataFeature\Domain\Repository\PostRepositoryInterface;

/**
 * Class PostService
 * @package App\DoctrineDataFeature\Application\ApiService
 *
 * This class is for external usage (outside this feature) only
 * Use CategoryDataServiceInterface for data manipulating and return DTOResponse here
 *
 * Don't return Domain entity outside the feature!
 */
class PostService implements PostDataServiceInterface
{
    private DataMapperInterface $dataMapper;
    private PostRepositoryInterface $postRepository;

    /**
     * @param DataMapperInterface $dataMapper
     * @param PostRepositoryInterface $postRepository
     */
    public function __construct(
        DataMapperInterface $dataMapper,
        PostRepositoryInterface $postRepository
    ) {
        $this->dataMapper = $dataMapper;
        $this->postRepository = $postRepository;
    }

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array
    {
        $list = [];
        $result = $this->postRepository->getList($criteria);

        foreach ($result as $item) {
            $list[] = $this->dataMapper->toResponse($item);
        }

        return $list;
    }

    /**
     * @param int $postId
     * @return PostDataResponseInterface|null
     */
    public function getById(int $postId): ?PostDataResponseInterface
    {
        $entity = $this->postRepository->getById($postId);
        return $entity ? $this->dataMapper->toResponse($entity) : null;
    }

    /**
     * @param PostDataRequestInterface $dtoRequest
     * @return PostDataResponseInterface
     */
    public function save(PostDataRequestInterface $dtoRequest): PostDataResponseInterface
    {
        $entity = $this->dataMapper->toEntity($dtoRequest);
        $this->postRepository->save($entity);

        return $this->dataMapper->toResponse($entity);
    }

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void
    {
        $this->postRepository->deleteById($id);
    }

    /**
     * @param string $slug
     * @return PostDataResponseInterface|null
     */
    public function getBySlug(string $slug): ?PostDataResponseInterface
    {
        $entity = $this->postRepository->getBySlug($slug);
        return $entity ? $this->dataMapper->toResponse($entity) : null;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DataMapper;

use App\DoctrineDataFeature\Application\DTORequest\DataRequestInterface;
use App\DoctrineDataFeature\Application\DTOResponse\DataResponseInterface;

/**
 * Interface DataMapperInterface
 * This is common interface for data mappers.
 *
 * @package App\DoctrineDataFeature\Application\EntityMapper
 **/
interface DataMapperInterface
{
    /**
     * Map DTORequest object to Infrastructure entity
     * @param DataRequestInterface $request
     * @return object
     */
    public function toEntity(DataRequestInterface $request): object;

    /**
     * Map entity to DTOResponse
     * @param object $entity
     * @return DataResponseInterface
     */
    public function toResponse(object $entity): DataResponseInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DataMapper;

use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;
use App\DoctrineDataFeature\Application\DTORequest\DataRequestInterface;
use App\DoctrineDataFeature\Application\DTOResponse\DataResponseInterface;
use App\DoctrineDataFeature\Application\DTOResponseFactory\CategoryResponseFactoryInterface;
use App\DoctrineDataFeature\Domain\Entity\Category;
use InvalidArgumentException;

/**
 * Class CategoryMapper
 * @package App\DoctrineDataFeature\Application\DTOEntityMapper
 **/
class CategoryMapper implements DataMapperInterface
{
    private CategoryResponseFactoryInterface $categoryResponseFactory;

    /**
     * @param CategoryResponseFactoryInterface $categoryResponseFactory
     */
    public function __construct(CategoryResponseFactoryInterface $categoryResponseFactory)
    {
        $this->categoryResponseFactory = $categoryResponseFactory;
    }

    /**
     * Map DTORequest object to Infrastructure entity
     * @param DataRequestInterface $request
     * @return Category
     */
    public function toEntity(DataRequestInterface $request): Category
    {
        if (!$request instanceof CategoryDataRequestInterface) {
            throw new InvalidArgumentException(
                sprintf('You can pass %s only to this mapper.', CategoryDataRequestInterface::class)
            );
        }

        $doctrineEntity = new Category();

        $doctrineEntity->setId($request->getId());
        $doctrineEntity->setActive($request->isActive());
        $doctrineEntity->setContent($request->getContent());
        $doctrineEntity->setSlug($request->getSlug());
        $doctrineEntity->setTitle($request->getTitle());

        return $doctrineEntity;
    }

    /**
     * Map entity to DTOResponse
     * @param object $entity
     * @return DataResponseInterface
     */
    public function toResponse(object $entity): DataResponseInterface
    {
        if (!$entity instanceof Category) {
            throw new InvalidArgumentException(
                sprintf('You can only pass %s entity to this mapper.', Category::class)
            );
        }

        $response = $this->categoryResponseFactory->create();

        $response->setId($entity->getId());
        $response->setActive($entity->getIsActive());
        $response->setContent($entity->getContent());
        $response->setSlug($entity->getSlug());
        $response->setTitle($entity->getTitle());

        return $response;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DataMapper;

use App\DataManagerFeatureApi\DTORequest\PostDataRequestInterface;
use App\DoctrineDataFeature\Application\DTORequest\DataRequestInterface;
use App\DoctrineDataFeature\Application\DTOResponse\DataResponseInterface;
use App\DoctrineDataFeature\Application\DTOResponseFactory\PostResponseFactoryInterface;
use App\DoctrineDataFeature\Domain\Entity\Category;
use App\DoctrineDataFeature\Domain\Entity\Post;
use App\DoctrineDataFeature\Domain\Repository\CategoryRepositoryInterface;
use InvalidArgumentException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

/**
 * Class PostMapper
 * @package App\DoctrineDataFeature\Application\DataMapper
 */
class PostMapper implements DataMapperInterface
{
    private PostResponseFactoryInterface $postResponseFactory;
    private CategoryRepositoryInterface $categoryRepository;

    /**
     * @param PostResponseFactoryInterface $postResponseFactory
     * @param CategoryRepositoryInterface $categoryRepository
     */
    public function __construct(
        PostResponseFactoryInterface $postResponseFactory,
        CategoryRepositoryInterface $categoryRepository
    ) {
        $this->postResponseFactory = $postResponseFactory;
        $this->categoryRepository = $categoryRepository;
    }

    /**
     * Map DTORequest object to Infrastructure entity
     * @param DataRequestInterface $request
     * @return object
     */
    public function toEntity(DataRequestInterface $request): object
    {
        if (!$request instanceof PostDataRequestInterface) {
            throw new InvalidArgumentException(
                sprintf('You can pass %s only to this mapper.', PostDataRequestInterface::class)
            );
        }

        $doctrineEntity = new Post();

        $doctrineEntity->setId($request->getId());
        $doctrineEntity->setPublished($request->isPublished());
        $doctrineEntity->setContent($request->getContent());
        $doctrineEntity->setSlug($request->getSlug());
        $doctrineEntity->setTitle($request->getTitle());

        if ($categoryId = $request->getCategoryId()) {
            $category = $this->getCategory($categoryId);
            $doctrineEntity->setCategory($category);
        }

        return $doctrineEntity;
    }

    /**
     * @param int $categoryId
     * @return Category
     */
    private function getCategory(int $categoryId): Category
    {
        $category = $this->categoryRepository->getById($categoryId);

        if (!$category) {
            throw new NotFoundHttpException(sprintf("The category with ID '%s' doesn't exist", $category));
        }

        return $category;
    }

    /**
     * Map entity to DTOResponse
     * @param object $entity
     * @return DataResponseInterface
     */
    public function toResponse(object $entity): DataResponseInterface
    {
        if (!$entity instanceof Post) {
            throw new InvalidArgumentException(
                sprintf('You can only pass %s entity to this mapper.', Post::class)
            );
        }

        $response = $this->postResponseFactory->create();

        $response->setId($entity->getId());
        $response->setPublished($entity->isPublished());
        $response->setContent($entity->getContent());
        $response->setSlug($entity->getSlug());
        $response->setTitle($entity->getTitle());
        $response->setCategoryId($entity->getCategory()?->getId());

        return $response;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTORequest;

/**
 * Interface DataRequestInterface
 * Marker for DTO request objects
 * @package App\DoctrineDataFeature\Application\DTORequest
 **/
interface DataRequestInterface
{

}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTORequest;

use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;

/**
 * Class CategoryUpdate
 * Request object for a category creation
 * @package App\DoctrineDataFeature\Application\DTORequest
 **/
class CategoryRequest implements CategoryDataRequestInterface, DataRequestInterface
{
    private ?int $id = null;
    private ?string $title = null;
    private ?string $content = null;
    private ?string $slug = null;
    private bool $isActive = false;

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void
    {
        $this->id = $id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void
    {
        $this->content = $content;
    }

    /**
     * @return string|null
     */
    public function getSlug(): ?string
    {
        return $this->slug;
    }

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void
    {
        $this->slug = $slug;
    }

    /**
     * @return bool
     */
    public function isActive(): bool
    {
        return $this->isActive;
    }

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void
    {
        $this->isActive = $active;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTORequest;

use App\DataManagerFeatureApi\DTORequest\PostDataRequestInterface;

/**
 * Class PostRequest
 * Request object for a post creation
 * @package App\DoctrineDataFeature\Application\DTORequest
 */
class PostRequest implements PostDataRequestInterface, DataRequestInterface
{
    private ?int $id = null;
    private ?string $title = null;
    private ?string $content = null;
    private ?string $slug = null;
    private bool $isPublished = false;
    private ?int $categoryId = null;

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void
    {
        $this->id = $id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void
    {
        $this->content = $content;
    }

    /**
     * @return string
     */
    public function getSlug(): string
    {
        return $this->slug;
    }

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void
    {
        $this->slug = $slug;
    }

    /**
     * @return bool
     */
    public function isPublished(): bool
    {
        return $this->isPublished;
    }

    /**
     * @param bool $published
     */
    public function setPublished(bool $published): void
    {
        $this->isPublished = $published;
    }

    /**
     * @param int|null $id
     * @return void
     */
    public function setCategoryId(int $id = null): void
    {
       $this->categoryId = $id;
    }

    /**
     * @return int|null
     */
    public function getCategoryId(): ?int
    {
       return $this->categoryId;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTORequestFactory;

use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;
use App\DataManagerFeatureApi\DTORequestFactory\CategoryDataRequestFactoryInterface;
use App\DoctrineDataFeature\Application\DTORequest\CategoryRequest;

/**
 * Class CategoryCreateFactory
 * @package App\DoctrineDataFeature\Application\DTORequestFactory
 **/
class CategoryRequestFactory implements CategoryDataRequestFactoryInterface
{
    /**
     * @return CategoryDataRequestInterface
     */
    public function create(): CategoryDataRequestInterface
    {
        return new CategoryRequest();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTORequestFactory;

use App\DataManagerFeatureApi\DTORequest\PostDataRequestInterface;
use App\DataManagerFeatureApi\DTORequestFactory\PostDataRequestFactoryInterface;
use App\DoctrineDataFeature\Application\DTORequest\PostRequest;

/**
 * Class PostRequestFactory
 * @package App\DoctrineDataFeature\Application\DTORequestFactory
 */
class PostRequestFactory implements PostDataRequestFactoryInterface
{
    /**
     * @return PostDataRequestInterface
     */
    public function create(): PostDataRequestInterface
    {
        return new PostRequest();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTOResponse;

/**
 * Interface DataResponseInterface
 * Marker for DTO request objects
 * @package App\DoctrineDataFeature\Application\DTOResponse
 **/
interface DataResponseInterface
{

}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTOResponse;

use App\DataManagerFeatureApi\DTOResponse\CategoryDataResponseInterface;

/**
 * Class Category
 * Module response object. This object will be returned for other features usage.
 * @package App\DoctrineDataFeature\Application\DTOResponse
 **/
class CategoryResponse implements CategoryDataResponseInterface, DataResponseInterface
{
    private ?int $id = null;
    private ?string $title = null;
    private ?string $content = null;
    private ?string $slug = null;
    private bool $isActive = false;

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void
    {
        $this->id = $id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void
    {
        $this->content = $content;
    }

    /**
     * @return string
     */
    public function getSlug(): string
    {
        return $this->slug;
    }

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void
    {
        $this->slug = $slug;
    }

    /**
     * @return bool
     */
    public function isActive(): bool
    {
        return $this->isActive;
    }

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void
    {
        $this->isActive = $active;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTOResponse;

use App\DataManagerFeatureApi\DTOResponse\PostDataResponseInterface;
use DateTimeInterface;

/**
 * Class PostResponse
 * Module response object. This object will be returned for other features usage.
 * @package App\DoctrineDataFeature\Application\DTOResponse
 */
class PostResponse implements PostDataResponseInterface, DataResponseInterface
{
    private ?int $id = null;
    private ?string $title = null;
    private ?string $content = null;
    private ?string $slug = null;
    private bool $isPublished = false;
    private ?int $categoryId = null;
    private ?string $createdAt = null;
    private ?string $updatedAt = null;

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void
    {
        $this->id = $id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void
    {
        $this->content = $content;
    }

    /**
     * @return string
     */
    public function getSlug(): string
    {
        return $this->slug;
    }

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void
    {
        $this->slug = $slug;
    }

    /**
     * @return bool
     */
    public function isPublished(): bool
    {
        return $this->isPublished;
    }

    /**
     * @param bool $published
     */
    public function setPublished(bool $published): void
    {
        $this->isPublished = $published;
    }

    /**
     * @return string|null
     */
    public function getUpdatedAt(): ?string
    {
        return date("Y-m-d", $this->updatedAt);
    }

    /**
     * @param string|null $updatedAt
     * @return void
     */
    public function setUpdatedAt(string $updatedAt = null): void
    {
        $this->updatedAt = $updatedAt;
    }

    /**
     * @return string
     */
    public function getCreatedAt(): string
    {
        return date("Y-m-d", $this->createdAt);
    }

    /**
     * @param string|null $createdAt
     * @return void
     */
    public function setCreatedAt(string $createdAt = null): void
    {
        $this->createdAt = $createdAt;
    }

    /**
     * @param int|null $id
     * @return void
     */
    public function setCategoryId(int $id = null): void
    {
        $this->categoryId = $id;
    }

    /**
     * @return int|null
     */
    public function getCategoryId(): ?int
    {
        return $this->categoryId;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTOResponseFactory;

use App\DataManagerFeatureApi\DTOResponse\CategoryDataResponseInterface;

/**
 * Interface CategoryResponseFactoryInterface
 * @package App\DoctrineDataFeature\Application\DTOResponseFactory
 **/
interface CategoryResponseFactoryInterface
{
    /**
     * @return CategoryDataResponseInterface
     */
    public function create(): CategoryDataResponseInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTOResponseFactory;

use App\DataManagerFeatureApi\DTOResponse\CategoryDataResponseInterface;
use App\DoctrineDataFeature\Application\DTOResponse\CategoryResponse;

/**
 * Class CategoryResponseFactory
 * @package App\DoctrineDataFeature\Application\DTOResponseFactory
 **/
class CategoryResponseFactory implements CategoryResponseFactoryInterface
{
    /**
     * @return CategoryDataResponseInterface
     */
    public function create(): CategoryDataResponseInterface
    {
        return new CategoryResponse();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTOResponseFactory;

use App\DataManagerFeatureApi\DTOResponse\PostDataResponseInterface;

/**
 * Interface PostResponseFactoryInterface
 * @package App\DoctrineDataFeature\Application\DTOResponseFactory
 */
interface PostResponseFactoryInterface
{
    /**
     * @return PostDataResponseInterface
     */
    public function create(): PostDataResponseInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\DoctrineDataFeature\Application\DTOResponseFactory;

use App\DataManagerFeatureApi\DTOResponse\PostDataResponseInterface;
use App\DoctrineDataFeature\Application\DTOResponse\PostResponse;

/**
 * Class PostResponseFactory
 * @package App\DoctrineDataFeature\Application\DTOResponseFactory
 */
class PostResponseFactory implements PostResponseFactoryInterface
{
    /**
     * @return PostDataResponseInterface
     */
    public function create(): PostDataResponseInterface
    {
        return new PostResponse();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeatureApi\DTORequest;

/**
 * @api
 * Interface CategoryCreateRequestInterface
 * @package App\CategoryFeatureApi\DTORequest
 *
 * Request object for a category creation
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface CategoryCreateRequestInterface
{
    /**
     * @return string|null
     */
    public function getTitle(): ?string;

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void;

    /**
     * @return string|null
     */
    public function getContent(): ?string;

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void;

    /**
     * @return string|null
     */
    public function getSlug(): ?string;

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void;

    /**
     * @return bool
     */
    public function isActive(): bool;

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeatureApi\DTORequest;

/**
 * @api
 * Interface CategoryUpdateRequestInterface
 * @package App\CategoryFeatureApi\DTORequest
 *
 * Request object for a category updates
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface CategoryUpdateRequestInterface
{
    /**
     * @return int|null
     */
    public function getId(): ?int;

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void;

    /**
     * @return string|null
     */
    public function getTitle(): ?string;

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void;

    /**
     * @return string|null
     */
    public function getContent(): ?string;

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void;

    /**
     * @return string|null
     */
    public function getSlug(): ?string;

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void;

    /**
     * @return bool
     */
    public function isActive(): bool;

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeatureApi\DTORequestFactory;

use App\CategoryFeatureApi\DTORequest\CategoryCreateRequestInterface;

/**
 * @api
 * Interface CategoryCreateDTOFactoryInterface
 * @package App\CategoryFeatureApi\DTORequestFactory
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface CategoryCreateDTOFactoryInterface
{
    /**
     * @return CategoryCreateRequestInterface
     */
    public function create(): CategoryCreateRequestInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeatureApi\DTORequestFactory;

use App\CategoryFeatureApi\DTORequest\CategoryUpdateRequestInterface;

/**
 * @api
 * Interface CategoryUpdateDTOFactoryInterface
 * @package App\CategoryFeatureApi\DTORequestFactory
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface CategoryUpdateDTOFactoryInterface
{
    /**
     * @return CategoryUpdateRequestInterface
     */
    public function create(): CategoryUpdateRequestInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeatureApi\DTOResponse;

/**
 * @api
 * Interface CategoryDTOInterface
 * @package App\CategoryFeatureApi\DTOResponse
 *
 * Module response object. This object will be returned for other features usage.
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 **/
interface CategoryDTOInterface
{
    /**
     * @return int|null
     */
    public function getId(): ?int;

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void;

    /**
     * @return string|null
     */
    public function getTitle(): ?string;

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void;

    /**
     * @return string|null
     */
    public function getContent(): ?string;

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void;

    /**
     * @return string
     */
    public function getSlug(): string;

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void;

    /**
     * @return bool
     */
    public function isActive(): bool;

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeatureApi\Service;

use App\CategoryFeatureApi\DTORequest\CategoryUpdateRequestInterface as UpdateDTORequest;
use App\CategoryFeatureApi\DTORequest\CategoryCreateRequestInterface as CreateDTORequest;
use App\CategoryFeatureApi\DTOResponse\CategoryDTOInterface as ResponseDTO;

/**
 * @api
 * Interface CategoryServiceInterface
 * @package App\CategoryFeatureApi\Service
 *
 * Api service for categories management
 *
 * WARNING! API DOESN'T know anything about realization!
 * This interfaces provides public access for other features to a feature realization.
 */
interface CategoryServiceInterface
{
    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array;

    /**
     * @param int $categoryId
     * @return ResponseDTO|null
     */
    public function getById(int $categoryId): ?ResponseDTO;

    /**
     * @param string $slug
     * @return ResponseDTO|null
     */
    public function getBySlug(string $slug): ?ResponseDTO;

    /**
     * @return ResponseDTO
     */
    public function initNewCategory(): ResponseDTO;

    /**
     * @param CreateDTORequest $dtoRequest
     * @return ResponseDTO
     */
    public function create(CreateDTORequest $dtoRequest): ResponseDTO;

    /**
     * @param UpdateDTORequest $dtoRequest
     * @return ResponseDTO
     */
    public function update(UpdateDTORequest $dtoRequest): ResponseDTO;

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\Entity;

use App\CategoryFeature\Domain\ValueObject\ContentValue;
use App\CategoryFeature\Domain\ValueObject\IdValue;
use App\CategoryFeature\Domain\ValueObject\SlugValue;
use App\CategoryFeature\Domain\ValueObject\ActiveValue;
use App\CategoryFeature\Domain\ValueObject\TitleValue;

/**
 * Class Category
 * @package App\CategoryFeature\Domain\Entity
 *
 * Domain Entity doesn't connect to any DB or other storages.
 * Represents an element of business logic.
 * Domain entities must not be revealed outside
 *
 * Use immutable value objects here
 */
class Category
{
    private IdValue $id;
    private TitleValue $title;
    private ContentValue $content;
    private SlugValue $slug;
    private ActiveValue $isActive;

    /**
     * @return IdValue
     */
    public function getId(): IdValue
    {
        return $this->id;
    }

    /**
     * @param IdValue $id
     */
    public function setId(IdValue $id): void
    {
        $this->id = $id;
    }

    /**
     * @return TitleValue
     */
    public function getTitle(): TitleValue
    {
        return $this->title;
    }

    /**
     * @param TitleValue $title
     */
    public function setTitle(TitleValue $title): void
    {
        $this->title = $title;
    }

    /**
     * @return ContentValue
     */
    public function getContent(): ContentValue
    {
        return $this->content;
    }

    /**
     * @param ContentValue $content
     */
    public function setContent(ContentValue $content): void
    {
        $this->content = $content;
    }

    /**
     * @return SlugValue
     */
    public function getSlug(): SlugValue
    {
        return $this->slug;
    }

    /**
     * @param SlugValue $slug
     */
    public function setSlug(SlugValue $slug): void
    {
        $this->slug = $slug;
    }

    /**
     * @return ActiveValue
     */
    public function isActive(): ActiveValue
    {
        return $this->isActive;
    }

    /**
     * @param ActiveValue $active
     */
    public function setActive(ActiveValue $active): void
    {
        $this->isActive = $active;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\Factory;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\ValueObject\ContentValue;
use App\CategoryFeature\Domain\ValueObject\IdValue;
use App\CategoryFeature\Domain\ValueObject\SlugValue;
use App\CategoryFeature\Domain\ValueObject\ActiveValue;
use App\CategoryFeature\Domain\ValueObject\TitleValue;

/**
 * Class CategoryFactory
 * @package App\CategoryFeature\Domain\Factory
 */
class CategoryFactory
{
    /**
     * @param int|null $id
     * @param string|null $title
     * @param string|null $content
     * @param string|null $slug
     * @param bool $isActive
     * @return Category
     */
    public function create(
        int    $id = null,
        string $title = null,
        string $content = null,
        string $slug = null,
        bool   $isActive = false,
    ): Category
    {
        $category = new Category();

        $idValue = new IdValue($id);
        $category->setId($idValue);

        $titleValue = new TitleValue($title);
        $category->setTitle($titleValue);

        $contentValue = new ContentValue($content);
        $category->setContent($contentValue);

        $slugValue = new SlugValue($slug);
        $category->setSlug($slugValue);

        $statusValue = new ActiveValue($isActive);
        $category->setActive($statusValue);

        return $category;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\Repository;

use App\CategoryFeature\Domain\Entity\Category;

/**
 * Interface CategoryRepositoryInterface
 * @package App\CategoryFeature\Domain\Repository
 *
 * Domain layer NEVER implements repository. Domain doesn't know anything about data storages.
 * Domain uses behavior description, repository must be implemented in Infrastructure layer according to a source
 * (eg. DB, Session and so on)
 */
interface CategoryRepositoryInterface
{
    /**
     * @param Category $category
     * @return Category
     */
    public function save(Category $category): Category;

    /**
     * @param int $id
     */
    public function deleteById(int $id): void;

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array;

    /**
     * @param int $id
     * @return Category|null
     */
    public function getById(int $id): ?Category;

    /**
     * @param string $slug
     * @return Category|null
     */
    public function getBySlug(string $slug): ?Category;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\Interactor;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\Repository\CategoryRepositoryInterface;
use DomainException;

/**
 * Class CategoryDeleteInteractor
 * @package App\CategoryFeature\Domain\Interactor
 *
 * Interactor represents a union of use cases. 1 use case = 1 business logic action.
 * e.g. deleteById() method represents delete category by id use case.
 * Interactor holds use cases for the sake of decreasing complexity of the code and decreasing dependencies for classes
 * which will need several use cases.
 *
 * WARNING! Interactors must not be changed or inherited.
 * Business logic can't be changed by 3-d party modules and layers
 */
final class CategoryDeleteInteractor
{
    private CategoryRepositoryInterface $categoryRepository;

    /**
     * @param CategoryRepositoryInterface $categoryRepository
     */
    public function __construct(CategoryRepositoryInterface $categoryRepository)
    {
        $this->categoryRepository = $categoryRepository;
    }

    /**
     * @param int $id
     * @return void
     * @throws DomainException
     */
    public function deleteById(int $id): void
    {
        $category = $this->categoryRepository->getById($id);

        if (null == $category) {
            throw new DomainException(sprintf("Category with id %s does not exist", $id));
        }

        $this->categoryRepository->deleteById($id);
    }

    /**
     * @param Category $category
     * @return void
     * @throws DomainException
     */
    public function delete(Category $category): void
    {
        $categoryId = $category->getId()->getValue();

        if (null == $categoryId) {
            throw new DomainException("Can't remove category without Id");
        }

        $this->categoryRepository->deleteById($categoryId);
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\Interactor;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\Factory\CategoryFactory;
use App\CategoryFeature\Domain\Repository\CategoryRepositoryInterface;

/**
 * Class CategoryLoadInteractor
 * @package App\CategoryFeature\Domain\Interactor
 *
 * Interactor represents a union of use cases. 1 use case = 1 business logic action.
 * e.g. loadById() method represents load category by id use case.
 * Interactor holds use cases for the sake of decreasing complexity of the code and decreasing dependencies for classes
 * which will need several use cases.
 *
 * WARNING! Interactors must not be changed or inherited.
 * Business logic can't be changed by 3-d party modules and layers
 */
final class CategoryLoadInteractor
{
    private CategoryRepositoryInterface $categoryRepository;
    private CategoryFactory $categoryFactory;

    /**
     * @param CategoryRepositoryInterface $categoryRepository
     * @param CategoryFactory $categoryFactory
     */
    public function __construct(
        CategoryRepositoryInterface $categoryRepository,
        CategoryFactory $categoryFactory
    ) {
        $this->categoryRepository = $categoryRepository;
        $this->categoryFactory = $categoryFactory;
    }

    /**
     * @param array|null $criteria
     * @return array
     */
    public function loadAll(array $criteria = null): array
    {
        return $this->categoryRepository->getList($criteria);
    }

    /**
     * @param int $id
     * @return Category|null
     */
    public function loadById(int $id): ?Category
    {
        return $this->categoryRepository->getById($id);
    }

    /**
     * @return Category
     */
    public function loadEmptyCategory(): Category
    {
        return $this->categoryFactory->create();
    }

    /**
     * @param string $slug
     * @return Category|null
     */
    public function loadBySlug(string $slug): ?Category
    {
        return $this->categoryRepository->getBySlug($slug);
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\Interactor;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\Repository\CategoryRepositoryInterface;
use DomainException;

/**
 * Class CategorySaveInteractor
 * @package App\CategoryFeature\Domain\Interactor
 *
 * Interactor represents a union of use cases. 1 use case = 1 business logic action.
 * e.g. update() method represents update category use case.
 * Interactor holds use cases for the sake of decreasing complexity of the code and decreasing dependencies for classes
 * which will need several use cases.
 *
 * WARNING! Interactors must not be changed or inherited.
 * Business logic can't be changed by 3-d party modules and layers
 */
final class CategorySaveInteractor
{
    private CategoryRepositoryInterface $categoryRepository;

    /**
     * @param CategoryRepositoryInterface $categoryRepository
     */
    public function __construct(CategoryRepositoryInterface $categoryRepository)
    {
        $this->categoryRepository = $categoryRepository;
    }

    /**
     * @param Category $category
     * @return Category
     */
    public function update(Category $category): Category
    {
        if (!$category->getSlug()->getValue()) {
            throw new DomainException("Category must have a slug");
        }

        $categoryId = $category->getId()->getValue();
        $existedCategory = $this->categoryRepository->getById($categoryId);

        if (null == $existedCategory) {
            throw new DomainException(sprintf("Category with id %s does not exist", $categoryId));
        }

        return $this->categoryRepository->save($category);
    }

    /**
     * @param Category $category
     * @return Category
     */
    public function create(Category $category): Category
    {
        $slug = $category->getSlug()->getValue();

        if (!$slug) {
            throw new DomainException("Category must have a slug");
        }

        $existedCategory = $this->categoryRepository->getBySlug($slug);

        if (null != $existedCategory) {
            throw new DomainException(sprintf("Category slug '%s' already exists", $slug));
        }

        return $this->categoryRepository->save($category);
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\ValueObject;

/**
 * Interface ValueObjectInterface
 * @package App\CategoryFeature\Domain\ValueObject
 */
interface ValueObjectInterface
{
    /**
     * @return mixed
     */
    public function getValue();

    /**
     * @return string
     */
    public function __toString(): string;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\ValueObject;

/**
 * Class StatusValue
 * Warning: data value object must be immutable
 *
 * @package App\CategoryFeature\Domain\ValueObject
 */
class ActiveValue implements ValueObjectInterface
{
    private bool $status;

    /**
     * @param bool $status
     */
    public function __construct(bool $status)
    {
        $this->status = $status;
    }

    /**
     * @return bool
     */
    public function getValue(): bool
    {
        return $this->status;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return (string)$this->status;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\ValueObject;

/**
 * Class ContentValue
 * Warning: data value object must be immutable
 *
 * @package App\CategoryFeature\Domain\ValueObject
 */
class ContentValue implements ValueObjectInterface
{
    private ?string $content;

    /**
     * @param string|null $content
     */
    public function __construct(string $content = null)
    {
        $this->content = $content;
    }

    /**
     * @return string|null
     */
    public function getValue(): ?string
    {
        return $this->content;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return $this->content;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\ValueObject;

/**
 * Class IdValue
 * Warning: data value object must be immutable
 *
 * @package App\CategoryFeature\Domain\ValueObject
 */
class IdValue implements ValueObjectInterface
{
    private ?int $id;

    /**
     * @param int|null $id
     */
    public function __construct(int $id = null)
    {
        $this->id = $id;
    }

    /**
     * @return int|null
     */
    public function getValue(): ?int
    {
        return $this->id;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return (string)$this->id;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\ValueObject;

/**
 * Class SlugValue
 * Warning: data value object must be immutable
 *
 * @package App\CategoryFeature\Domain\ValueObject
 */
class SlugValue implements ValueObjectInterface
{
    private ?string $slug;

    /**
     * @param string|null $slug
     */
    public function __construct(string $slug = null)
    {
        $this->slug = $slug;
    }

    /**
     * @return string|null
     */
    public function getValue(): ?string
    {
        return $this->slug;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return $this->slug;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Domain\ValueObject;

/**
 * Class TitleValue
 * Warning: data value object must be immutable
 *
 * @package App\CategoryFeature\Domain\ValueObject
 */
class TitleValue implements ValueObjectInterface
{
    private ?string $title;

    /**
     * @param string|null $title
     */
    public function __construct(string $title = null)
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getValue(): ?string
    {
        return $this->title;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return $this->title;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Infrastructure\DataMapper;

use App\CategoryFeature\Domain\Entity\Category;
use App\DataManagerFeatureApi\DTOResponse\CategoryDataResponseInterface;

/**
 * Interface CategoryDomainMapperInterface
 * Map data response object to a domain object
 * @package App\CategoryFeature\Infrastructure\DataMapper
 **/
interface CategoryDomainMapperInterface
{
    /**
     * @param CategoryDataResponseInterface $dataResponse
     * @return Category
     */
    public function map(CategoryDataResponseInterface $dataResponse): Category;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Infrastructure\DataMapper;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\Factory\CategoryFactory as CategoryDomainFactory;
use App\DataManagerFeatureApi\DTOResponse\CategoryDataResponseInterface;

/**
 * Class CategoryDomainMapper
 * @package App\CategoryFeature\Infrastructure\DataMapper
 **/
class CategoryDomainMapper implements CategoryDomainMapperInterface
{
    private CategoryDomainFactory $categoryDomainFactory;

    /**
     * @param CategoryDomainFactory $categoryDomainFactory
     */
    public function __construct(CategoryDomainFactory $categoryDomainFactory)
    {
        $this->categoryDomainFactory = $categoryDomainFactory;
    }

    /**
     * Map data response object to a domain object
     * @param CategoryDataResponseInterface $dataResponse
     * @return Category
     */
    public function map(CategoryDataResponseInterface $dataResponse): Category
    {
        return $this->categoryDomainFactory->create(
            $dataResponse->getId(),
            $dataResponse->getTitle(),
            $dataResponse->getContent(),
            $dataResponse->getSlug(),
            $dataResponse->isActive()
        );
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Infrastructure\DataMapper;

use App\CategoryFeature\Domain\Entity\Category;
use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;

/**
 * Interface CategoryRequestMapperInterface
 * Map domain object to a data object for sending to DataManagerFeature
 * @package App\CategoryFeature\Infrastructure\DataMapper
 **/
interface CategoryRequestMapperInterface
{
    /**
     * @param Category $domainEntity
     * @return CategoryDataRequestInterface
     */
    public function map(Category $domainEntity): CategoryDataRequestInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Infrastructure\DataMapper;

use App\CategoryFeature\Domain\Entity\Category;
use App\DataManagerFeatureApi\DTORequest\CategoryDataRequestInterface;
use App\DataManagerFeatureApi\DTORequestFactory\CategoryDataRequestFactoryInterface;

/**
 * Class CategoryRequestMapper
 * @package App\CategoryFeature\Infrastructure\DataMapper
 **/
class CategoryRequestMapper implements CategoryRequestMapperInterface
{
    private CategoryDataRequestFactoryInterface $categoryDataRequestFactory;

    /**
     * @param CategoryDataRequestFactoryInterface $categoryDataRequestFactory
     */
    public function __construct(CategoryDataRequestFactoryInterface $categoryDataRequestFactory)
    {
        $this->categoryDataRequestFactory = $categoryDataRequestFactory;
    }

    /**
     * Map domain object to a data object for sending to DataManagerFeature
     * @param Category $domainEntity
     * @return CategoryDataRequestInterface
     */
    public function map(Category $domainEntity): CategoryDataRequestInterface
    {
        $requestModel = $this->categoryDataRequestFactory->create();

        $requestModel->setId($domainEntity->getId()->getValue());
        $requestModel->setTitle($domainEntity->getTitle()->getValue());
        $requestModel->setSlug($domainEntity->getSlug()->getValue());
        $requestModel->setContent($domainEntity->getContent()->getValue());
        $requestModel->setActive($domainEntity->isActive()->getValue());

        return $requestModel;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Infrastructure\Repository;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\Repository\CategoryRepositoryInterface;
use App\CategoryFeature\Infrastructure\DataMapper\CategoryRequestMapperInterface;
use App\CategoryFeature\Infrastructure\DataMapper\CategoryDomainMapperInterface;
use App\DataManagerFeatureApi\Service\CategoryDataServiceInterface;

/**
 * Class CategoryRepository
 *
 * We save data in another feature by doctrine.
 * For that we need to convert a Category Domain Entity to a Data Manager request object,
 * send that request object for saving to the Doctrine feature, get response object from the Doctrine Data Manager
 * and convert that object back to a Domain entity.
 *
 * This approach allows you not to be depended on a concrete data storage.
 * You can use Doctrine / Csv / Elastic if needed.
 * Just create a separate module for each realisation and implement DataManagerFeatureApi.
 * PS: don't forget to change interface realisation in construct.
 *
 * @package App\CategoryFeature\Infrastructure\Repository
 */
class CategoryRepository implements CategoryRepositoryInterface
{
    private CategoryDomainMapperInterface $categoryDomainMapper;
    private CategoryRequestMapperInterface $categoryRequestDataMapper;
    private CategoryDataServiceInterface $categoryDataService;

    /**
     * @param CategoryDomainMapperInterface $domainMapper
     * @param CategoryRequestMapperInterface $requestMapper
     * @param CategoryDataServiceInterface $categoryDataService
     */
    public function __construct(
        CategoryDomainMapperInterface  $domainMapper,
        CategoryRequestMapperInterface $requestMapper,
        CategoryDataServiceInterface   $categoryDataService
    ) {
        $this->categoryDomainMapper = $domainMapper;
        $this->categoryRequestDataMapper = $requestMapper;
        $this->categoryDataService = $categoryDataService;
    }

    /**
     * @param Category $category
     * @return Category
     */
    public function save(Category $category): Category
    {
        $requestDTO = $this->categoryRequestDataMapper->map($category);
        $responseDTO = $this->categoryDataService->save($requestDTO);

        return $this->categoryDomainMapper->map($responseDTO);
    }

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void
    {
        $this->categoryDataService->deleteById($id);
    }

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array
    {
        $result = $this->categoryDataService->getList($criteria);
        $list = [];

        foreach ($result as $item) {
            $list[] = $this->categoryDomainMapper->map($item);

        }

        return $list;
    }

    /**
     * @param int $id
     * @return Category|null
     */
    public function getById(int $id): ?Category
    {
        $responseDTO = $this->categoryDataService->getById($id);
        return $responseDTO ? $this->categoryDomainMapper->map($responseDTO) : null;
    }

    /**
     * @param string $slug
     * @return Category|null
     */
    public function getBySlug(string $slug): ?Category
    {
        $responseDTO = $this->categoryDataService->getBySlug($slug);
        return $responseDTO ? $this->categoryDomainMapper->map($responseDTO) : null;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\ApiService;

use App\CategoryFeature\Application\DTODomainMapper\CategoryMapperInterface as CategoryDomainMapper;
use App\CategoryFeature\Application\DTORequest\CategoryRequestDTOInterface;
use App\CategoryFeature\Application\DTORequestValidator\CategoryValidatorInterface;
use App\CategoryFeature\Application\DTOResponseMapper\CategoryMapperInterface as CategoryDTOResponseMapper;
use App\CategoryFeature\Application\Model\CategoryManagerInterface;
use App\CategoryFeatureApi\DTORequest\CategoryUpdateRequestInterface as UpdateRequest;
use App\CategoryFeatureApi\DTORequest\CategoryCreateRequestInterface as CreateRequest;
use App\CategoryFeatureApi\DTOResponse\CategoryDTOInterface as ResponseDTO;
use App\CategoryFeatureApi\Service\CategoryServiceInterface;
use Exception;

/**
 * Class CategoryService
 * @package App\CategoryFeature\Application\ApiService
 *
 * This class is for external usage (outside this feature) only
 * Use CategoryManagerInterface for data manipulating and return DTOResponse here
 *
 * Don't return Domain entity outside the feature!
 */
class CategoryService implements CategoryServiceInterface
{
    private CategoryDTOResponseMapper $categoryDtoResponseMapper;
    private CategoryDomainMapper $categoryDomainMapper;
    private CategoryManagerInterface $categoryManager;
    private CategoryValidatorInterface $categoryValidator;

    /**
     * @param CategoryDTOResponseMapper $categoryDtoResponseMapper
     * @param CategoryDomainMapper $categoryDomainMapper
     * @param CategoryManagerInterface $categoryManager
     * @param CategoryValidatorInterface $categoryValidator
     */
    public function __construct(
        CategoryDTOResponseMapper $categoryDtoResponseMapper,
        CategoryDomainMapper $categoryDomainMapper,
        CategoryManagerInterface $categoryManager,
        CategoryValidatorInterface $categoryValidator
    ) {
        $this->categoryDtoResponseMapper = $categoryDtoResponseMapper;
        $this->categoryDomainMapper = $categoryDomainMapper;
        $this->categoryManager = $categoryManager;
        $this->categoryValidator = $categoryValidator;
    }

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array
    {
        $list = [];
        $categories = $this->categoryManager->getList($criteria);

        foreach ($categories as $category) {
            $list[] = $this->categoryDtoResponseMapper->map($category);
        }

        return $list;
    }

    /**
     * @param int $categoryId
     * @return ResponseDTO|null
     */
    public function getById(int $categoryId): ?ResponseDTO
    {
        $category = $this->categoryManager->getById($categoryId);
        return $category ? $this->categoryDtoResponseMapper->map($category) : null;
    }

    /**
     * @param string $slug
     * @return ResponseDTO|null
     */
    public function getBySlug(string $slug): ?ResponseDTO
    {
        $category = $this->categoryManager->getBySlug($slug);
        return $category ? $this->categoryDtoResponseMapper->map($category) : null;
    }

    /**
     * @return ResponseDTO
     */
    public function initNewCategory(): ResponseDTO
    {
        $category = $this->categoryManager->initNewCategory();
        return $this->categoryDtoResponseMapper->map($category);
    }

    /**
     * @param CreateRequest $dtoRequest
     * @return ResponseDTO
     * @throws Exception
     */
    public function create(CreateRequest $dtoRequest): ResponseDTO
    {
        $this->validateRequest($dtoRequest);

        $domainEntity = $this->categoryDomainMapper->mapCreateRequest($dtoRequest);
        $createdCategory = $this->categoryManager->create($domainEntity);

        return $this->categoryDtoResponseMapper->map($createdCategory);
    }

    /**
     * @param UpdateRequest $dtoRequest
     * @return ResponseDTO
     * @throws Exception
     */
    public function update(UpdateRequest $dtoRequest): ResponseDTO
    {
        $this->validateRequest($dtoRequest);

        $domainEntity = $this->categoryDomainMapper->mapUpdateRequest($dtoRequest);
        $updatedCategory = $this->categoryManager->update($domainEntity);

        return $this->categoryDtoResponseMapper->map($updatedCategory);
    }

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void
    {
        $this->categoryManager->deleteById($id);
    }

    /**
     * @param CategoryRequestDTOInterface $requestDTO
     * @return void
     * @throws Exception
     */
    protected function validateRequest(CategoryRequestDTOInterface $requestDTO): void
    {
        $errors = $this->categoryValidator->validate($requestDTO);
        $message = "";

        foreach ($errors as $property => $errorMsgs) {
            $message .= "The $property is not valid. Message: " . implode("," , $errorMsgs) . " \n";
        }

        if ($message) {
            throw new Exception($message);
        }
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTODomainMapper;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeatureApi\DTORequest\CategoryCreateRequestInterface;
use App\CategoryFeatureApi\DTORequest\CategoryUpdateRequestInterface;

/**
 * Interface CategoryMapperInterface
 * Map DTO request to a Domain entity
 *
 * @package App\CategoryFeature\Application\DTODomainMapper
 **/
interface CategoryMapperInterface
{
    /**
     * @param CategoryUpdateRequestInterface $dtoRequest
     * @return Category
     */
    public function mapUpdateRequest(CategoryUpdateRequestInterface $dtoRequest): Category;

    /**
     * @param CategoryCreateRequestInterface $dtoRequest
     * @return Category
     */
    public function mapCreateRequest(CategoryCreateRequestInterface $dtoRequest): Category;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTODomainMapper;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\Factory\CategoryFactory as CategoryDomainFactory;
use App\CategoryFeatureApi\DTORequest\CategoryCreateRequestInterface;
use App\CategoryFeatureApi\DTORequest\CategoryUpdateRequestInterface;

/**
 * Class CategoryMapper
 * @package App\CategoryFeature\Application\DTODomainMapper
 **/
class CategoryMapper implements CategoryMapperInterface
{
    private CategoryDomainFactory $categoryDomainFactory;

    /**
     * @param CategoryDomainFactory $categoryDomainFactory
     */
    public function __construct(CategoryDomainFactory $categoryDomainFactory)
    {
        $this->categoryDomainFactory = $categoryDomainFactory;
    }

    /**
     * Map DTO request to a Domain entity
     * @param CategoryUpdateRequestInterface $dtoRequest
     * @return Category
     */
    public function mapUpdateRequest(CategoryUpdateRequestInterface $dtoRequest): Category
    {
        return $this->categoryDomainFactory->create(
            $dtoRequest->getId(),
            $dtoRequest->getTitle(),
            $dtoRequest->getContent(),
            $dtoRequest->getSlug(),
            $dtoRequest->isActive()
        );
    }

    /**
     * Map DTO request to a Domain entity
     * @param CategoryCreateRequestInterface $dtoRequest
     * @return Category
     */
    public function mapCreateRequest(CategoryCreateRequestInterface $dtoRequest): Category
    {
        return $this->categoryDomainFactory->create(
            null,
            $dtoRequest->getTitle(),
            $dtoRequest->getContent(),
            $dtoRequest->getSlug(),
            $dtoRequest->isActive()
        );
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTORequest;

/**
 * Interface CategoryRequestDTOInterface
 * @package App\CategoryFeature\Application\DTORequest
 * Marker for Category DTO Requests
 */
interface CategoryRequestDTOInterface
{

}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTORequest;

use App\CategoryFeatureApi\DTORequest\CategoryCreateRequestInterface;
use Symfony\Component\Validator\Constraints as Assert;

/**
 * Class CategoryCreate
 * Request object for a category creation
 *
 * @package App\CategoryFeature\Application\DTORequest
 */
class CategoryCreate implements CategoryCreateRequestInterface, CategoryRequestDTOInterface
{
    #[Assert\NotBlank]
    #[Assert\Type("string")]
    private ?string $title = null;

    #[Assert\Type("string")]
    private ?string $content = null;

    #[Assert\Type("string")]
    private ?string $slug = null;

    #[Assert\Type("bool")]
    private bool $isActive = false;

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void
    {
        $this->content = $content;
    }

    /**
     * @return string|null
     */
    public function getSlug(): ?string
    {
        return $this->slug;
    }

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void
    {
        $this->slug = $slug;
    }

    /**
     * @return bool
     */
    public function isActive(): bool
    {
        return $this->isActive;
    }

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void
    {
        $this->isActive = $active;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTORequest;

use App\CategoryFeatureApi\DTORequest\CategoryUpdateRequestInterface;
use Symfony\Component\Validator\Constraints as Assert;

/**
 * Class CategoryUpdate
 * Request object for a category updates
 * @package App\CategoryFeature\Application\DTORequest
 */
class CategoryUpdate implements CategoryUpdateRequestInterface, CategoryRequestDTOInterface
{
    #[Assert\NotBlank]
    #[Assert\Type("int")]
    private ?int $id = null;

    #[Assert\NotBlank]
    #[Assert\Type("string")]
    private ?string $title = null;

    #[Assert\Type("string")]
    private ?string $content = null;

    #[Assert\Type("string")]
    private ?string $slug = null;

    #[Assert\Type("bool")]
    private bool $isActive = false;

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void
    {
        $this->id = $id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void
    {
        $this->content = $content;
    }

    /**
     * @return string|null
     */
    public function getSlug(): ?string
    {
        return $this->slug;
    }

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void
    {
        $this->slug = $slug;
    }

    /**
     * @return bool
     */
    public function isActive(): bool
    {
        return $this->isActive;
    }

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void
    {
        $this->isActive = $active;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTORequestFactory;

use App\CategoryFeature\Application\DTORequest\CategoryCreate;
use App\CategoryFeatureApi\DTORequest\CategoryCreateRequestInterface;
use App\CategoryFeatureApi\DTORequestFactory\CategoryCreateDTOFactoryInterface;

/**
 * Class CategoryCreateFactory
 * @package App\CategoryFeature\Application\DTORequestFactory
 */
class CategoryCreateFactory implements CategoryCreateDTOFactoryInterface
{
    /**
     * @return CategoryCreateRequestInterface
     */
    public function create(): CategoryCreateRequestInterface
    {
        return new CategoryCreate();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTORequestFactory;

use App\CategoryFeature\Application\DTORequest\CategoryUpdate;
use App\CategoryFeatureApi\DTORequest\CategoryUpdateRequestInterface;
use App\CategoryFeatureApi\DTORequestFactory\CategoryUpdateDTOFactoryInterface;

/**
 * Class CategoryUpdateFactory
 * @package App\CategoryFeature\Application\DTORequestFactory
 */
class CategoryUpdateFactory implements CategoryUpdateDTOFactoryInterface
{
    /**
     * @return CategoryUpdateRequestInterface
     */
    public function create(): CategoryUpdateRequestInterface
    {
        return new CategoryUpdate();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTORequestValidator;

use App\CategoryFeature\Application\DTORequest\CategoryRequestDTOInterface;

/**
 * Interface CategoryValidatorInterface
 * Primary request validation (input). Other validation must be in interactors.
 * Interactors are responsible for business logic validation.
 *
 * @package App\CategoryFeature\Application\DTORequestValidator
 */
interface CategoryValidatorInterface
{
    /**
     * @param CategoryRequestDTOInterface $dto
     * @return array
     */
    public function validate(CategoryRequestDTOInterface $dto): array;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTORequestValidator;

use App\CategoryFeature\Application\DTORequest\CategoryRequestDTOInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

/**
 * Class CategoryValidator
 * @package App\CategoryFeature\Application\DTORequestValidator
 */
class CategoryValidator implements CategoryValidatorInterface
{
    private ValidatorInterface $validator;

    /**
     * @param ValidatorInterface $validator
     */
    public function __construct(ValidatorInterface $validator)
    {
        $this->validator = $validator;
    }

    /**
     * Primary request validation (input). Other validation must be in interactors.
     * Interactors are responsible for business logic validation.
     *
     * @param CategoryRequestDTOInterface $dto
     * @return array
     */
    public function validate(CategoryRequestDTOInterface $dto): array
    {
        $violations = [];
        $violationList = $this->validator->validate($dto);

        foreach ($violationList as $violation) {
            $violations[$violation->getPropertyPath()][] = $violation->getMessage();
        }

        return $violations;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTOResponse;

use App\CategoryFeatureApi\DTOResponse\CategoryDTOInterface;

/**
 * Class Category
 * Module response object. This object will be returned for other features usage.
 *
 * @package App\CategoryFeature\Application\DTOResponse;
 **/
class Category implements CategoryDTOInterface
{
    private ?int $id = null;
    private ?string $title = null;
    private ?string $content = null;
    private ?string $slug = null;
    private bool $isActive = false;

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @param int|null $id
     */
    public function setId(int $id = null): void
    {
        $this->id = $id;
    }

    /**
     * @return string|null
     */
    public function getTitle(): ?string
    {
        return $this->title;
    }

    /**
     * @param string|null $title
     */
    public function setTitle(string $title = null): void
    {
        $this->title = $title;
    }

    /**
     * @return string|null
     */
    public function getContent(): ?string
    {
        return $this->content;
    }

    /**
     * @param string|null $content
     */
    public function setContent(string $content = null): void
    {
        $this->content = $content;
    }

    /**
     * @return string
     */
    public function getSlug(): string
    {
        return $this->slug;
    }

    /**
     * @param string|null $slug
     */
    public function setSlug(string $slug = null): void
    {
        $this->slug = $slug;
    }

    /**
     * @return bool
     */
    public function isActive(): bool
    {
        return $this->isActive;
    }

    /**
     * @param bool $active
     */
    public function setActive(bool $active): void
    {
        $this->isActive = $active;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTOResponseFactory;

use App\CategoryFeatureApi\DTOResponse\CategoryDTOInterface;

/**
 * Interface CategoryFactoryInterface
 * @package App\CategoryFeatureApi\DTOResponseFactory
 **/
interface CategoryFactoryInterface
{
    /**
     * @return CategoryDTOInterface
     */
    public function create(): CategoryDTOInterface;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTOResponseFactory;

use App\CategoryFeature\Application\DTOResponse\Category;
use App\CategoryFeatureApi\DTOResponse\CategoryDTOInterface;

/**
 * Class CategoryFactory
 * @package App\CategoryFeature\Application\DTOResponseFactory
 **/
class CategoryFactory implements CategoryFactoryInterface
{
    /**
     * @return CategoryDTOInterface
     */
    public function create(): CategoryDTOInterface
    {
        return new Category();
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTOResponseMapper;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeatureApi\DTOResponse\CategoryDTOInterface as CategoryResponseDTO;

/**
 * Interface CategoryMapperInterface
 * Map domain entity to a Response DTO object.
 * Don't return domain entity outside the module.
 *
 * @package App\CategoryFeature\Application\DTOResponseMapper
 **/
interface CategoryMapperInterface
{
    /**
     * @param Category $category
     * @return CategoryResponseDTO
     */
    public function map(Category $category): CategoryResponseDTO;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\DTOResponseMapper;

use App\CategoryFeature\Application\DTOResponseFactory\CategoryFactoryInterface;
use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeatureApi\DTOResponse\CategoryDTOInterface as CategoryResponseDTO;

/**
 * Class CategoryMapper
 * @package App\CategoryFeature\Application\DTOResponseMapper
 **/
class CategoryMapper implements CategoryMapperInterface
{
    private CategoryFactoryInterface $categoryDTOResponseFactory;

    /**
     * @param CategoryFactoryInterface $categoryDTOResponseFactory
     */
    public function __construct(CategoryFactoryInterface $categoryDTOResponseFactory)
    {
        $this->categoryDTOResponseFactory = $categoryDTOResponseFactory;
    }

    /**
     * Map domain entity to a Response DTO object.
     * Don't return domain entity outside the module.
     *
     * @param Category $category
     * @return CategoryResponseDTO
     */
    public function map(Category $category): CategoryResponseDTO
    {
        $dtoResponse = $this->categoryDTOResponseFactory->create();

        $dtoResponse->setActive($category->isActive()->getValue());
        $dtoResponse->setId($category->getId()->getValue());
        $dtoResponse->setContent($category->getContent()->getValue());
        $dtoResponse->setSlug($category->getSlug()->getValue());
        $dtoResponse->setTitle($category->getTitle()->getValue());

        return $dtoResponse;
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\Model;

use App\CategoryFeature\Domain\Entity\Category;

/**
 * Interface CategoryManagerInterface
 * @package App\CategoryFeature\Application\Model
 **/
interface CategoryManagerInterface
{
    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array;

    /**
     * @param int $categoryId
     * @return Category|null
     */
    public function getById(int $categoryId): ?Category;

    /**
     * @param string $slug
     * @return Category|null
     */
    public function getBySlug(string $slug): ?Category;

    /**
     * @return Category
     */
    public function initNewCategory(): Category;

    /**
     * @param Category $category
     * @return Category
     */
    public function create(Category $category): Category;

    /**
     * @param Category $category
     * @return Category
     */
    public function update(Category $category): Category;

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void;
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\CategoryFeature\Application\Model;

use App\CategoryFeature\Domain\Entity\Category;
use App\CategoryFeature\Domain\Interactor\CategoryDeleteInteractor;
use App\CategoryFeature\Domain\Interactor\CategoryLoadInteractor;
use App\CategoryFeature\Domain\Interactor\CategorySaveInteractor;

/**
 * Class CategoryManager
 * @package App\CategoryFeature\Application\Model
 *
 * This class is for internal usage (inside this feature) only
 **/
class CategoryManager implements CategoryManagerInterface
{
    private CategorySaveInteractor $categorySaveInteractor;
    private CategoryDeleteInteractor $categoryDeleteInteractor;
    private CategoryLoadInteractor $categoryLoadInteractor;

    /**
     * @param CategorySaveInteractor $categorySaveInteractor
     * @param CategoryDeleteInteractor $categoryDeleteInteractor
     * @param CategoryLoadInteractor $categoryLoadInteractor
     */
    public function __construct(
        CategorySaveInteractor $categorySaveInteractor,
        CategoryDeleteInteractor $categoryDeleteInteractor,
        CategoryLoadInteractor $categoryLoadInteractor,
    ) {
        $this->categorySaveInteractor = $categorySaveInteractor;
        $this->categoryDeleteInteractor = $categoryDeleteInteractor;
        $this->categoryLoadInteractor = $categoryLoadInteractor;
    }

    /**
     * @param array|null $criteria
     * @return array
     */
    public function getList(array $criteria = null): array
    {
        return $this->categoryLoadInteractor->loadAll($criteria);
    }

    /**
     * @param int $categoryId
     * @return Category|null
     */
    public function getById(int $categoryId): ?Category
    {
        return $this->categoryLoadInteractor->loadById($categoryId);
    }

    /**
     * @param string $slug
     * @return Category|null
     */
    public function getBySlug(string $slug): ?Category
    {
        return $this->categoryLoadInteractor->loadBySlug($slug);
    }

    /**
     * @return Category
     */
    public function initNewCategory(): Category
    {
        return $this->categoryLoadInteractor->loadEmptyCategory();
    }

    /**
     * @param Category $category
     * @return Category
     */
    public function create(Category $category): Category
    {
        return $this->categorySaveInteractor->create($category);
    }

    /**
     * @param Category $category
     * @return Category
     */
    public function update(Category $category): Category
    {
        return $this->categorySaveInteractor->update($category);
    }

    /**
     * @param int $id
     * @return void
     */
    public function deleteById(int $id): void
    {
        $this->categoryDeleteInteractor->deleteById($id);
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\FrontFeature\Presentation\Controller\Category;

use App\CategoryFeatureApi\Service\CategoryServiceInterface;
use App\PostFeatureApi\Service\PostServiceInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

/**
 * Class ViewController
 * @package App\FrontFeature\Presentation\Controller\Category
 *
 * WARNING! Presentation layer can communicate ONLY with Application layer or shared API.
 * Presentation layer doesn't know anything about domain
 */
#[Route('/category', name: 'frontend_feature_category_')]
class ViewController extends AbstractController
{
    private CategoryServiceInterface $categoryService;
    private PostServiceInterface $postService;

    /**
     * @param PostServiceInterface $postService
     * @param CategoryServiceInterface $categoryService
     */
    public function __construct(
        PostServiceInterface $postService,
        CategoryServiceInterface $categoryService
    ) {
        $this->categoryService = $categoryService;
        $this->postService = $postService;
    }

    #[Route('/{slug}', name: 'view', methods: ["GET"])]
    public function __invoke(string $slug): Response
    {
        $category = $this->categoryService->getBySlug($slug);

        if (null === $category) {
            throw $this->createNotFoundException();
        }

        return $this->render('@frontend_feature_templates/baseTheme/layout/category/view.html.twig', [
            'category' => $category,
            'menuItems' => $this->categoryService->getList(["isActive" => true]),
            'seoTitle' => $category->getTitle(),
            'seoDescription' => $category->getTitle(),
            'postList' => $this->postService->getList(['category' => $category->getId(), 'isPublished' => true]),
        ]);
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\FrontFeature\Presentation\Controller\Home;

use App\CategoryFeatureApi\Service\CategoryServiceInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

/**
 * Class ViewController
 * @package App\FrontFeature\Presentation\Controller\Home
 *
 * WARNING! Presentation layer can communicate ONLY with Application layer or shared API.
 * Presentation layer doesn't know anything about domain
 */
class ViewController extends AbstractController
{
    private const PAGE_TITLE = "Symfony Blog: Learn Clean Architecture Together";
    private const PAGE_DESCRIPTION = "Learn Clean Architecture Together";

    private CategoryServiceInterface $categoryService;

    /**
     * @param CategoryServiceInterface $categoryService
     */
    public function __construct(CategoryServiceInterface $categoryService)
    {
        $this->categoryService = $categoryService;
    }

    #[Route('/', name: 'home', methods: ["GET"])]
    public function __invoke(): Response
    {
        $categoryList = $this->categoryService->getList(["isActive" => true]);

        return $this->render('@frontend_feature_templates/baseTheme/layout/home/view.html.twig', [
            'categoryList' => $categoryList,
            'seoTitle' => self::PAGE_TITLE,
            'seoDescription' => self::PAGE_DESCRIPTION,
            'menuItems' => $categoryList
        ]);
    }
}

<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the GNU General Public License v3 (GPL 3.0)
 * It is available through the world-wide-web at this URL:
 * https://www.gnu.org/licenses/gpl-3.0.en.html
 *
 * @license    https://www.gnu.org/licenses/gpl-3.0.en.html GNU General Public License v3 (GPL 3.0)
 */

declare(strict_types=1);

namespace App\FrontFeature\Presentation\Controller\Post;

use App\CategoryFeatureApi\Service\CategoryServiceInterface;
use App\PostFeatureApi\Service\PostServiceInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

/**
 * Class ViewController
 * @package App\FrontFeature\Presentation\Controller\Post
 *
 * WARNING! Presentation layer can communicate ONLY with Application layer or shared API.
 * Presentation layer doesn't know anything about domain
 */
#[Route('/post', name: 'frontend_feature_post_')]
class ViewController extends AbstractController
{
    private PostServiceInterface $postService;
    private CategoryServiceInterface $categoryService;

    /**
     * @param CategoryServiceInterface $categoryService
     * @param PostServiceInterface $postService
     */
    public function __construct(
        CategoryServiceInterface $categoryService,
        PostServiceInterface $postService
    ) {
        $this->postService = $postService;
        $this->categoryService = $categoryService;
    }

    #[Route('/{slug}', name: 'view', methods: ["GET"])]
    public function __invoke(string $slug): Response
    {
        $post = $this->postService->getBySlug($slug);

        if (null === $post) {
            throw $this->createNotFoundException();
        }

        return $this->render('@frontend_feature_templates/baseTheme/layout/post/view.html.twig', [
            'post' => $post,
            'menuItems' => $this->categoryService->getList(["isActive" => true]),
            'seoTitle' => $post->getTitle(),
            'seoDescription' => $post->getTitle(),
        ]);
    }
}

<p>This is blog footer</p>

<head>
    <meta charset="UTF-8">
    <title>
        {% block seoTitle %}{{ seoTitle }}{% endblock %}
    </title>
    <meta name="description" content="{% block seoDescription %}{{ seoDescription }}{% endblock %}">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">
    <link rel="icon"
          href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 128 128%22><text y=%221.2em%22 font-size=%2296%22>⚫️</text></svg>"
    >

    {% block stylesheets %}
        {{ encore_entry_link_tags('app') }}
    {% endblock %}

    {% block javascripts %}
        {{ encore_entry_script_tags('app') }}
    {% endblock %}
</head>

<style>
    .bd-placeholder-img {
        font-size: 1.125rem;
        text-anchor: middle;
        -webkit-user-select: none;
        -moz-user-select: none;
        user-select: none;
    }

    @media (min-width: 768px) {
        .bd-placeholder-img-lg {
            font-size: 3.5rem;
        }
    }

    .b-example-divider {
        height: 3rem;
        background-color: rgba(0, 0, 0, .1);
        border: solid rgba(0, 0, 0, .15);
        border-width: 1px 0;
        box-shadow: inset 0 .5em 1.5em rgba(0, 0, 0, .1), inset 0 .125em .5em rgba(0, 0, 0, .15);
    }

    .b-example-vr {
        flex-shrink: 0;
        width: 1.5rem;
        height: 100vh;
    }

    .bi {
        vertical-align: -.125em;
        fill: currentColor;
    }

    .nav-scroller {
        position: relative;
        z-index: 2;
        height: 2.75rem;
        overflow-y: hidden;
    }

    .nav-scroller .nav {
        display: flex;
        flex-wrap: nowrap;
        padding-bottom: 1rem;
        margin-top: -1px;
        overflow-x: auto;
        text-align: center;
        white-space: nowrap;
        -webkit-overflow-scrolling: touch;
    }

    /* stylelint-disable selector-list-comma-newline-after */

    .blog-header {
        border-bottom: 1px solid #e5e5e5;
    }

    .blog-header-logo {
        font-family: "Playfair Display", Georgia, "Times New Roman", serif/*rtl:Amiri, Georgia, "Times New Roman", serif*/;
        font-size: 2.25rem;
    }

    .blog-header-logo:hover {
        text-decoration: none;
    }

    h1, h2, h3, h4, h5, h6 {
        font-family: "Playfair Display", Georgia, "Times New Roman", serif/*rtl:Amiri, Georgia, "Times New Roman", serif*/;
    }

    .display-4 {
        font-size: 2.5rem;
    }
    @media (min-width: 768px) {
        .display-4 {
            font-size: 3rem;
        }
    }

    .flex-auto {
        flex: 0 0 auto;
    }

    .h-250 { height: 250px; }
    @media (min-width: 768px) {
        .h-md-250 { height: 250px; }
    }

    /* Pagination */
    .blog-pagination {
        margin-bottom: 4rem;
    }

    /*
     * Blog posts
     */
    .blog-post {
        margin-bottom: 4rem;
    }
    .blog-post-title {
        font-size: 2.5rem;
    }
    .blog-post-meta {
        margin-bottom: 1.25rem;
        color: #727272;
    }

    /*
     * Footer
     */
    .blog-footer {
        padding: 2.5rem 0;
        color: #727272;
        text-align: center;
        background-color: #f9f9f9;
        border-top: .05rem solid #e5e5e5;
    }
    .blog-footer p:last-child {
        margin-bottom: 0;
    }
</style>

<div class="row flex-nowrap justify-content-between align-items-center">
    <div class="col-12 text-center">
        <a class="blog-header-logo text-dark" href="/">Clean Architecture Blog</a>
    </div>
</div>

{% extends '@frontend_feature_templates/baseTheme/layout/base.html.twig' %}

{% block pageTitle %}
    {{category.title}}
{% endblock %}

{% block main %}
    <div class="row g-5">
        <div class="col-md-12">
            <article class="blog-post">
                {{ category.content }}
            </article>
        </div>
    </div>
    <div class="row mb-2">
        {% if postList %}
            {% for post in postList %}
                <div class="col-md-6">
                    <div class="row g-0 border rounded overflow-hidden flex-md-row mb-4 shadow-sm h-md-250 position-relative">
                        <div class="col p-4 d-flex flex-column position-static">
                            <h3 class="mb-0">{{ post.title }}</h3>
                            <a
                                    href="{{ path('frontend_feature_post_view', {slug: post.slug}) }}"
                                    class="stretched-link"
                            >
                                Continue reading
                            </a>
                        </div>
                    </div>
                </div>
            {% endfor %}
        {% else %}
            <p>No posts yet =(</p>
        {% endif %}
    </div>
{% endblock %}

{% extends '@frontend_feature_templates/baseTheme/layout/base.html.twig' %}

{% block pageTitle %}
    Welcome! Glad To See You Here!
{% endblock %}

{% block main %}
    <div class="row mb-2">
        {% for category in categoryList %}
            <div class="col-md-6">
                <div class="row g-0 border rounded overflow-hidden flex-md-row mb-4 shadow-sm h-md-250 position-relative">
                    <div class="col p-4 d-flex flex-column position-static">
                        <h3 class="mb-0">{{ category.title }}</h3>
                        <a
                                href="{{ path('frontend_feature_category_view', {slug: category.slug}) }}"
                                class="stretched-link"
                        >
                            Continue reading
                        </a>
                    </div>
                </div>
            </div>
        {% endfor %}
    </div>
{% endblock %}

{% extends '@frontend_feature_templates/baseTheme/layout/base.html.twig' %}

{% block pageTitle %}
    {{post.title}}
{% endblock %}

{% block main %}
    <div class="row g-5">
        <div class="col-md-8">
            <article class="blog-post">
                <p class="blog-post-meta">{{ post.updatedAt }}</p>
                {{ post.content }}
            </article>
        </div>
        <div class="col-md-4">
            <div class="position-sticky" style="top: 2rem;">
                <div class="p-4">
                    <h4 class="fst-italic">Categories</h4>
                    <ol class="list-unstyled mb-0">
                        {% for item in menuItems %}
                            <li>
                                <a
                                    class="p-2 link-secondary"
                                    href="{{ path('frontend_feature_category_view', {slug: item.slug}) }}"
                                >
                                    {{ item.title }}
                                </a>
                            </li>
                        {% endfor %}
                    </ol>
                </div>
            </div>
        </div>
    </div>
{% endblock %}

<!DOCTYPE html>
<html lang="en">
    {%
        include '@frontend_feature_templates/baseTheme/block/head.html.twig'
        with {
            'seoTitle': (seoTitle is defined) ? seoTitle : 'Default Title',
            'seoDescription': (seoDescription is defined) ? seoDescription : 'Default Description'
        }
    %}
    <body>
        {% block body %}
            <div class="container">
                <header class="{% block headerClass %}blog-header lh-1 py-3{% endblock %}">
                    {% block header %}
                        {% include '@frontend_feature_templates/baseTheme/block/header.html.twig' %}
                    {% endblock %}
                </header>

                <div class="{% block blockNavWrapperClass %}nav-scroller py-1 mb-2{% endblock %}">
                    {% block nav %}
                        <nav class="nav d-flex justify-content-between">
                            {% for item in menuItems %}
                                <a
                                    class="p-2 link-secondary"
                                    href="{{ path('frontend_feature_category_view', {slug: item.slug}) }}">
                                    {{ item.title }}
                                </a>
                            {% endfor %}
                        </nav>
                    {% endblock %}
                </div>
            </div>

            <main class="{% block blockMainWrapperClass %}container{% endblock %}">
                <div class="p-4 p-md-5 mb-4 rounded text-bg-dark">
                    <div class="col-md-12 px-0">
                        <h1 class=" fst-italic">{% block pageTitle %}{% endblock %}</h1>
                    </div>
                </div>
                {% block main %}{% endblock %}
            </main>

            <footer class="{% block blockFooterWrapperClass %}blog-footer{% endblock %}">
                {% block footer %}
                    {% include '@frontend_feature_templates/baseTheme/block/footer.html.twig' %}
                {% endblock %}
            </footer>
        {% endblock %}
    </body>
</html>