Drupal 8 Desacoplar la lógica de negocio del framework

Manel López / @mloptor #DrupalcampSpain2015
Desacoplar la lógica de negocio del
framework

Manel López Torrent
Ingeniero en informática
Web Developer
@mloptor
malotor@gmail.com

Desacoplada
=
Independiente

“El dominio es el mundo del
negocio”
Ideas, conocimiento y datos del
problema que intentamos resolver.
Expertos del dominio
Dominio

Objeto del negocio
Objetos o entidades abstractas
que conforman el dominio.

UniversidadPeriódico
Profesor
Alumno Asignatura
Departament
o
Editor
Periodista
Noticia
Anuncio

Reglas de negocio

Modelo del dominio
Nuestra solución al problema
Conocimiento estructurado del
problema
Código, prosa o un diagrama.
Refleja el conocimiento que tenemos
del dominio

Lógica de negocio / Capa de negocio
“La parte de nuestro software que
mantiene el modelo del dominio y
codifica las reglas de negocio”

Aplicaciones web y Frameworks

¿Dónde se
implementa la
lógica de
negocio?

ControladorPetición
Modelo
Vista
Persistencia
de datos
Respuesta
Presentación
de los datos

ControladorPetición
Modelo
Vista
Persistencia
de datos
Respuesta
Lógica de
negocio
Presentación
de los datos

Problemas
Alto nivel de dependencia
Difícil testeo
No SRP
HTTP
Tamaño

Hi! I'm your
controller

Controlador
Lógica de
negocio
?

Arquitectura hexagonal

Arquitectura hexagonal
Arquitectura de software
Alistair CockBurn
AKA “Ports and adapters”
Separar responsabilidades

Domain
Model
Lógica
de
negocio

Application Layer
Domain
Model
API

Application Layer
Domain
Model
Puerto
Puerto
Puerto
Puerto

Application Layer
Domain
Model
Infrastructure Layer Adaptador

Lógica de
negocio
Framework

Puertos/Adaptadores

interface log {
public function message($message);
public function error($message);
}
class LogService implements log {
public function __construct($factory) {
$this->loggerFactory = $factory;
}
public function message($message) {
$this->loggerFactory->get('my_module')->error($message);
}
public function error($message) {
$this->loggerFactory->get('my_module')->error($message);
}
}
Adaptador
Puerto

Application Layer
Domain
Model

Fronteras

Application Layer
Domain
Model
Infrastructure Layer

Ventajas

Agnóstica

Fácil Testeo

Aislada
Cambios aislados
+ refactoring
_ deuda técnica

Patrones de diseño

Entidad
Representan a los objetos del dominio
Estado + Comportamiento
Contener lógica del negocio
Modelo Anémico
Identidad

Adaptador
Adaptadores
Puertos

Factorías
stdClass new Product()

Repositorios
RepositorioCliente
DataProvider
Factoría
1 - Query
2 - Query 3 - Object Data
4 - Object Data
5 - Real Object6 - Real Object

Fachada

Esto no es el
Santo Grial

Escalabilidad
Mantenibilidad
fiabilidad
Complejidad

CRUD
Mínima lógica
Complejidad Oculta
Escenarios Inciertos
Requisitos cambiantes
Desconocimiento del Dominio

SHOW ME
THE
CODE!!!

Shopping Cart
1. CLIENTE Quiero ver un listado de productos para elegir lo que quiero
comprar
2. CLIENTE Quiero ser capaz de elegir el producto que quiero comprar y
añadirlo a mi cesta de la compra
a. Si un producto está ya en la cesta incrementaremos la cantidad
3. CLIENTE Quiero ser capaz de eliminar productos de mi cesta si he
cambiado de opinión
4. CLIENTE Quero poder ver el coste total de todos los productos de mi
cesta en todo momento.
5. CLIENTE Quiero que se guarde mi cesta de la compra por si quiero
pensarlo mejor

Repositorios de código
Shopping Cart Business Logic
https://github.com/malotor/basket
Shopping Cart Drupal 8 module
https://github.com/malotor/drupal_ecommerce

Modelo del dominio
Diseño emergente

Tests unitarios Tests integración

Modelo del dominio

Basket Products
contains
*

src
├── Application
│ ├── Factory
│ │ ├── BasketFactory.php
│ │ └── ProductFactory.php
│ ├── Repository
│ │ ├── BasketRepository.php
│ │ └── ProductRepository.php
│ └── Service
│ └── ShoppingCartService.php
└── Domain
└── Entity
├── Basket.php
├── Item.php
└── Product.php
Capa Aplicación
Capa Dominio

