De CRUD à DDD pas à pas

De CRUD à DDD pas à pas
@SelrahcD

Charles Desneuf
Développeur indépendant
@SelrahcD
c.desneuf@gmail.com
4 Architecture
4 Modélisation
4 Tests
4 Agilité

Context
Application de santé qui propose des jeux à des centres
de soins ou des entreprises
pour favoriser une activité physique.
@SelrahcD

Context
Une entreprise qui grandit et recrute.
4 Automatiser les tâches d'administration
chronophages
4 Faciliter la compréhension de son métier par ses
nouveaux arrivants
4 Pouvoir adapter son système rapidement
@SelrahcD

Le backend est développé au dessus d'EasyAdmin 2
@SelrahcD

Player:
class: AppDomainEntityPlayer
controller: AppAdminControllerPlayerController
disabled_actions: [delete,new,show]
templates:
edit: 'admin/player/edit.html.twig'
list:
title: 'player.list.title'
sort: createdAt
actions:
- { name: contact, title: 'player.action.contact'}
fields:
- { property: id, label: UID }
- { property: lastname, label: 'player.label.lastname' }
- { property: firstname, label: 'player.label.firstname' }
edit:
// ...
@SelrahcD

class Player {
/**
* @ORMColumn(type="string")
*/
private $firstname;
public function getFirstname(): string {
return $this->firstname;
}
public function setFirstname(string $firstname): void {
$this->firstname = $firstname;
}
}
@SelrahcD

Préparer le terrain
@SelrahcD

De nouveaux concepts
4 Registration
4 Assessment
4 Intervention
@SelrahcD

Annotations
/**
* @AssertNotNull()
*/
private $startDate;
/**
* @AssertExpression(expression="value > this.getStartDate()")
*/
private $endDate;
@SelrahcD

Event handlers doctrine
public function postUpdate(LifecycleEventArgs $event): void
{
if (!self::supportsLifecycleEvent($event)) {
return;
}
/** @var Game $game */
$game = $event->getEntity();
$changeSet = $event->getEntityManager()->getUnitOfWork()->getEntityChangeSet($game);
$changedAttributes = array_keys($changeSet);
$listenedAttributeChanges = ['interventionDuration', 'endDate'];
if (!empty(array_intersect($listenedAttributeChanges, $changedAttributes))) {
// Do something
}
}
@SelrahcD

Player2Game
VS
4 Registration
4 Assessment
4 Intervention
@SelrahcD

Player2Game:
class: AppAdminDomainPlayer2Game
controller: AppAdminControllerPlayer2GameController
disabled_actions: [new,edit,delete,show]
list:
sort: createdAt
actions:
- { name: restartIntervention, title: 'p2g.action.restart-intervention'}
- { name: stats, title: 'p2g.action.stats' }
fields:
- { property: game.name, label: 'p2g.label.program' }
- { property: player.firstname, label: 'p2g.label.firstname' }
- { property: player.lastname, label: 'p2g.label.lastname' }
- { property: isValidated, label: 'p2g.label.is-validated', type: boolean }
- { property: hasRunningAssessment, label: 'p2g.label.has-running-assessment', type: boolean }
- { property: startDate, label: 'p2g.label.intervention-start-date', type: date }
- { property: endDate, label: 'p2g.label.intervention-end-date', type: date }
@SelrahcD

Poser des tests
qui vont survivre au refactoring
@SelrahcD

Tests fonctionnels Symfony
4 De l'UI
4 Jusqu'à la DB
@SelrahcD

Tests fonctionnels Symfony
4 Charger une page
4 Effectuer une action
4 Aller vérifier que le résultat de l'action a eu lieu via
l'UI
@SelrahcD

Approval testing
4 Passer des paramètres au système
4 Stocker le résultat
4 S'assurer que le résultat reste toujours le même
@SelrahcD

class Player2GameManager
{
public function startIntervention(Player2Game $player2Game): Player2Game
{
$now = new DateTimeImmutable();
$startDate = $now;
$game = $player2Game->getGame();
if($game->getStartDate() > $now) {
$startDate = $game->getStartDate();
}
$endDate = $game->getEndDate();
if($game->duration() !== null) {
$endDate = $startDate->modify(sprintf('+ %d weeks', $game->duration()));
}
$player2Game->setStartDate($startDate);
$player2Game->setEndDate($endDate);
return $player2Game;
}
}
@SelrahcD

class StartInterventionTest extends TestCase {
private function print(Player2Game $player2Game): string
{
return "Start date: {$player2Game->getStartDate()->format(DATE_ISO8601)}"
. PHP_EOL
. "End date: {$player2Game->getEndDate()->format(DATE_ISO8601)}";
}
}
@SelrahcD

public function test_startIntervention(): void
{
$manager = new Player2GameManager();
$game = new Game(
new DateTimeImmutable(),
new DateTimeImmutable()
);
$player2Game = new Player2Game($game, new Player());
$player2GameResult = $manager->startIntervention($player2Game);
Approvals::verifyString($this->print($player2GameResult));
}
@SelrahcD

