Refactoring services #885

common/logic/BaseService.php

     public function getHierarchy(): array
     {
         return [
-            FactoryInterface::class,
             SolverInterface::class,
             RepositoryInterface::class,
             BuilderInterface::class,
             FactoryInterface, SolverInterface ou BuilderInterface au service.');
     }
 
-    public function isFactory(): bool
-    {
-        return $this->classImplementsInterface(FactoryInterface::class);
-    }
-
     public function isSolver(): bool
     {
         return $this->classImplementsInterface(SolverInterface::class);

common/logic/Config/TaxRate/TaxRateFactory.php → common/logic/Config/TaxRate/TaxRateBuilder.php

 namespace common\logic\Config\TaxRate;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class TaxRateFactory extends BaseService implements FactoryInterface
+class TaxRateBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): TaxRate
+    public function instanciate(): TaxRate
     {
         $taxRate = new TaxRate();
 

common/logic/Config/TaxRate/TaxRateContainer.php

     public function getServices(): array
     {
         return [
-            TaxRateFactory::class,
+            TaxRateBuilder::class,
             TaxRateRepository::class,
         ];
     }
 
-    public function getFactory(): TaxRateFactory
+    public function getBuilder(): TaxRateBuilder
     {
-        return new TaxRateFactory();
+        return new TaxRateBuilder();
     }
 
     public function getRepository(): TaxRateRepository

common/logic/Distribution/ProductDistribution/ProductDistributionBuilder.php

 namespace common\logic\Distribution\ProductDistribution;
 
 use common\logic\BaseService;
+use common\logic\BuilderInterface;
 use common\logic\Distribution\Distribution\Distribution;
 use common\logic\Distribution\Distribution\DistributionSolver;
-use common\logic\FactoryInterface;
 use common\logic\Product\Product\Product;
 
-class ProductDistributionBuilder extends BaseService implements FactoryInterface
+class ProductDistributionBuilder extends BaseService implements BuilderInterface
 {
     protected ProductDistributionRepository $productDistributionRepository;
     protected DistributionSolver $distributionSolver;

common/logic/Document/DeliveryNote/DeliveryNoteFactory.php → common/logic/Document/DeliveryNote/DeliveryNoteBuilder.php

 namespace common\logic\Document\DeliveryNote;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class DeliveryNoteFactory extends BaseService implements FactoryInterface
+class DeliveryNoteBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): DeliveryNote
+    public function instanciate(): DeliveryNote
     {
         $deliveryNote = new DeliveryNote();
 

common/logic/Document/DeliveryNote/DeliveryNoteRepository.php

+<?php
+
+namespace common\logic\PointSale\PointSale;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class DeliveryNoteRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/Document/Invoice/InvoiceBuilder.php

+<?php
+
+namespace common\logic\Document\Invoice;
+
+use common\logic\BaseService;
+use common\logic\BuilderInterface;
+use common\logic\Document\Document\DocumentBuilder;
+
+class InvoiceBuilder extends DocumentBuilder implements BuilderInterface
+{
+    public function instanciate(): Invoice
+    {
+        $invoice = new Invoice();
+
+        return $invoice;
+    }
+}

common/logic/Document/Invoice/InvoiceContainer.php

 use common\logic\ContainerInterface;
 use common\logic\Document\Document\DocumentBuilder;
 use common\logic\Document\Document\DocumentSolver;
+use common\logic\PointSale\PointSale\InvoiceRepository;
 
 class InvoiceContainer implements ContainerInterface
 {
     public function getServices(): array
     {
         return [
-            InvoiceFactory::class,
+            DocumentSolver::class,
+            InvoiceBuilder::class,
         ];
     }
 
-    public function getFactory(): InvoiceFactory
+    public function getSolver(): DocumentSolver
     {
-        return new InvoiceFactory();
+        return new DocumentSolver();
     }
 
-    public function getSolver(): DocumentSolver
+    public function getRepository(): InvoiceRepository
     {
-        return new DocumentSolver();
+        return new InvoiceRepository();
     }
 
-    public function getBuilder(): DocumentBuilder
+    public function getBuilder(): InvoiceBuilder
     {
-        return new DocumentBuilder();
+        return new InvoiceBuilder();
     }
 }

common/logic/Document/Invoice/InvoiceFactory.php

-<?php
-
-namespace common\logic\Document\Invoice;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class InvoiceFactory extends BaseService implements FactoryInterface
-{
-    public function create(): Invoice
-    {
-        $invoice = new Invoice();
-
-        return $invoice;
-    }
-}

common/logic/Document/Invoice/InvoiceRepository.php

+<?php
+
+namespace common\logic\PointSale\PointSale;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class InvoiceRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/Document/Quotation/QuotationFactory.php → common/logic/Document/Quotation/QuotationBuilder.php

 namespace common\logic\Document\Quotation;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class QuotationFactory extends BaseService implements FactoryInterface
+class QuotationBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): Quotation
+    public function instanciate(): Quotation
     {
         $quotation = new Quotation();
 

common/logic/Document/Quotation/QuotationContainer.php

 use common\logic\ContainerInterface;
 use common\logic\Document\Document\DocumentBuilder;
 use common\logic\Document\Document\DocumentSolver;
+use common\logic\Document\Quotation\QuotationBuilder;
 use common\logic\Document\Quotation\QuotationFactory;
 use common\logic\Document\Quotation\Quotation;
+use common\logic\PointSale\PointSale\QuotationRepository;
 
 class QuotationContainer implements ContainerInterface
 {
     public function getServices(): array
     {
         return [
-            QuotationFactory::class,
+            QuotationBuilder::class,
         ];
     }
 
-    public function getFactory(): QuotationFactory
-    {
-        return new QuotationFactory();
-    }
-
     public function getSolver(): DocumentSolver
     {
         return new DocumentSolver();
     }
+    
+    public function getRepository(): QuotationRepository
+    {
+        return new QuotationRepository();
+    }
 
-    public function getBuilder(): DocumentBuilder
+    public function getBuilder(): QuotationBuilder
     {
-        return new DocumentBuilder();
+        return new QuotationBuilder();
     }
 }

common/logic/Document/Quotation/QuotationRepository.php

+<?php
+
+namespace common\logic\PointSale\PointSale;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class QuotationRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/FactoryInterface.php

-<?php
-
-namespace common\logic;
-
-interface FactoryInterface
-{
-
-}

common/logic/Order/Order/OrderBuilder.php

 
 class OrderBuilder extends BaseService implements BuilderInterface
 {
-    
+    public function instanciate(): Order
+    {
+        $order = new Order();
+
+        return $order;
+    }
 }

common/logic/Order/Order/OrderContainer.php

     public function getServices(): array
     {
         return [
-            OrderFactory::class,
             OrderSolver::class,
             OrderRepository::class,
             OrderBuilder::class,
         ];
     }
 
-    public function getFactory(): OrderFactory
-    {
-        return new OrderFactory();
-    }
-
     public function getSolver(): OrderSolver
     {
         return new OrderSolver();

common/logic/Order/Order/OrderFactory.php

-<?php
-
-namespace common\logic\Order\Order;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class OrderFactory extends BaseService implements FactoryInterface
-{
-    public function create(): Order
-    {
-        $order = new Order();
-
-        return $order;
-    }
-}

common/logic/Order/OrderStatusHistory/OrderStatusHistoryFactory.php → common/logic/Order/OrderStatusHistory/OrderStatusHistoryBuilder.php

 namespace common\logic\Order\OrderStatusHistory;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class OrderStatusHistoryFactory extends BaseService implements FactoryInterface
+class OrderStatusHistoryBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): OrderStatusHistory
+    public function instanciate(): OrderStatusHistory
     {
         $orderStatusHistory = new OrderStatusHistory();
 

common/logic/Order/OrderStatusHistory/OrderStatusHistoryContainer.php

 namespace common\logic\Order\OrderStatusHistory;
 
 use common\logic\ContainerInterface;
+use common\logic\PointSale\PointSale\OrderStatusHistoryRepository;
 
 class OrderStatusHistoryContainer implements ContainerInterface
 {
     public function getServices(): array
     {
         return [
-            OrderStatusHistoryFactory::class
+            OrderStatusHistoryRepository::class,
+            OrderStatusHistoryBuilder::class
         ];
     }
 
-    public function getFactory(): OrderStatusHistoryFactory
+    public function getRepository(): OrderStatusHistoryRepository
     {
-        return new OrderStatusHistoryFactory();
+        return new OrderStatusHistoryRepository();
+    }
+
+    public function getBuilder(): OrderStatusHistoryBuilder
+    {
+        return new OrderStatusHistoryBuilder();
     }
 }

common/logic/Order/OrderStatusHistory/OrderStatusHistoryRepository.php

+<?php
+
+namespace common\logic\PointSale\PointSale;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class OrderStatusHistoryRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/Order/ProductOrder/ProductOrderFactory.php → common/logic/Order/ProductOrder/ProductOrderBuilder.php

 namespace common\logic\Order\ProductOrder;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class ProductOrderFactory extends BaseService implements FactoryInterface
+class ProductOrderBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): ProductOrder
+    public function instanciate(): ProductOrder
     {
         $productOrder = new ProductOrder();
 

common/logic/Order/ProductOrder/ProductOrderContainer.php

 namespace common\logic\Order\ProductOrder;
 
 use common\logic\ContainerInterface;
+use common\logic\PointSale\PointSale\ProductOrderRepository;
 
 class ProductOrderContainer implements ContainerInterface
 {
     public function getServices(): array
     {
         return [
-            ProductOrderFactory::class,
             ProductOrderSolver::class,
+            ProductOrderRepository::class,
+            ProductOrderBuilder::class,
         ];
     }
 
-    public function getFactory(): ProductOrderFactory
+    public function getSolver(): ProductOrderSolver
     {
-        return new ProductOrderFactory();
+        return new ProductOrderSolver();
     }
 
-    public function getSolver(): ProductOrderSolver
+    public function getRepository(): ProductOrderRepository
     {
-        return new ProductOrderSolver();
+        return new ProductOrderRepository();
+    }
+
+    public function getBuilder(): ProductOrderBuilder
+    {
+        return new ProductOrderBuilder();
     }
 }

common/logic/Order/ProductOrder/ProductOrderRepository.php

+<?php
+
+namespace common\logic\PointSale\PointSale;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class ProductOrderRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/PointSale/PointSale/PointSaleBuilder.php

 
 class PointSaleBuilder extends BaseService implements BuilderInterface
 {
-    
+    public function instanciate(): PointSale
+    {
+        $pointSale = new PointSale();
+
+        return $pointSale;
+    }
 }

common/logic/PointSale/PointSale/PointSaleContainer.php

     public function getServices(): array
     {
         return [
-            PointSaleFactory::class,
             PointSaleSolver::class,
             PointSaleRepository::class,
             PointSaleBuilder::class,
         ];
     }
 
-    public function getFactory(): PointSaleFactory
-    {
-        return new PointSaleFactory();
-    }
-
     public function getSolver(): PointSaleSolver
     {
         return new PointSaleSolver();

common/logic/PointSale/PointSale/PointSaleFactory.php

-<?php
-
-namespace common\logic\PointSale\PointSale;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class PointSaleFactory extends BaseService implements FactoryInterface
-{
-    public function create(): PointSale
-    {
-        $pointSale = new PointSale();
-
-        return $pointSale;
-    }
-}

common/logic/PointSale/UserPointSale/UserPointSaleFactory.php → common/logic/PointSale/UserPointSale/UserPointSaleBuilder.php

 namespace common\logic\PointSale\UserPointSale;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class UserPointSaleFactory extends BaseService implements FactoryInterface
+class UserPointSaleBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): UserPointSale
+    public function instanciate(): UserPointSale
     {
         $userPointSale = new UserPointSale();
 

common/logic/PointSale/UserPointSale/UserPointSaleContainer.php

 namespace common\logic\PointSale\UserPointSale;
 
 use common\logic\ContainerInterface;
+use common\logic\PointSale\PointSale\UserPointSaleRepository;
 
 class UserPointSaleContainer implements ContainerInterface
 {
     public function getServices(): array
     {
         return [
-            UserPointSaleFactory::class,
+            UserPointSaleRepository::class,
+            UserPointSaleBuilder::class,
         ];
     }
 
-    public function getFactory(): UserPointSaleFactory
+    public function getRepository(): UserPointSaleRepository
     {
-        return new UserPointSaleFactory();
+        return new UserPointSaleRepository();
+    }
+
+    public function getBuilder(): UserPointSaleBuilder
+    {
+        return new UserPointSaleBuilder();
     }
 }

common/logic/PointSale/UserPointSale/UserPointSaleRepository.php

+<?php
+
+namespace common\logic\PointSale\PointSale;
+
+use common\logic\BaseService;
+use common\logic\BuilderInterface;
+use common\logic\RepositoryInterface;
+
+class UserPointSaleRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/Producer/Producer/ProducerBuilder.php

         $this->producerSolver = $this->loadService(ProducerSolver::class);
     }
 
+    public function instanciate(): Producer
+    {
+        $producer = new Producer();
+
+        $producer->order_deadline = Producer::ORDER_DEADLINE_DEFAULT;
+        $producer->order_delay = Producer::ORDER_DELAY_DEFAULT;
+
+        return $producer;
+    }
+
     public function init(Producer $producer): void
     {
         $this->initSlug($producer);

common/logic/Producer/Producer/ProducerContainer.php

     public function getServices(): array
     {
         return [
-            ProducerFactory::class,
             ProducerSolver::class,
             ProducerRepository::class,
             ProducerBuilder::class,
         ];
     }
 
-    public function getFactory(): ProducerFactory
-    {
-        return new ProducerFactory();
-    }
-
     public function getSolver(): ProducerSolver
     {
         return new ProducerSolver();

common/logic/Producer/Producer/ProducerFactory.php

-<?php
-
-namespace common\logic\Producer\Producer;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class ProducerFactory extends BaseService implements FactoryInterface
-{
-    public function create()
-    {
-        $producer = new Producer();
-
-        $producer->order_deadline = Producer::ORDER_DEADLINE_DEFAULT;
-        $producer->order_delay = Producer::ORDER_DELAY_DEFAULT;
-
-        return $producer;
-    }
-}

common/logic/Product/Product/ProductBuilder.php

 
 class ProductBuilder extends BaseService implements BuilderInterface
 {
-    
+    public function instanciate(): Product
+    {
+        $product = new Product();
+
+        return $product;
+    }
 }

common/logic/Product/Product/ProductContainer.php

     public function getServices(): array
     {
         return [
-            ProductFactory::class,
             ProductSolver::class,
-            ProductRepository::class,
             ProductBuilder::class,
+            ProductRepository::class,
         ];
     }
 
-    public function getFactory(): ProductFactory
-    {
-        return new ProductFactory();
-    }
-
     public function getSolver(): ProductSolver
     {
         return new ProductSolver();
     {
         return new ProductBuilder();
     }
+
+
+
 }

common/logic/Product/Product/ProductFactory.php

-<?php
-
-namespace common\logic\Product\Product;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class ProductFactory extends BaseService implements FactoryInterface
-{
-    public function create(): Product
-    {
-        $product = new Product();
-
-        return $product;
-    }
-}

common/logic/Product/ProductCategory/ProductCategoryFactory.php → common/logic/Product/ProductCategory/ProductCategoryBuilder.php

 namespace common\logic\Product\ProductCategory;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class ProductCategoryFactory extends BaseService implements FactoryInterface
+class ProductCategoryBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): ProductCategory
+    public function instanciate(): ProductCategory
     {
         $productCategory = new ProductCategory();
 

common/logic/Product/ProductCategory/ProductCategoryContainer.php

     public function getServices(): array
     {
         return [
-            ProductCategoryFactory::class,
+            ProductCategoryBuilder::class,
             ProductCategoryRepository::class
         ];
     }
 
-    public function getFactory(): ProductCategoryFactory
+    public function getBuilder(): ProductCategoryBuilder
     {
-        return new ProductCategoryFactory();
+        return new ProductCategoryBuilder();
     }
 
     public function getRepository(): ProductCategoryRepository

common/logic/Product/ProductPointSale/ProductPointSaleFactory.php → common/logic/Product/ProductPointSale/ProductPointSaleBuilder.php

 namespace common\logic\Product\ProductPointSale;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class ProductPointSaleFactory extends BaseService implements FactoryInterface
+class ProductPointSaleBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): ProductPointSale
+    public function instanciate(): ProductPointSale
     {
         $productPointSale = new ProductPointSale();
 

common/logic/Product/ProductPointSale/ProductPointSaleContainer.php

 namespace common\logic\Product\ProductPointSale;
 
 use common\logic\ContainerInterface;
+use common\logic\Product\ProductPrice\ProductPointSaleRepository;
 
 class ProductPointSaleContainer implements ContainerInterface
 {
     public function getServices(): array
     {
         return [
-            ProductPointSaleFactory::class,
+            ProductPointSaleRepository::class,
+            ProductPointSaleBuilder::class,
         ];
     }
 
-    public function getFactory(): ProductPointSaleFactory
+    public function getRepository(): ProductPointSaleRepository
     {
-        return new ProductPointSaleFactory();
+        return new ProductPointSaleRepository();
+    }
+
+    public function getBuilder(): ProductPointSaleBuilder
+    {
+        return new ProductPointSaleBuilder();
     }
 }

common/logic/Product/ProductPointSale/ProductPointSaleRepository.php

+<?php
+
+namespace common\logic\Product\ProductPrice;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class ProductPointSaleRepository extends BaseService implements RepositoryInterface
+{
+
+}

common/logic/Product/ProductPrice/ProductPriceFactory.php → common/logic/Product/ProductPrice/ProductPriceBuilder.php

 namespace common\logic\Product\ProductPrice;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class ProductPriceFactory extends BaseService implements FactoryInterface
+class ProductPriceBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): ProductPrice
+    public function instanciate(): ProductPrice
     {
         $productPrice = new ProductPrice();
 

common/logic/Product/ProductPrice/ProductPriceContainer.php

     public function getServices(): array
     {
         return [
-            ProductPriceFactory::class,
             ProductPriceSolver::class,
             ProductPriceRepository::class
         ];
     }
 
-    public function getFactory(): ProductPriceFactory
+    public function getBuilder(): ProductPriceBuilder
     {
-        return new ProductPriceFactory();
+        return new ProductPriceBuilder();
     }
 
     public function getSolver(): ProductPriceSolver

common/logic/Subscription/ProductSubscription/ProductSubscriptionFactory.php → common/logic/Subscription/ProductSubscription/ProductSubscriptionBuilder.php

 namespace common\logic\Subscription\ProductSubscription;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class ProductSubscriptionFactory extends BaseService implements FactoryInterface
+class ProductSubscriptionBuilder extends BaseService implements BuilderInterface
 {
-    public function create(): ProductSubscription
+    public function instanciate(): ProductSubscription
     {
         $productSubscription = new ProductSubscription();
 

common/logic/Subscription/ProductSubscription/ProductSubscriptionContainer.php

     public function getServices(): array
     {
         return [
-            ProductSubscriptionFactory::class
+            ProductSubscriptionBuilder::class
         ];
     }
 
-    public function getFactory(): ProductSubscriptionFactory
+    public function getFactory(): ProductSubscriptionBuilder
     {
-        return new ProductSubscriptionFactory();
+        return new ProductSubscriptionBuilder();
     }
 }

common/logic/Subscription/Subscription/SubscriptionBuilder.php

 
 class SubscriptionBuilder extends BaseService implements BuilderInterface
 {
+    public function instanciate(): Subscription
+    {
+        $subscription = new Subscription();
 
+        return $subscription;
+    }
 }

common/logic/Subscription/Subscription/SubscriptionContainer.php

     public function getServices(): array
     {
         return [
-            SubscriptionFactory::class,
             SubscriptionSolver::class,
             SubscriptionRepository::class,
             SubscriptionBuilder::class
         ];
     }
 
-    public function getFactory(): SubscriptionFactory
-    {
-        return new SubscriptionFactory();
-    }
-
     public function getSolver(): SubscriptionSolver
     {
         return new SubscriptionSolver();

common/logic/Subscription/Subscription/SubscriptionFactory.php

-<?php
-
-namespace common\logic\Subscription\Subscription;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class SubscriptionFactory extends BaseService implements FactoryInterface
-{
-    public function create(): Subscription
-    {
-        $subscription = new Subscription();
-
-        return $subscription;
-    }
-}

common/logic/User/CreditHistory/CreditHistoryBuilder.php

         $this->userProducerBuilder = $this->loadService(UserProducerBuilder::class);
     }
 
+    public function instanciate(): CreditHistory
+    {
+        $creditHistory = new CreditHistory();
+
+        return $creditHistory;
+    }
+
     public function save(CreditHistory $creditHistory): bool
     {
         if ($creditHistory->getAmount() > -0.01 && $creditHistory->getAmount() < 0.01) {

common/logic/User/CreditHistory/CreditHistoryContainer.php

     public function getServices(): array
     {
         return [
-            CreditHistoryFactory::class,
             CreditHistorySolver::class,
             CreditHistoryBuilder::class,
             CreditHistoryRepository::class,
         ];
     }
 
-    public function getFactory(): CreditHistoryFactory
-    {
-        return new CreditHistoryFactory();
-    }
-
     public function getSolver(): CreditHistorySolver
     {
         return new CreditHistorySolver();

common/logic/User/CreditHistory/CreditHistoryFactory.php

-<?php
-
-namespace common\logic\User\CreditHistory;
-
-use common\logic\FactoryInterface;
-
-class CreditHistoryFactory implements FactoryInterface
-{
-    public function create()
-    {
-        $creditHistory = new CreditHistory();
-
-        return $creditHistory;
-    }
-}

common/logic/User/User/UserBuilder.php

 
 class UserBuilder extends BaseService implements BuilderInterface
 {
+    public function instanciate(): User
+    {
+        $user = new User();
+
+        return $user;
+    }
+
     public function initPassword(User $user, string $password)
     {
         $user->setPassword($password);

common/logic/User/User/UserContainer.php

     public function getServices(): array
     {
         return [
-            UserFactory::class,
             UserSolver::class,
             UserRepository::class,
             UserBuilder::class,
         ];
     }
 
-    public function getFactory(): UserFactory
-    {
-        return new UserFactory();
-    }
-
     public function getSolver(): UserSolver
     {
         return new UserSolver();

common/logic/User/User/UserFactory.php

-<?php
-
-namespace common\logic\User\User;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class UserFactory extends BaseService implements FactoryInterface
-{
-    public function create()
-    {
-        $user = new User();
-
-        return $user;
-    }
-}

common/logic/User/UserGroup/UserGroupFactory.php → common/logic/User/UserGroup/UserGroupBuilder.php

 namespace common\logic\User\UserGroup;
 
 use common\logic\BaseService;
-use common\logic\FactoryInterface;
+use common\logic\BuilderInterface;
 
-class UserGroupFactory extends BaseService implements FactoryInterface
+class UserGroupBuilder extends BaseService implements BuilderInterface
 {
-    public function create()
+    public function instanciate(): UserGroup
     {
         $userGroup = new UserGroup();
 

common/logic/User/UserGroup/UserGroupContainer.php

     public function getServices(): array
     {
         return [
-            UserGroupFactory::class,
+            UserGroupBuilder::class,
             UserGroupRepository::class
         ];
     }
 
-    public function getFactory(): UserGroupFactory
+    public function getFactory(): UserGroupBuilder
     {
-        return new UserGroupFactory();
+        return new UserGroupBuilder();
     }
 
     public function getRepository(): UserGroupRepository

common/logic/User/UserProducer/UserProducerBuilder.php

         $this->userProducerRepository = $this->loadService(UserProducerRepository::class);
     }
 
+    public function instanciate(int $idUser, int $idProducer, int $bookmark = 1)
+    {
+        $userProducer = new UserProducer();
+
+        $userProducer->setIdUser($idUser);
+        $userProducer->setIdProducer($idProducer);
+        $userProducer->setCredit(0);
+        $userProducer->setActive(1);
+        $userProducer->setBookmark($bookmark);
+
+        return $userProducer;
+    }
+
     public function updateCredit(CreditHistory $creditHistory): void
     {
         $userProducer = $this->userProducerRepository->getOne($creditHistory->getIdUser(), $creditHistory->getIdProducer());

common/logic/User/UserProducer/UserProducerContainer.php

     public function getServices(): array
     {
         return [
-            UserProducerRepository::class
+            UserProducerRepository::class,
+            UserProducerBuilder::class,
         ];
     }
 
     {
         return new UserProducerRepository();
     }
+
+    public function getBuilder(): UserProducerBuilder
+    {
+        return new UserProducerBuilder();
+    }
 }

common/logic/User/UserProducer/UserProducerFactory.php

-<?php
-
-namespace common\logic\User\UserProducer;
-
-use common\logic\FactoryInterface;
-
-class UserProducerFactory implements FactoryInterface
-{
-    public function create(int $idUser, int $idProducer, int $bookmark = 1)
-    {
-        $userProducer = new UserProducer();
-
-        $userProducer->setIdUser($idUser);
-        $userProducer->setIdProducer($idProducer);
-        $userProducer->setCredit(0);
-        $userProducer->setActive(1);
-        $userProducer->setBookmark($bookmark);
-
-        return $userProducer;
-    }
-}

common/logic/User/UserUserGroup/UserUserGroupBuilder.php

+<?php
+
+namespace common\logic\User\UserGroup;
+
+use common\logic\BaseService;
+use common\logic\BuilderInterface;
+
+class UserUserGroupBuilder extends BaseService implements BuilderInterface
+{
+    public function instanciate(): UserUserGroup
+    {
+        $userUserGroup = new UserUserGroup();
+
+        return $userUserGroup;
+    }
+}

common/logic/User/UserUserGroup/UserUserGroupContainer.php

 namespace common\logic\User\UserGroup;
 
 use common\logic\ContainerInterface;
+use common\logic\User\UserProducer\UserUserGroupRepository;
 
 class UserUserGroupContainer implements ContainerInterface
 {
     public function getEntityFqcn(): string
     {
-        return User UserGroup::class;
+        return UserUserGroup::class;
     }
 
     public function getServices(): array
     {
         return [
-            UserUserGroupFactory::class
+            UserUserGroupRepository::class,
+            UserUserGroupBuilder::class
         ];
     }
 
-    public function getFactory(): UserUserGroupFactory
+    public function getRepository(): UserUserGroupRepository
     {
-        return new UserUserGroupFactory();
+        return new UserUserGroupRepository();
+    }
+
+    public function getBuilder(): UserUserGroupBuilder
+    {
+        return new UserUserGroupBuilder();
     }
 }

common/logic/User/UserUserGroup/UserUserGroupFactory.php

-<?php
-
-namespace common\logic\User\UserGroup;
-
-use common\logic\BaseService;
-use common\logic\FactoryInterface;
-
-class UserUserGroupFactory extends BaseService implements FactoryInterface
-{
-    public function create(): User UserGroup
-    {
-        $userUserGroup = new User UserGroup();
-
-        return $userUserGroup;
-    }
-}

common/logic/User/UserUserGroup/UserUserGroupRepository.php

+<?php
+
+namespace common\logic\User\UserProducer;
+
+use common\logic\BaseService;
+use common\logic\RepositoryInterface;
+
+class UserUserGroupRepository extends BaseService implements RepositoryInterface
+{
+
+}