Capa Domino - Entidades

/src/Domain/Entity/Product.php
class Product implements Item
{
private $id;
private $quantity;
private $price;
public function __construct($id, $price, $quantity = 1) {}
public function getId() {}
public function getQuantity() {}
public function getAmount() {}
public function increaseQuantity() {}
}

/src/Domain/Entity/Product.php
class Product implements Item
{
private $id;
private $quantity;
private $price;
public function __construct($id, $price, $quantity = 1) {}
public function getId() {}
public function getQuantity() {}
public function getAmount() {}
public function increaseQuantity() {}
}
Estado
Comportamiento

/src/Domain/Entity/Basket.php
class Basket
{
private $items = [];
public function countItems() {}
public function addItem(Item $item) {}
public function getItem($itemId) {}
public function removeItem($itemId){}
public function getItems(){}
public function totalAmount(){}
}

/src/Domain/Entity/Basket.php
class Basket
{
public function addItem(Item $item)
{
$itemId = $item->getId();
if ($this->containsItem($itemId))
$this->items[$itemId]->increaseQuantity();
else
$this->items[$itemId] = $item;
}
}
“Si un producto ya existe en el carro
incrementaremos su cantidad”

Capa Dominio - Test de integración

/tests/Integration/Basket.php
class BasketTest extends PHPUnit_Framework_TestCase {
protected $basket;
public function setUp() {
$this->products[0] = new Product(1,10);
$this->products[1] = new Product(2,5.5);
$this->basket = new Basket();
}
public function testAddAProduct() {
$this->assertEquals(0, $this->basket->countItems());
$this->basket->addItem($this->products[0]);
}
}

public function testRemoveAProduct() {
$this->basket->removeItem(1);
}
public function testIncreaseProductQuantity() {
$this->assertEquals(1, $this->products[0]->getQuantity());
$this->assertEquals(2, $this->products[0]->getQuantity());
}
}

public function testCartTotalAmount() {
$this->assertEquals(25.5, $this->basket->totalAmount());
}
}

Capa Aplicación - Servicios

/src/Application/Service/ShoppingCartService.php
use malotorshoppingcartApplicationRepositoryProductRepository;
use malotorshoppingcartApplicationRepositoryBasketRepository;
class ShoppingCartService
{
private $productRepository;
private $basketRepository;
public function __construct(
ProductRepository $productRepository,
BasketRepository $basketRepository
)
{...}
}

{
)
{...}
}
Puertos

{
)
{...}
}
Interfaces

{
{...}
public function addProductToBasket($productId, $baskedId)
{...}
public function removeProductFromBasket($productId, $basketId)
{...}
public function getProductsFromBasket($basketId) {...}
public function getBasketTotalAmount($basketId) {...}
}
API para Infraestructura

{
{
$basket = $this->basketRepository->get($baskedId);
$product = $this->productRepository->get($productId);
$basket->addItem($product);
$this->basketRepository->save($basket);
}
{...}
}

{
{
}
{...}
}
Recupera datos al los repositorios

{
{
}
{...}
}
Ejecutará la lógica de negocio

{
{
}
{...}
}
Persiste los datos

{
{
}
{...}
}
Patrón Fachada

{
public function removeProductFromBasket($productId, $basketId)
{
$basket = $this->basketRepository->get($basketId);
$basket->removeItem($productId);
}
public function getProductsFromBasket($basketId)
{
return $basket->getItems();
}
public function getBasketTotalAmount($basketId)
{
return $basket->totalAmount();
}
}

Capa Aplicación - Repositorios (Puertos)

/src/Application/Repository/BasketRepository.php
namespace malotorshoppingcartApplicationRepository;
use malotorshoppingcartDomainEntityBasket;
interface BasketRepository
{
/**
* @return Basket
*/
public function get($basketId);
public function save(Basket $basket);
}

/src/Application/Repository/ProductRepository.php
namespace malotorshoppingcartApplicationRepository;
use malotorshoppingcartDomainEntityProduct;
interface ProductRepository
{
/**
* @return Product
*/
public function get($productId);
}

Capa Aplicación - Factorías

/src/Application/Factory/Product.php
class ProductFactory
{
static public function create($object) {
return new Product(
$object->id,
$object->price,
$object->quantity
);
}
}

