Création d'applications de domaine ciblées. Une approche Symfony (Sauvegarde de l'entité)

Introduction

Dans ce troisième article de cette série, nous allons créer une entité prête à être conservée dans la base de données à partir du DTO que nous avons créé dans le premier article de la série.

Transformer le UserInputDTO en une entité

Pour commencer avec cette section, supposons que nous utilisons une doctrine pour communiquer avec la base de données et que notre entité Utilisateur ressemble à ceci :

#[ORM\Entity(repositoryClass: UserRepository::class)]
class User
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 150)]
    private string $firstname;

    #[ORM\Column(length: 255)]
    private string $lastname;

    #[ORM\Column(length: 25)]
    private string $dob;

    #[ORM\Column]
    private \DateTimeImmutable $createdAt;

    #[ORM\Column]
    private string $token;

    // getters and setters
}

Les champs email, prénom, nom et dob seront renseignés avec les valeurs UserInputDTO et les champs createdAt et token seront remplis selon les règles suivantes :

• Le champ createdAt contiendra la date actuelle.
• Le champ jeton contiendra une chaîne de 50 caractères alphanumériques.

Comme nous avons décidé comment nous allons remplir les champs de l'entité, cette partie du code appartiendra au domaine puisqu'elle contient les règles métier du domaine. Nous avons donc besoin d'un domaine de service pour faire tout cela. Codons-le.

class UserEntityBuilder {

    public function buildEntity(UserInputDTO $userInputDto): User
    {
        $user = new User();
        $user->setEmail($userInputDto->email);
        $user->setFirstname($userInputDto->firstname);
        $user->setLastname($userInputDto->lastname);
        $user->setDob($userInputDto->dob);
        $user->setToken(bin2hex(random_bytes(50)));
        $user->setCreatedAt(new \DateTimeImmutable());

        return $user;
    }
}

Comme vous pouvez le constater, la méthode UserEntityBuilder buildEntity crée l'entité User en suivant les règles pré-établies et renvoie l'entité.

Un service applicatif pour créer et sauvegarder l'entité

Maintenant, nous avons besoin d'un service qui se chargera de coordonner les processus impliqués dans le sauvetage de l'entité :

• Création de l'entité User à l'aide de notre service de domaine UserEntityBuilder récemment créé.
• Utilisation du service doctrine EntityManager pour conserver l'entité dans la base de données. Le service EntityManager doit être considéré comme un service d'infrastructure puisqu'il est fourni par le framework Symfony à travers son composant symfony/orm-pack.

Codons-le.

class UserCreator {

    public function __construct(
        private readonly UserEntityBuilder $userEntityBuilder,
        private readonly EntityManagerInterface $em,
    ){}

    public function createUser(UserInputDTO $userInputDto): object
    {
        $user = $this->userEntityBuilder->buildEntity($userInputDto);
        $this->em->persist($user);
        $this->em->flush();

        return '.....'; // Return a DTO ready to be used by the presentation layer
    }
}

Comme vous pouvez le voir dans le code ci-dessus, le service de couche d'application UserCreator utilise d'abord le UserEntityBuilder pour créer l'entité, puis utilise le gestionnaire d'entités Doctrine pour l'enregistrer dans la base de données. .

Vous avez peut-être remarqué que la ligne "retour" n'est pas complète. ¿ Que devrions-nous retourner ici?. Nous le verrons dans le prochain et dernier article de cette série :)

Qu'en est-il des entités. Appartiennent-ils au domaine ?

C'est une bonne question. À mon avis, ils appartiendraient à notre domaine puisque, bien qu'ils représentent un mappage de tables de base de données avec des objets de notre application, ils encapsulent nos décisions concernant le modèle de données du projet.
Or, le fait qu'ils puissent appartenir à notre domaine ne signifie pas qu'ils peuvent être utilisés comme DTO. Ils doivent être isolés et utilisés uniquement pour enregistrer des données dans la base de données et en recevoir des données.

Conclusion

Dans ce troisième article, nous avons créé un service de domaine pour créer une entité utilisateur prête à être conservée dans la base de données et avons également créé un service d'application qui enregistre l'entité dans la base de données en utilisant le service de domaine pour créer l'utilisateur et le gestionnaire d'entité de doctrine pour le sauvegarder.
Dans le prochain et dernier article, nous apprendrons à chaud à créer un DTO de sortie avec les informations utilisateur enregistrées prêtes à être renvoyées à la couche de présentation.

Si vous aimez mon contenu, aimez le lire et souhaitez en savoir plus sur PHP, vous pouvez lire mon ebook sur la façon de créer une API orientée opérations à l'aide de PHP et du Framework Symfony. Vous pouvez le trouver ici : Construire une API orientée opérations à l'aide de PHP et du framework Symfony : un guide étape par étape

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!