{
$manager = new Player2GameManager();
$game = new Game(
new DateTimeImmutable('2017-12-18 22:14:17'),
new DateTimeImmutable('2019-10-09 06:06:16')
);
}
@SelrahcD

class Player2GameManager
{
{
$now = $this->getNow();
// ...
}
protected function getNow(): DateTimeImmutable
{
return new DateTimeImmutable();
}
}
Extract method
@SelrahcD

class TestablePlayer2GameManager extends Player2GameManager {
public ?DateTimeImmutable $now = null;
protected function getNow(): DateTimeImmutable
{
if($this->now !== null) {
return $this->now;
}
return parent::getNow();
}
}
Override factory method
@SelrahcD

{
$manager = new TestablePlayer2GameManager();
$manager->now = new DateTimeImmutable('2017-12-22 02:34:18');
$game = new Game(
);
}
@SelrahcD

public function test_startIntervention_start_date_after_now(): void
{
$game = new Game(
);
}
@SelrahcD

public function test_startIntervention_start_date_after_now(): void
{
$duration = 2;
$game = new Game(
$duration
);
}
@SelrahcD

$exec = function($startDate, $endDate, $now, $duration) {
$manager->now = new DateTimeImmutable($now);
$game = new Game(
new DateTimeImmutable($startDate),
new DateTimeImmutable($endDate),
$duration);
return $this->print($player2GameResult);
};
@SelrahcD

public function test_startIntervention_combinations(): void {
$exec = //...
$startDates = ['2017-12-18 22:14:17', ...];
$endDates = ['2019-10-09 06:06:16', ...];
$nows = ['2017-12-15 02:34:18', ...];
$durations = [null, 0, 2, 10];
CombinationApprovals::verifyAllCombinations4(
$exec,
$startDates,
$endDates,
$nows,
$durations
);
}
@SelrahcD

[2017-12-18 22:14:17, 2019-10-09 06:06:16, 2017-12-15 02:34:18, ] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2019-10-09T06:06:16+00:00
[2017-12-18 22:14:17, 2019-10-09 06:06:16, 2017-12-15 02:34:18, 0] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2017-12-18T22:14:17+00:00
[2017-12-18 22:14:17, 2019-10-09 06:06:16, 2017-12-15 02:34:18, 2] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2018-01-01T22:14:17+00:00
[2017-12-18 22:14:17, 2019-10-09 06:06:16, 2017-12-15 02:34:18, 10] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2018-02-26T22:14:17+00:00
[2017-12-18 22:14:17, 2022-08-16 08:56:18, 2017-12-15 02:34:18, ] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2022-08-16T08:56:18+00:00
[2017-12-18 22:14:17, 2022-08-16 08:56:18, 2017-12-15 02:34:18, 0] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2017-12-18T22:14:17+00:00
[2017-12-18 22:14:17, 2022-08-16 08:56:18, 2017-12-15 02:34:18, 2] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2018-01-01T22:14:17+00:00
[2017-12-18 22:14:17, 2022-08-16 08:56:18, 2017-12-15 02:34:18, 10] =>
Start date: 2017-12-18T22:14:17+00:00
End date: 2018-02-26T22:14:17+00:00
[2017-12-10 13:30:15, 2019-10-09 06:06:16, 2017-12-15 02:34:18, ] =>
Start date: 2017-12-15T02:34:18+00:00
End date: 2019-10-09T06:06:16+00:00
[2017-12-10 13:30:15, 2019-10-09 06:06:16, 2017-12-15 02:34:18, 0] =>
Start date: 2017-12-15T02:34:18+00:00
End date: 2017-12-15T02:34:18+00:00
[2017-12-10 13:30:15, 2019-10-09 06:06:16, 2017-12-15 02:34:18, 2] =>
Start date: 2017-12-15T02:34:18+00:00
End date: 2017-12-29T02:34:18+00:00
...
@SelrahcD

class Player2GameManager {
{
$now = $this->getNow();
$startDate = $now;
$game = $player2Game->getGame();
if($game->getStartDate() > $now) {
$startDate = $game->getStartDate();
}
$endDate = $game->getEndDate();
if($game->duration() !== null) {
$endDate = $startDate->modify(sprintf('+ %d weeks', $game->duration()));
}
$player2Game->setStartDate($startDate);
$player2Game->setEndDate($endDate);
return $player2Game;
}
}
@SelrahcD

class Player2Game {
public function startIntervention(DateTimeImmutable $now): Player2Game
{
$startDate = $now;
if($this->game->getStartDate() > $now) {
$startDate = $this->game->getStartDate();
}
$endDate = $this->game->getEndDate();
if($this->game->duration() !== null) {
$endDate = $startDate->modify(sprintf('+ %d weeks', $this->game->duration()));
}
$this->startDate = $startDate;
$this->endDate = $endDate;
return $this;
}
}
@SelrahcD

{
return $player2Game->startIntervention($this->getNow());
}
}
@SelrahcD