/src/Application/Factory/Product.php
class ProductFactory
{
static public function create($object) {
return new Product(
$object->id,
$object->price,
$object->quantity
);
}
}
stdClass new Product()

/src/Application/Factory/Basket.php
use malotorshoppingcartDomainEntityBasket;
class BasketFactory
{
static public function create($products = array()) {
$basket = new Basket();
foreach ($products as $object) {
$basket->addItem(
ProductFactory::create($object) );
}
return $basket;
}
}

Empaquetar y distribuir

/composer.json
{
"name": "malotor/shoppingcart",
"description": "Shopping Cart",
"version" : "2.0.0-dev",
"require-dev": {
"phpunit/phpunit": "~4.4",
"phpspec/phpspec": "~2.0"
},
"authors": [
{
"name": "Manel López",
"email": "malotor@gmail.com"
}
],
"require": {
"php": ">=5.4.0"
},
"autoload": {
"psr-4": {
"malotorshoppingcart": "src"
}
}
}
https://packagist.org/

Infraestructura

Módulo Drupal 8
$ drupal generate:module

Cargar la lógica

/modules/ecommerce/composer.json
{
"name": "malotor/drupal8_shoppingcart",
"description": "Example module",
"type": "drupal-module",
"repositories": [
{
"type": "vcs",
"url": "https://github.com/malotor/basket.git"
}
],
"require": {
"malotor/shoppingcart": "dev-master"
}
}

Cargamos las dependencias ( composer_manager)
$ drush dl composer_manager
$ drush en -y composer_manager
$ drush composer-manager-init
$ cd core
$ composer drupal-update

Rutas

/ecommerce.routing.yml
ecommerce.addtocart:
path: '/ecommerce/addtocart/{productId}'
defaults:
_controller: 'DrupalecommerceControllerEcommerceController::addToCart'
_title: 'Add to cart'
requirements:
_permission: 'access content'
ecommerce.removefromcart:
path: '/ecommerce/removefromcart/{productId}'
defaults:
_controller: 'DrupalecommerceControllerEcommerceController::removeFromCart'
_title: 'Remove from cart'
requirements:
ecommerce.showcart:
path: '/ecommerce/shoppingcart'
defaults:
_controller: 'DrupalecommerceControllerEcommerceController::showCart'
_title: 'Shopping Cart'
requirements:

/ecommerce.routing.yml
ecommerce.addtocart:
path: '/ecommerce/addtocart/{productId}'
defaults:
_controller: 'DrupalecommerceControllerEcommerceController::addToCart'
_title: 'Add to cart'
requirements:
ecommerce.removefromcart:
path: '/ecommerce/removefromcart/{productId}'
defaults:
_controller: 'DrupalecommerceControllerEcommerceController::removeFromCart'
_title: 'Remove from cart'
requirements:
ecommerce.showcart:
path: '/ecommerce/shoppingcart'
defaults:
_controller: 'DrupalecommerceControllerEcommerceController::showCart'
_title: 'Shopping Cart'
requirements:
Añadir al carro
Eliminar del carro
Mostrar el carro

Adaptadores

#Ecommerce application layer
ecommerce.manager:
class: malotorshoppingcartApplicationServiceShoppingCartService
arguments: ['@ecommerce.product_repository','@ecommerce.basket_repository']
/modules/ecommerce/ecommerce.services.yml

ecommerce.manager:
Servicio de la capa de aplicación

ecommerce.manager:
Inyectar Adaptadores

ecommerce.manager:
#Repositories
ecommerce.product_repository:
class: DrupalecommerceAdaptersProductRepository
arguments: ['@ecommerce.coupon_repository']
ecommerce.basket_repository:
class: DrupalecommerceAdaptersBasketRepository
arguments: ['@ecommerce.coupon_repository','@ecommerce.linecart_provider']

ecommerce.manager:
#Repositories
Repositorio Cupones

ecommerce.manager:
#Repositories
Lineas de carro

Product
Repository
Product
Entity
Product Adapter
Coupon
Repository
ID Coupon
ID Coupon Node Coupon