final class InterventionDates
{
public readonly DateTimeImmutable $startDate;
public readonly DateTimeImmutable $endDate;
public function __construct(
DateTimeImmutable $startDate,
DateTimeImmutable $endDate)
{
if($startDate > $endDate) {
throw new Exception('Start date must be before end date');
}
$this->startDate = $startDate;
$this->endDate = $endDate;
}
}
@SelrahcD

class Game {
public function computeInterventionDates(DateTimeImmutable $now): InterventionDates
{
$startDate = $this->startDate > $now ?
$this->startDate : $now;
$endDate = $this->duration === null ?
$this->endDate : $startDate->modify(sprintf('+ %d weeks', $this->duration));
return new InterventionDates($startDate, $endDate);
}
}
@SelrahcD

class Player2Game {
public function startIntervention(DateTimeImmutable $now): Player2Game
{
$interventionDates = $this->game->computeInterventionDates($now);
$this->startDate = $interventionDates->startDate;
$this->endDate = $interventionDates->endDate;
return $this;
}
}
@SelrahcD

After a while...
Photo by Jon Tyson on Unsplash
@SelrahcD

class Player2Game {
public function startIntervention(DateTimeImmutable $now): Player2Game {}
public function startInitialAssessment(): Player2Game {}
public function restartOn(DateTimeImmutable $restartDate): void {}
public function validate(): void {}
public function accept(): self {}
}
@SelrahcD

Utilisation des interfaces
interface Registration {
public function accept(): self;
public function startIntervention(): Intervention;
public function startInitialAssessment(): Assessment;
}
interface Intervention {
public function restartOn(DateTimeImmutable $restartDate): void;
}
interface Assessment {
public function validate(): void;
}
class Player2Game implements Registration, Assessment, Intervention {}
@SelrahcD

public function startIntervention(Registration $registration): Intervention
{
return $registration->startIntervention($this->getClock());
}
}
@SelrahcD

Modification de la base de données
@SelrahcD

Player2Game
Pouvoir afficher des informations sur la relation entre
un joueur et un jeu venant de plusieurs entitées.
@SelrahcD

Fonctionnement actuel
@SelrahcD

Tentative 1 : 3 entitées d'écriture, une table, 1 entitée de
lecture
@SelrahcD

Tentative 2 : 3 tables, 3 entités d'écriture, 1 entitée de
lecture
@SelrahcD

Tentative 3 : 3 tables, 3 entités d'écriture, 1 entitée de
lecture et 1 vue
@SelrahcD

Création d'une vue MySQL
CREATE VIEW view_player_2_game AS
SELECT
r.id,
r.player_id,
r.game_id,
r.is_validated,
CASE WHEN a.id IS NULL THEN 0
ELSE 1 END AS has_running_assessment,
i.start_date,
i.end_date
FROM registration r
LEFT JOIN assessement a ON a.player_id = r.player_id AND a.game_id = r.game_id AND a.validation_date IS NULL
LEFT JOIN intervention i ON i.player_id = r.player_id AND i.game_id = r.game_id
@SelrahcD

Création d'un entité Doctrine
/**
* @ORMEntity(readOnly=true)
* @ORMTable (name="view_player_2_game")
*/
class Player2Game {
/**
* @ORMId
* @ORMColumn(type="guid")
*/
public $id;
/**
* @ORMManyToOne(targetEntity="AppDomainEntityPlayer")
*/
public $player;
/**
* @ORMColumn(type="datetime_immutable")
*/
public $validationDate;
}
@SelrahcD

Utilisation d'entités uniquement pour
la vue
/**
* @ORMEntity(readOnly=true)
* @ORMTable (name="view_player_2_game")
*/
class Player2Game {
/**
* @ORMId
* @ORMColumn(type="guid")
*/
public $id;
/**
* @ORMManyToOne(targetEntity="AppUIViewModelPlayer")
*/
public $player;
/**
* @ORMColumn(type="datetime_immutable")
*/
public $validationDate;
}
@SelrahcD

Faites le à plusieurs !
Photo by Helena Lopes on Unsplash
@SelrahcD

Générale
4 Design patterns for modernizing legacy code bases -
Matthias Noback
@SelrahcD

Rollup
4 Why & How to use Doctrine Migrations Rollup? -
Olivier Dolbeau
4 Rolling up database migrations with Doctrine -
Andreas Möller
@SelrahcD

Doctrine et vues
4 Aggregate your data by using SQL views and
Doctrine. - Robbert Stevens
4 Separating Concerns using Embeddables - Doctrine
documentation
@SelrahcD

Approval testing
4 approvals/approval-tests
4 Approval testing - Emily Bach
4 Live-Refactoring de Legacy Code avec la technique
du Golden Master - Philippe Bourgau
@SelrahcD

De CRUD à DDD pas à pas

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to De CRUD à DDD pas à pas

Similar to De CRUD à DDD pas à pas (20)

More from Charles Desneuf

More from Charles Desneuf (6)

Recently uploaded

Recently uploaded (20)

De CRUD à DDD pas à pas