use malotorshoppingcartApplicationRepositoryProductRepository as
ProductRepositoryInterface;
use malotorshoppingcartApplicationFactoryProductFactory;
class ProductRepository implements ProductRepositoryInterface {
private $couponRepository;
const ENTITY_NAME = "node";
public function __construct($couponRepository) {
$this->couponRepository = $couponRepository;
}
public function get($id) {
$coupon = $this->couponRepository->load($id);
$object = new stdClass();
$object->id = $coupon->id();
$object->price = $coupon->field_price->value;
return ProductFactory::create($object);
}
}
/modules/ecommerce/src/Adapters/ProductRepository.php

BasketRepository
Basket
Repository
Basket
Entity
Coupon
Repository
ID Basket
LineCart
Provider
DataBase
ID User
Session
Line Carts

Línea de carro
( basket_id , coupon_id , quantity )

Línea de carro
( user_id , coupon_id , quantity )

/modules/ecommerce/src/Adapters/BasketRepository.php
class BasketRepository implements BasketRepositoryInterface {
public function __construct($couponRepository, $lineCartDataProvider) {
$this->dataProvider = $lineCartDataProvider;
}
public function get($baskedId) {
$cartLines = $this->dataProvider->getAll();
$products = array();
foreach ($cartLines as $row) {
$coupon = $this->couponRepository->load($row->item_id);
$object->id = $row->item_id;
$object->quantity = $row->quantity;
$products[] = $object;
}
return BasketFactory::create($products);
}

}
}
}
Lineas de carro

}
}
}
Cupón

Controlador

class EcommerceController extends ControllerBase {
public function __construct($shoppingCart, $router, $printer) {
$this->shoppingCart = $shoppingCart;
$this->router = $router;
$this->printer = $printer;
}
public static function create(ContainerInterface $container) {
return new static(
$container->get('ecommerce.shoppingcart),
$container->get('ecommerce.router'),
$container->get('ecommerce.printer')
);
}
/* … */
}
/modules/ecommerce/src/Controller/EcommerceController.php
Servicio de la capa de aplicación

public function __construct($shoppingCart, $router, $printer) {
$this->shoppingCart = $shoppingCart;
$this->router = $router;
$this->printer = $printer;
}
public static function create(ContainerInterface $container) {
return new static(
$container->get('ecommerce.shoppingcart),
$container->get('ecommerce.router'),
$container->get('ecommerce.printer')
);
}
/* … */
}
Servicios Auxiliares

public function addToCart($productId) {
try {
$this->shoppingCart->addProductToBasket($productId, null);
return $this->router->redirectToPreviosPage("Product added");
} catch (Exception $e) {
return $this->router->redirectWithError($e->getMessage());
}
}
}

public function removeFromCart($productId) {
try {
$this->shoppingCart->removeProductFromBasket($productId, null);
return $this->router->redirectToPreviosPage("Product removed");
}
}
}

public function showCart() {
try {
$this->printer->setDisplay('full');
return $this->printer->render();
}
}
}

ecommerce.printer:
class: DrupalecommerceServicesPrinterService
arguments: ['@ecommerce.shoppingcart']

Bloque “Shopping Cart”

/modules/ecommerce/src/Plugin/Block/ShoppingCartBlock.php
/**
* Provides a shooping cart block.
* @Block(
* id = "shoppingcartblock",
* subject = @Translation("Shopping Cart block"),
* admin_label = @Translation("Shopping Cart block")
* )
*/
class ShoppingCartBlock extends BlockBase {
public function build() {
$printer = Drupal::service('ecommerce.printer');
$printer->setDisplay('short');
return $printer->render();
}
}

Demo

#project_wishlist
Mantenible
Escalable
Fiable

“There are no
dumb
questions”

Referencias
Hexagonal architecture - Alistair Cockburn
http://alistair.cockburn.us/Hexagonal+architecture
Desdrupalizando la lógica de negocio - Carles Climent
https://vimeo.com/112570854
The Clean Architecture - Robert C. Martin
http://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-architecture.html
What is Hexagonal architecture - Philip Brown
http://culttt.com/2014/12/31/hexagonal-architecture/

Referencias
Hexagonal Architecture - Chris Fidao
http://userscape.com/laracon/2014/chrisfidao.html
http://fideloper.com/hexagonal-architecture
Hexagonal Architecture - Carlos Buenosvinos
http://www.slideshare.net/carlosbuenosvinos/hexagonal-architecture-php-
barcelona

Gracias!
… para Noa López Llombart

Drupal 8 Desacoplar la lógica de negocio del framework

More Related Content

Featured (20)

Drupal 8 Desacoplar la lógica de negocio del framework

Editor's Notes