Refactoring modèles

Model/Address/AddressInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Address;
 
 interface AddressInterface
 {

Model/Address/Address.php → Model/Address/AddressModel.php

 namespace Lc\CaracoleBundle\Model\Address;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\StatusInterface;
+use Lc\SovBundle\Doctrine\Extension\StatusInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Address extends AbstractEntity implements StatusInterface
+abstract class AddressModel extends AbstractEntity implements StatusInterface
 {
         use StatusTrait;
 
         const TYPE_LEGAL_PERSON = 'legal-person';
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface", inversedBy="addresses")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", inversedBy="addresses")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $user;
         protected $comment;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\PointSaleInterface", mappedBy="address", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\PointSale\PointSaleInterface", mappedBy="address", cascade={"persist", "remove"})
          */
         protected $pointSale;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", mappedBy="address", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", mappedBy="address", cascade={"persist", "remove"})
          */
         protected $merchant;
 

Model/Common/TaxRateInterface.php

+<?php
+
+namespace Lc\CaracoleBundle\Model\Common;
+
+interface TaxRateInterface
+{
+
+}

Model/Global/TaxRate.php → Model/Common/TaxRateModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Common;
 
 use Doctrine\ORM\Mapping as ORM;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class TaxRate extends AbstractEntity
+abstract class TaxRateModel extends AbstractEntity
 {
 
         /**

Model/Common/UnitInterface.php

+<?php
+
+namespace Lc\CaracoleBundle\Model\Common ;
+
+interface UnitInterface
+{
+
+}

Model/Global/Unit.php → Model/Common/UnitModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Common;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Model\AbstractEntity;
+use Lc\CaracoleBundle\Model\AbstractEntity;
 
 /**
  * @ORM\MappedSuperclass
  */
-abstract class Unit extends AbstractEntity
+abstract class UnitModel extends AbstractEntity
 {
         /**
          * @ORM\Column(type="string", length=32)
         protected $coefficient;
 
         /**
-         * @ORM\ManyToOne(targetEntity="App\Entity\Unit")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Common\UnitInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $unitReference;

Model/Credit/CreditConfigInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Credit;
 
 interface CreditConfigInterface
 {

Model/Credit/CreditConfig.php → Model/Credit/CreditConfigModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Credit;
 
 use Doctrine\ORM\Mapping as ORM;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class CreditConfig
+abstract class CreditConfigModel
 {
         /**
          * @ORM\Column(type="boolean")

Model/Credit/CreditHistoryInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Credit;
 
 interface CreditHistoryInterface
 {

Model/Credit/CreditHistory.php → Model/Credit/CreditHistoryModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Credit;
 
 use App\Entity\OrderPayment;
 use App\Entity\OrderRefund;
 use App\Entity\UserMerchant;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\OrderPaymentInterface;
-use Lc\ShopBundle\Context\OrderRefundInterface;
-use Lc\ShopBundle\Context\PayoffInterface;
-use Lc\ShopBundle\Context\UserMerchantInterface;
+use Lc\CaracoleBundle\Model\Order\OrderPaymentInterface;
+use Lc\CaracoleBundle\Model\Order\OrderRefundInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\PayoffInterface;
+use Lc\CaracoleBundle\Model\User\UserMerchantInterface;
 use Gedmo\Mapping\Annotation as Gedmo;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class CreditHistory extends AbstractEntity implements PayoffInterface
+abstract class CreditHistoryModel extends AbstractEntity implements PayoffInterface
 {
         use PayoffTrait;
 
         protected $type;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserMerchantInterface", inversedBy="creditHistories")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserMerchantInterface", inversedBy="creditHistories")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $userMerchant;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\OrderPaymentInterface", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderPaymentInterface", cascade={"persist", "remove"})
          */
         protected $orderPayment;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\OrderRefundInterface", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderRefundInterface", cascade={"persist", "remove"})
          */
         protected $orderRefund;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;

Model/File/DocumentInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\File;
 
 interface DocumentInterface
 {

Model/File/Document.php → Model/File/DocumentModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\File;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 use Gedmo\Mapping\Annotation as Gedmo;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Document extends AbstractDocumentEntity implements FilterMerchantInterface
+abstract class DocumentModel extends AbstractDocumentEntity implements FilterMerchantInterface
 {
         const TYPE_INVOICE = 'invoice';
         const TYPE_QUOTATION = 'quotation';
         const TYPE_DELIVERY_NOTE = 'delivery-note';
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
         protected $logo;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\AddressInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Address\AddressInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchantAddress;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\AddressInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Address\AddressInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $buyerAddress;
         protected $isSent;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", mappedBy="documents")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", mappedBy="documents")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $orderShops;
 
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\OrderRefundInterface", mappedBy="document", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderRefundInterface", mappedBy="document", cascade={"persist", "remove"})
          */
         protected $orderRefund;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;

Model/Global/TaxRateInterface.php

-<?php
-
-namespace Lc\ShopBundle\Context;
-
-interface TaxRateInterface
-{
-
-}

Model/Global/UnitInterface.php

-<?php
-
-namespace Lc\ShopBundle\Context ;
-
-interface UnitInterface
-{
-
-}

Model/Merchant/MerchantConfigInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Merchant;
 
 interface MerchantConfigInterface
 {

Model/Merchant/MerchantConfig.php → Model/Merchant/MerchantConfigModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Merchant;
 
 use Doctrine\ORM\Mapping as ORM;
 use Symfony\Component\HttpFoundation\File\File;
  * @ORM\MappedSuperclass()
  * @Vich\Uploadable
  */
-abstract class MerchantConfig extends AbstractEntity
+abstract class MerchantConfigModel extends AbstractEntity
 {
     /**
-     * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="merchantConfigs")
+     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="merchantConfigs")
      * @ORM\JoinColumn(nullable=false)
      */
     protected $merchant;
 
     public static $availableOptions = [];
 
-    public function getMerchant(): ?Merchant
+    public function getMerchant(): ?MerchantModel
     {
         return $this->merchant;
     }
 
-    public function setMerchant(?Merchant $merchant): self
+    public function setMerchant(?MerchantModel $merchant): self
     {
         $this->merchant = $merchant;
 

Model/Merchant/MerchantInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Merchant;
 
 interface MerchantInterface
 {

Model/Merchant/Merchant.php → Model/Merchant/MerchantModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Merchant;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\CreditConfigInterface;
-use Lc\ShopBundle\Context\GroupUserInterface;
+use Lc\CaracoleBundle\Model\Credit\CreditConfigInterface;
+use Lc\CaracoleBundle\Model\User\GroupUserInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Merchant extends AbstractDocumentEntity
+abstract class MerchantModel extends AbstractDocumentEntity
 {
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\CreditConfigInterface", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Credit\CreditConfigInterface", cascade={"persist", "remove"})
          * @ORM\JoinColumn(nullable=true)
          */
         protected $creditConfig;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\TaxRateInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Common\TaxRateInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $taxRate;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\PointSaleInterface", mappedBy="merchants")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\PointSale\PointSaleInterface", mappedBy="merchants")
          */
         protected $pointSales;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\ProductFamilyInterface", mappedBy="merchant")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductFamilyInterface", mappedBy="merchant")
          */
         protected $productFamilies;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\MerchantConfigInterface", mappedBy="merchant", orphanRemoval=true, cascade={"persist"})
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantConfigInterface", mappedBy="merchant", orphanRemoval=true, cascade={"persist"})
          */
         protected $merchantConfigs;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\AddressInterface", inversedBy="merchant", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Address\AddressInterface", inversedBy="merchant", cascade={"persist", "remove"})
          * @ORM\JoinColumn(nullable=true)
          */
         protected $address;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\ProductCategoryInterface", mappedBy="merchant", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface", mappedBy="merchant", orphanRemoval=true)
          */
         protected $productCategories;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\NewsInterface", mappedBy="merchant", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\News\NewsInterface", mappedBy="merchant", orphanRemoval=true)
          */
         protected $news;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\PageInterface", mappedBy="merchant", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Site\PageInterface", mappedBy="merchant", orphanRemoval=true)
          */
         protected $pages;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\NewsletterInterface", mappedBy="merchant")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Newsletter\NewsletterInterface", mappedBy="merchant")
          */
         protected $newsletters;
 
         /**
-         * @ORM\OneToMany(targetEntity="App\Entity\GroupUser", mappedBy="merchant")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\User\GroupUser", mappedBy="merchant")
          */
         protected $groupUsers;
 
         }
 
         /**
-         * @return Collection|MerchantConfig[]
+         * @return Collection|MerchantConfigModel[]
          */
         public function getMerchantConfigs(): Collection
         {
                 return $this->merchantConfigs;
         }
 
-        public function addMerchantConfig(MerchantConfig $merchantConfig): self
+        public function addMerchantConfig(MerchantConfigModel $merchantConfig): self
         {
                 if (!$this->merchantConfigs->contains($merchantConfig)) {
                         $this->merchantConfigs[] = $merchantConfig;
                 return $this;
         }
 
-        public function removeMerchantConfig(MerchantConfig $merchantConfig): self
+        public function removeMerchantConfig(MerchantConfigModel $merchantConfig): self
         {
                 if ($this->merchantConfigs->contains($merchantConfig)) {
                         $this->merchantConfigs->removeElement($merchantConfig);

Model/Newsletter/NewsletterInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context ;
+namespace Lc\CaracoleBundle\Model\Newsletter ;
 
 interface NewsletterInterface
 {

Model/Newsletter/Newsletter.php → Model/Newsletter/NewsletterModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Newsletter;
 
 use App\Entity\Hub;
 use App\Entity\User;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Newsletter extends AbstractDocumentEntity implements FilterMerchantInterface
+abstract class NewsletterModel extends AbstractDocumentEntity implements FilterMerchantInterface
 {
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="newsletters")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="newsletters")
          */
         protected $merchant;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\UserInterface", mappedBy="newsletters")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", mappedBy="newsletters")
          */
         protected $users;
 

Model/Order/OrderPayment.php

-<?php
-
-namespace Lc\ShopBundle\Model;
-
-use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\OrderPaymentInterface;
-use Lc\ShopBundle\Context\OrderPayoffInterface;
-use Lc\ShopBundle\Context\ReductionInterface;
-
-/**
- * @ORM\MappedSuperclass()
- */
-abstract class OrderPayment extends AbstractEntity implements OrderPayoffInterface
-{
-        use OrderPayoffTrait;
-
-}

Model/Order/OrderPaymentInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context ;
+namespace Lc\CaracoleBundle\Model\Order ;
 
 interface OrderPaymentInterface
 {

Model/Order/OrderPaymentModel.php

+<?php
+
+namespace Lc\CaracoleBundle\Model\Order;
+
+use Doctrine\ORM\Mapping as ORM;
+use Lc\CaracoleBundle\Model\Order\OrderPaymentInterface;
+use Lc\CaracoleBundle\Model\Order\OrderPayoffInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionInterface;
+
+/**
+ * @ORM\MappedSuperclass()
+ */
+abstract class OrderPaymentModel extends AbstractEntity implements OrderPayoffInterface
+{
+        use OrderPayoffTrait;
+
+}

Model/Order/OrderPayoffInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderPayoffInterface
 {

Model/Order/OrderProductInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderProductInterface
 {

Model/Order/OrderProduct.php → Model/Order/OrderProductModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
-use App\Entity\OrderProductReductionCatalog;
+use Lc\CaracoleBundle\Model\Order\OrderProductReductionCatalog;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\PriceInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\PriceInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderProduct implements PriceInterface
+abstract class OrderProductModel implements PriceInterface
 {
         use PriceTrait ;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", inversedBy="orderProducts", cascade={"persist"})
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", inversedBy="orderProducts", cascade={"persist"})
          * @ORM\JoinColumn(nullable=false)
          */
         protected $orderShop;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\ProductInterface"))
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Product\ProductInterface"))
          */
         protected $product;
 
         protected $title;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\OrderProductReductionCatalogInterface", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderProductReductionCatalogInterface", cascade={"persist", "remove"})
          */
         protected $orderProductReductionCatalog;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\OrderProductRefundInterface", mappedBy="orderProduct", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderProductRefundInterface", mappedBy="orderProduct", cascade={"persist", "remove"})
          */
         protected $orderProductRefund;
 
                 return $title ;
         }
 
-        public function getOrderShop(): ?OrderShop
+        public function getOrderShop(): ?OrderShopModel
         {
                 return $this->orderShop;
         }
 
-        public function setOrderShop(?OrderShop $orderShop): self
+        public function setOrderShop(?OrderShopModel $orderShop): self
         {
                 $this->orderShop = $orderShop;
 
 
                 return $this;
         }
-        public function getOrderProductRefund(): ?OrderProductRefund
+        public function getOrderProductRefund(): ?OrderProductRefundModel
         {
                 return $this->orderProductRefund;
         }
 
-        public function setOrderProductRefund(OrderProductRefund $orderProductRefund): self
+        public function setOrderProductRefund(OrderProductRefundModel $orderProductRefund): self
         {
                 $this->orderProductRefund = $orderProductRefund;
 

Model/Order/OrderProductReductionCatalogInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context ;
+namespace Lc\CaracoleBundle\Model\Order ;
 
 interface OrderProductReductionCatalogInterface
 {

Model/Order/OrderProductReductionCatalog.php → Model/Order/OrderProductReductionCatalogModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\OrderProductReductionCatalogInterface;
+use Lc\CaracoleBundle\Model\Order\OrderProductReductionCatalogInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderProductReductionCatalog implements OrderProductReductionCatalogInterface
+abstract class OrderProductReductionCatalogModel implements OrderProductReductionCatalogInterface
 {
         use ReductionTrait ;
 

Model/Order/OrderProductRefundInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderProductRefundInterface
 {

Model/Order/OrderProductRefund.php → Model/Order/OrderProductRefundModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\ORM\Mapping as ORM;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderProductRefund
+abstract class OrderProductRefundModel
 {
         /**
          * @ORM\Column(type="integer")
         protected $price;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\OrderProductInterface", inversedBy="orderProductRefund", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderProductInterface", inversedBy="orderProductRefund", cascade={"persist", "remove"})
          * @ORM\JoinColumn(nullable=false)
          */
         protected $orderProduct;
                 return $this;
         }
 
-        public function getOrderProduct(): ?OrderProduct
+        public function getOrderProduct(): ?OrderProductModel
         {
                 return $this->orderProduct;
         }
 
-        public function setOrderProduct(OrderProduct $orderProduct): self
+        public function setOrderProduct(OrderProductModel $orderProduct): self
         {
                 $this->orderProduct = $orderProduct;
 

Model/Order/OrderReductionCartInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderReductionCartInterface
 {

Model/Order/OrderReductionCart.php → Model/Order/OrderReductionCartModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\ReductionCartPropertyInterface;
-use Lc\ShopBundle\Context\ReductionInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\ReductionCartPropertyInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderReductionCart implements ReductionInterface, ReductionCartPropertyInterface
+abstract class OrderReductionCartModel implements ReductionInterface, ReductionCartPropertyInterface
 {
         use ReductionTrait;
         use ReductionCartPropertyTrait;
         protected $title;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", inversedBy="orderReductionCarts")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", inversedBy="orderReductionCarts")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $orderShop;
 
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\ReductionCartInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Reduction\ReductionCartInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $reductionCart;
                 return $this;
         }
 
-        public function getOrderShop(): ?OrderShop
+        public function getOrderShop(): ?OrderShopModel
         {
                 return $this->orderShop;
         }
 
-        public function setOrderShop(?OrderShop $orderShop): self
+        public function setOrderShop(?OrderShopModel $orderShop): self
         {
                 $this->orderShop = $orderShop;
 

Model/Order/OrderReductionCreditInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderReductionCreditInterface
 {

Model/Order/OrderReductionCredit.php → Model/Order/OrderReductionCreditModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\ReductionInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderReductionCredit implements ReductionInterface
+abstract class OrderReductionCreditModel implements ReductionInterface
 {
         use ReductionTrait ;
 
 
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", inversedBy="orderReductionCredits")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", inversedBy="orderReductionCredits")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $orderShop;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\ReductionCreditInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Reduction\ReductionCreditInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $reductionCredit;
                 return $this;
         }
 
-        public function getOrderShop(): ?OrderShop
+        public function getOrderShop(): ?OrderShopModel
         {
                 return $this->orderShop;
         }
 
-        public function setOrderShop(?OrderShop $orderShop): self
+        public function setOrderShop(?OrderShopModel $orderShop): self
         {
                 $this->orderShop = $orderShop;
 

Model/Order/OrderRefundInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderRefundInterface
 {

Model/Order/OrderRefund.php → Model/Order/OrderRefundModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\OrderPaymentInterface;
-use Lc\ShopBundle\Context\OrderPayoffInterface;
-use Lc\ShopBundle\Context\ReductionInterface;
+use Lc\CaracoleBundle\Model\Order\OrderPaymentInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\OrderPayoffInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderRefund extends AbstractEntity implements OrderPayoffInterface
+abstract class OrderRefundModel extends AbstractEntity implements OrderPayoffInterface
 {
         use OrderPayoffTrait;
 
         protected $deliveryRefundAmount;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\DocumentInterface", inversedBy="orderRefund", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\File\DocumentInterface", inversedBy="orderRefund", cascade={"persist", "remove"})
          * @ORM\JoinColumn(nullable=false)
          */
         protected $document;

Model/Order/OrderShopInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderShopInterface
 {

Model/Order/OrderShop.php → Model/Order/OrderShopModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Gedmo\Mapping\Annotation as Gedmo;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\DocumentInterface;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Services\Order\OrderUtils;
-use Lc\ShopBundle\Model\OrderStatus ;
+use Lc\CaracoleBundle\Model\File\DocumentInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Services\Order\OrderUtils;
+use Lc\CaracoleBundle\Model\OrderStatus ;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderShop extends AbstractEntity implements FilterMerchantInterface
+abstract class OrderShopModel extends AbstractEntity implements FilterMerchantInterface
 {
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="productFamilies")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="productFamilies")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface", inversedBy="orders", fetch="EAGER")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", inversedBy="orders", fetch="EAGER")
          */
         protected $user;
 
         /**
-         * @ORM\ManyToOne(targetEntity="App\Entity\Visitor", inversedBy="orders")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\VisitorInterface", inversedBy="orders")
          */
         protected $visitor;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\AddressInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Address\AddressInterface")
          */
         protected $invoiceAddress;
 
         protected $meanPayment;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\OrderStatusHistoryInterface", mappedBy="orderShop", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderStatusHistoryInterface", mappedBy="orderShop", orphanRemoval=true)
          */
         protected $orderStatusHistories;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\OrderPaymentInterface", mappedBy="orderShop", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderPaymentInterface", mappedBy="orderShop", orphanRemoval=true)
          */
         protected $orderPayments;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\OrderProductInterface", mappedBy="orderShop", cascade={"persist", "remove"}, orphanRemoval=true, fetch="EAGER")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderProductInterface", mappedBy="orderShop", cascade={"persist", "remove"}, orphanRemoval=true, fetch="EAGER")
          */
         protected $orderProducts;
 
         protected $deliveryInfos;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\OrderStatusInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderStatusInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $orderStatus;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\OrderReductionCartInterface", mappedBy="orderShop", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderReductionCartInterface", mappedBy="orderShop", orphanRemoval=true)
          */
         protected $orderReductionCarts;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\OrderReductionCreditInterface", mappedBy="orderShop", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderReductionCreditInterface", mappedBy="orderShop", orphanRemoval=true)
          */
         protected $orderReductionCredits;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\DocumentInterface", inversedBy="orderShops")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Order\DocumentInterface", inversedBy="orderShops")
          */
         protected $documents;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\TicketInterface", mappedBy="orderShop")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Ticket\TicketInterface", mappedBy="orderShop")
          */
         protected $tickets;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\SectionInterface", inversedBy="orderShops")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface", inversedBy="orderShops")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $section;
         }
 
         /**
-         * @return Collection|OrderStatusHistory[]
+         * @return Collection|OrderStatusHistoryModel[]
          */
         public function getOrderStatusHistories(): Collection
         {
                 return $this->orderStatusHistories;
         }
 
-        public function addOrderStatusHistory(OrderStatusHistory $orderStatusHistory): self
+        public function addOrderStatusHistory(OrderStatusHistoryModel $orderStatusHistory): self
         {
                 if (!$this->orderStatusHistories->contains($orderStatusHistory)) {
                         $this->orderStatusHistories[] = $orderStatusHistory;
                 return $this;
         }
 
-        public function removeOrderStatusHistory(OrderStatusHistory $orderStatusHistory): self
+        public function removeOrderStatusHistory(OrderStatusHistoryModel $orderStatusHistory): self
         {
                 if ($this->orderStatusHistories->contains($orderStatusHistory)) {
                         $this->orderStatusHistories->removeElement($orderStatusHistory);
         }
 
         /**
-         * @return Collection|OrderPayment[]
+         * @return Collection|OrderPaymentModel[]
          */
         public function getOrderPayments($meanPayment = null): Collection
         {
                 return $this->orderPayments;
         }
 
-        public function addOrderPayment(OrderPayment $orderPayment): self
+        public function addOrderPayment(OrderPaymentModel $orderPayment): self
         {
                 if (!$this->orderPayments->contains($orderPayment)) {
                         $this->orderPayments[] = $orderPayment;
                 return $this;
         }
 
-        public function removeOrderPayment(OrderPayment $orderPayment): self
+        public function removeOrderPayment(OrderPaymentModel $orderPayment): self
         {
                 if ($this->orderPayments->contains($orderPayment)) {
                         $this->orderPayments->removeElement($orderPayment);
         }
 
         /**
-         * @return Collection|OrderProduct[]
+         * @return Collection|OrderProductModel[]
          */
         public function getOrderProducts(): Collection
         {
                 return $this->orderProducts;
         }
 
-        public function addOrderProduct(OrderProduct $orderProduct): self
+        public function addOrderProduct(OrderProductModel $orderProduct): self
         {
                 if (!$this->orderProducts->contains($orderProduct)) {
                         $this->orderProducts[] = $orderProduct;
                 return $this;
         }
 
-        public function removeOrderProduct(OrderProduct $orderProduct): self
+        public function removeOrderProduct(OrderProductModel $orderProduct): self
         {
                 if ($this->orderProducts->contains($orderProduct)) {
                         $this->orderProducts->removeElement($orderProduct);
 
 
         /**
-         * @return Collection|OrderReductionCart[]
+         * @return Collection|OrderReductionCartModel[]
          */
         public function getOrderReductionCarts(): Collection
         {
                 return $this->orderReductionCarts;
         }
 
-        public function addOrderReductionCart(OrderReductionCart $orderReductionCart): self
+        public function addOrderReductionCart(OrderReductionCartModel $orderReductionCart): self
         {
                 if (!$this->orderReductionCarts->contains($orderReductionCart)) {
                         $this->orderReductionCarts[] = $orderReductionCart;
                 return $this;
         }
 
-        public function removeOrderReductionCart(OrderReductionCart $orderReductionCart): self
+        public function removeOrderReductionCart(OrderReductionCartModel $orderReductionCart): self
         {
                 if ($this->orderReductionCarts->contains($orderReductionCart)) {
                         $this->orderReductionCarts->removeElement($orderReductionCart);
         }
 
         /**
-         * @return Collection|OrderReductionCart[]
+         * @return Collection|OrderReductionCartModel[]
          */
         public function getOrderReductionCredits(): Collection
         {
                 return $this->orderReductionCredits;
         }
 
-        public function addOrderReductionCredit(OrderReductionCredit $orderReductionCredit): self
+        public function addOrderReductionCredit(OrderReductionCreditModel $orderReductionCredit): self
         {
                 if (!$this->orderReductionCredits->contains($orderReductionCredit)) {
                         $this->orderReductionCredits[] = $orderReductionCredit;
                 return $this;
         }
 
-        public function removeOrderReductionCredit(OrderReductionCredit $orderReductionCredit): self
+        public function removeOrderReductionCredit(OrderReductionCreditModel $orderReductionCredit): self
         {
                 if ($this->orderReductionCredits->contains($orderReductionCredit)) {
                         $this->orderReductionCredits->removeElement($orderReductionCredit);

Model/Order/OrderShopPriceUtilsInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context ;
+namespace Lc\CaracoleBundle\Model\Order ;
 
 interface OrderShopPriceUtilsInterface
 {

Model/Order/OrderStatusHistoryInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderStatusHistoryInterface
 {

Model/Order/OrderStatusHistory.php → Model/Order/OrderStatusHistoryModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\ORM\Mapping as ORM;
 use Gedmo\Mapping\Annotation as Gedmo;
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderStatusHistory extends AbstractEntity
+abstract class OrderStatusHistoryModel extends AbstractEntity
 {
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", inversedBy="orderStatusHistories")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", inversedBy="orderStatusHistories")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $orderShop;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\OrderStatusInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderStatusInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $orderStatus;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;
                 return $this->getOrderStatus()->getAlias(). ' le : '.$this->getCreatedAt()->format('d-m-Y H:i').'('.$this->getOrigin().')';
         }
 
-        public function getOrderShop(): ?OrderShop
+        public function getOrderShop(): ?OrderShopModel
         {
                 return $this->orderShop;
         }
 
-        public function setOrderShop(?OrderShop $orderShop): self
+        public function setOrderShop(?OrderShopModel $orderShop): self
         {
                 $this->orderShop = $orderShop;
 
                 return $this;
         }
 
-        public function getOrderStatus(): ?OrderStatus
+        public function getOrderStatus(): ?OrderStatusModel
         {
                 return $this->orderStatus;
         }
 
-        public function setOrderStatus(?OrderStatus $orderStatus): self
+        public function setOrderStatus(?OrderStatusModel $orderStatus): self
         {
                 $this->orderStatus = $orderStatus;
 

Model/Order/OrderStatusInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Order;
 
 interface OrderStatusInterface
 {

Model/Order/OrderStatus.php → Model/Order/OrderStatusModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Order;
 
 use Doctrine\ORM\Mapping as ORM;
 use Doctrine\Common\Collections\ArrayCollection;
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class OrderStatus
+abstract class OrderStatusModel
 {
         const ALIAS_CART = 'cart' ;
         const ALIAS_CART_CANCELED = 'cart-canceled' ;
         protected $description;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\OrderStatusInterface")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderStatusInterface")
          */
         protected $nextStatusAllowed;
 

Model/PointSale/PointSaleDayInfoInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\PointSale;
 
 interface PointSaleDayInfoInterface
 {

Model/PointSale/PointSaleDayInfo.php → Model/PointSale/PointSaleDayInfoModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\PointSale;
 
 use Doctrine\ORM\Mapping as ORM;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class PointSaleDayInfo extends AbstractEntity
+abstract class PointSaleDayInfoModel extends AbstractEntity
 {
         /**
          * @ORM\Column(type="boolean")
         protected $description;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\PointSaleInterface", inversedBy="pointSaleDayInfos")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\PointSale\PointSaleInterface", inversedBy="pointSaleDayInfos")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $pointSale;
                 return $this;
         }
 
-        public function getPointSale(): ?PointSale
+        public function getPointSale(): ?PointSaleModel
         {
                 return $this->pointSale;
         }
 
-        public function setPointSale(?PointSale $pointSale): self
+        public function setPointSale(?PointSaleModel $pointSale): self
         {
                 $this->pointSale = $pointSale;
 

Model/PointSale/PointSaleInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\PointSale;
 
 interface PointSaleInterface
 {

Model/PointSale/PointSale.php → Model/PointSale/PointSaleModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\PointSale;
 
 use App\Entity\User;
 use App\Entity\UserPointSale;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMultipleMerchantsInterface;
-use Lc\ShopBundle\Context\OrderAmountMinInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMultipleMerchantsInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\OrderAmountMinInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class PointSale extends AbstractDocumentEntity implements FilterMultipleMerchantsInterface, OrderAmountMinInterface
+abstract class PointSaleModel extends AbstractDocumentEntity implements FilterMultipleMerchantsInterface, OrderAmountMinInterface
 {
 
         use OrderAmountMin;
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="pointSales")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="pointSales")
          */
         protected $merchants;
 
         protected $code;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\PointSaleDayInfoInterface", mappedBy="pointSale", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Pointsale\PointSaleDayInfoInterface", mappedBy="pointSale", orphanRemoval=true)
          */
         protected $pointSaleDayInfos;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\AddressInterface", inversedBy="pointSale", cascade={"persist", "remove"})
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Address\AddressInterface", inversedBy="pointSale", cascade={"persist", "remove"})
          * @ORM\JoinColumn(nullable=false)
          */
         protected $address;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\UserPointSaleInterface", mappedBy="pointSale", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\User\UserPointSaleInterface", mappedBy="pointSale", orphanRemoval=true)
          */
         protected $userPointSales;
 
         }
 
         /**
-         * @return Collection|PointSaleDayInfo[]
+         * @return Collection|PointSaleDayInfoModel[]
          */
         public function getPointSaleDayInfos(): Collection
         {
                 return $this->pointSaleDayInfos;
         }
 
-        public function addPointSaleDayInfo(PointSaleDayInfo $pointSaleDayInfo): self
+        public function addPointSaleDayInfo(PointSaleDayInfoModel $pointSaleDayInfo): self
         {
                 if (!$this->pointSaleDayInfos->contains($pointSaleDayInfo)) {
                         $this->pointSaleDayInfos[] = $pointSaleDayInfo;
                 return $this;
         }
 
-        public function removePointSaleDayInfo(PointSaleDayInfo $pointSaleDayInfo): self
+        public function removePointSaleDayInfo(PointSaleDayInfoModel $pointSaleDayInfo): self
         {
                 if ($this->pointSaleDayInfos->contains($pointSaleDayInfo)) {
                         $this->pointSaleDayInfos->removeElement($pointSaleDayInfo);

Model/Product/ProductCategoryInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Product;
 
 interface ProductCategoryInterface
 {

Model/Product/ProductCategory.php → Model/Product/ProductCategoryModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Product;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Context\TreeInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\SovBundle\Doctrine\Extension\TreeInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class ProductCategory extends AbstractDocumentEntity implements TreeInterface, FilterMerchantInterface
+abstract class ProductCategoryModel extends AbstractDocumentEntity implements TreeInterface, FilterMerchantInterface
 {
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="productCategories")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="productCategories")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\ProductCategoryInterface", inversedBy="childrens")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface", inversedBy="childrens")
          */
         protected $parent;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\ProductCategoryInterface", mappedBy="parent" , fetch="EAGER"))
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface", mappedBy="parent" , fetch="EAGER"))
          * @ORM\OrderBy({"position" = "ASC"})
          */
         protected $childrens;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ProductFamilyInterface", mappedBy="productCategories")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductFamilyInterface", mappedBy="productCategories")
          */
         protected $productFamilies;
 
 
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\SectionInterface", inversedBy="productCategories")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface", inversedBy="productCategories")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $section;
         }
 
         /**
-         * @return Collection|ProductFamily[]
+         * @return Collection|ProductFamilyModel[]
          */
         public function getProductFamilies(): Collection
         {
                 return $this->productFamilies;
         }
 
-        public function addProductFamily(ProductFamily $productFamily): self
+        public function addProductFamily(ProductFamilyModel $productFamily): self
         {
                 if (!$this->productFamilies->contains($productFamily)) {
                         $this->productFamilies[] = $productFamily;
                 return $this;
         }
 
-        public function removeProductFamily(ProductFamily $productFamily): self
+        public function removeProductFamily(ProductFamilyModel $productFamily): self
         {
                 if ($this->productFamilies->contains($productFamily)) {
                         $this->productFamilies->removeElement($productFamily);

Model/Product/ProductFamilyInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Product;
 
 interface ProductFamilyInterface
 {

Model/Product/ProductFamily.php → Model/Product/ProductFamilyModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Product;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Context\PriceInterface;
-use Lc\ShopBundle\Context\ProductInterface;
-use Lc\ShopBundle\Context\ProductPropertyInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\PriceInterface;
+use Lc\CaracoleBundle\Model\Product\ProductInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\ProductPropertyInterface;
 use Gedmo\Mapping\Annotation as Gedmo;
 
 
  * @ORM\MappedSuperclass()
  */
 
-abstract class ProductFamily extends AbstractDocumentEntity implements ProductPropertyInterface, PriceInterface, FilterMerchantInterface
+abstract class ProductFamilyModel extends AbstractDocumentEntity implements ProductPropertyInterface, PriceInterface, FilterMerchantInterface
 {
 
         use ProductPropertyTrait;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="productFamilies")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="productFamilies")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ProductCategoryInterface", inversedBy="productFamilies")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface", inversedBy="productFamilies")
          */
         protected $productCategories;
 
         protected $quantityLabel;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\ProductInterface", mappedBy="productFamily", orphanRemoval=true, cascade={"persist"})
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductInterface", mappedBy="productFamily", orphanRemoval=true, cascade={"persist"})
          * @ORM\OrderBy({"position" = "ASC"})
          */
         protected $products;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\TaxRateInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Common\TaxRateInterface")
          */
         protected $supplierTaxRate;
 
         protected $saleStatus;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\SectionInterface", inversedBy="productFamilies")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Section\SectionInterface", inversedBy="productFamilies")
          */
         protected $sections;
 
                 return $this;
         }
         /**
-         * @return Collection|ProductCategory[]
+         * @return Collection|ProductCategoryModel[]
          */
         public function getProductCategories(): Collection
         {
                 $this->productCategories = new ArrayCollection();
         }
 
-        public function addProductCategory(ProductCategory $productCategory): self
+        public function addProductCategory(ProductCategoryModel $productCategory): self
         {
                 if (!$this->productCategories->contains($productCategory)) {
                         $this->productCategories[] = $productCategory;
                 return $this;
         }
 
-        public function removeProductCategory(ProductCategory $productCategory): self
+        public function removeProductCategory(ProductCategoryModel $productCategory): self
         {
                 if ($this->productCategories->contains($productCategory)) {
                         $this->productCategories->removeElement($productCategory);

Model/Product/ProductInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Product;
 
 interface ProductInterface
 {

Model/Product/Product.php → Model/Product/ProductModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Product;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\OrderProductInterface;
-use Lc\ShopBundle\Context\PriceInterface;
-use Lc\ShopBundle\Context\ProductInterface;
-use Lc\ShopBundle\Context\ProductPropertyInterface;
-use Lc\ShopBundle\Context\SortableInterface;
-use Lc\ShopBundle\Services\Price;
+use Lc\CaracoleBundle\Model\Order\OrderProductInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\PriceInterface;
+use Lc\CaracoleBundle\Model\Product\ProductInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\ProductPropertyInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\SortableInterface;
+use Lc\CaracoleBundle\Services\Price;
 use Gedmo\Mapping\Annotation as Gedmo;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Product extends AbstractEntity implements SortableInterface, ProductPropertyInterface, PriceInterface
+abstract class ProductModel extends AbstractEntity implements SortableInterface, ProductPropertyInterface, PriceInterface
 {
         use SortableTrait;
         use ProductPropertyTrait;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\ProductFamilyInterface", inversedBy="products",  cascade={"persist"})
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Product\ProductFamilyInterface", inversedBy="products",  cascade={"persist"})
          * @ORM\JoinColumn(nullable=false)
          */
         protected $productFamily;
         public function getAvailableQuantityInherited()
         {
                 switch ($this->getProductFamily()->getBehaviorCountStock()) {
-                        case ProductFamily::BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY :
-                        case ProductFamily::BEHAVIOR_COUNT_STOCK_BY_MEASURE :
+                        case ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY :
+                        case ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_MEASURE :
                                 return $this->getProductFamily()->getAvailableQuantity();
                                 break;
-                        case ProductFamily::BEHAVIOR_COUNT_STOCK_BY_PRODUCT :
+                        case ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT :
                                 return $this->getAvailableQuantity();
                                 break;
-                        case ProductFamily::BEHAVIOR_COUNT_STOCK_UNLIMITED :
+                        case ProductFamilyModel::BEHAVIOR_COUNT_STOCK_UNLIMITED :
                                 return false;
                                 break;
                 }
                 return $this->getProductFamily()->getTaxRateInherited();
         }
 
-        public function getProductFamily(): ?ProductFamily
+        public function getProductFamily(): ?ProductFamilyModel
         {
                 return $this->productFamily;
         }
 
-        public function setProductFamily(?ProductFamily $productFamily): self
+        public function setProductFamily(?ProductFamilyModel $productFamily): self
         {
                 $this->productFamily = $productFamily;
 

Model/Reduction/ReductionCartInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Reduction;
 
 use Doctrine\Common\Collections\Collection;
-use Lc\ShopBundle\Model\PointSale;
+use Lc\CaracoleBundle\Model\PointSale;
 
 interface ReductionCartInterface
 {

Model/Reduction/ReductionCart.php → Model/Reduction/ReductionCartModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Reduction;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Context\OrderAmountMinInterface;
-use Lc\ShopBundle\Context\ReductionCartPropertyInterface;
-use Lc\ShopBundle\Context\ReductionInterface;
-use Lc\ShopBundle\Context\ReductionPropertyInterface;
-use Lc\ShopBundle\Context\StatusInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\OrderAmountMinInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\ReductionCartPropertyInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\ReductionPropertyInterface;
+use Lc\SovBundle\Doctrine\Extension\StatusInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class ReductionCart extends AbstractEntity implements ReductionPropertyInterface, ReductionInterface, ReductionCartPropertyInterface, FilterMerchantInterface, OrderAmountMinInterface, StatusInterface
+abstract class ReductionCartModel extends AbstractEntity implements ReductionPropertyInterface, ReductionInterface, ReductionCartPropertyInterface, FilterMerchantInterface, OrderAmountMinInterface, StatusInterface
 {
 
         const APPLIED_TO_DELIVERY = 'delivery';
         protected $title;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
         protected $availableQuantityPerUser;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\PointSaleInterface")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\PointSale\PointSaleInterface")
          */
         protected $pointSales;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ReductionCartInterface")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Reduction\ReductionCartInterface")
          */
         protected $uncombinables;
 

Model/Reduction/ReductionCatalogInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Reduction;
 
 interface ReductionCatalogInterface
 {

Model/Reduction/ReductionCatalog.php → Model/Reduction/ReductionCatalogModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Reduction;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Context\ReductionCatalogInterface;
-use Lc\ShopBundle\Context\ReductionInterface;
-use Lc\ShopBundle\Context\ReductionPropertyInterface;
-use Lc\ShopBundle\Context\StatusInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionCatalogInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\ReductionPropertyInterface;
+use Lc\SovBundle\Doctrine\Extension\StatusInterface;
 use phpDocumentor\Reflection\Types\Integer;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class ReductionCatalog extends AbstractEntity implements ReductionCatalogInterface, ReductionPropertyInterface, FilterMerchantInterface, StatusInterface
+abstract class ReductionCatalogModel extends AbstractEntity implements ReductionCatalogInterface, ReductionPropertyInterface, FilterMerchantInterface, StatusInterface
 {
         use StatusTrait;
         use ReductionTrait;
         protected $title;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ProductFamilyInterface")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductFamilyInterface")
          */
         protected $productFamilies;
 
         /**
-         * @ORM\OneToOne(targetEntity="Lc\ShopBundle\Context\ProductFamilyInterface")
+         * @ORM\OneToOne(targetEntity="Lc\CaracoleBundle\Model\Product\ProductFamilyInterface")
          */
         protected $productFamily;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ProductCategoryInterface")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface")
          */
         protected $productCategories;
 

Model/Reduction/ReductionCreditInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Reduction;
 
 interface ReductionCreditInterface
 {

Model/Reduction/ReductionCredit.php → Model/Reduction/ReductionCreditModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Reduction;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Context\ReductionInterface;
-use Lc\ShopBundle\Context\ReductionPropertyInterface;
-use Lc\ShopBundle\Context\StatusInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionInterface;
+use Lc\CaracoleBundle\Model\Reduction\ReductionPropertyInterface;
+use Lc\SovBundle\Doctrine\Extension\StatusInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class ReductionCredit extends AbstractEntity implements ReductionInterface, FilterMerchantInterface, StatusInterface
+abstract class ReductionCreditModel extends AbstractEntity implements ReductionInterface, FilterMerchantInterface, StatusInterface
 {
         const TYPE_CREDIT = 'credit';
         const TYPE_GIFT = 'gift';
         protected $title;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\UserInterface", inversedBy="reductionCredits")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", inversedBy="reductionCredits")
          */
         protected $users;
 
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
         protected $sended;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          */
         protected $owner;
 

Model/Reminder/ReminderInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Reminder;
 
 interface ReminderInterface
 {

Model/Reminder/Reminder.php → Model/Reminder/ReminderModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Reminder;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Reminder extends AbstractEntity implements FilterMerchantInterface
+abstract class ReminderModel extends AbstractEntity implements FilterMerchantInterface
 {
         public $relatedPage;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
         protected $entityAction;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          */
         protected $users;
 

Model/Section/SectionInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Section;
 
 interface SectionInterface
 {

Model/Section/Section.php → Model/Section/SectionModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Section;
 
 use App\Entity\Hub;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Section extends AbstractDocumentEntity implements FilterMerchantInterface
+abstract class SectionModel extends AbstractDocumentEntity implements FilterMerchantInterface
 {
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
         const SECTION_CYCLE_YEAR = 'year' ;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ProductFamilyInterface", mappedBy="sections")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductFamilyInterface", mappedBy="sections")
          */
         protected $productFamilies;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", mappedBy="section")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", mappedBy="section")
          */
         protected $orderShops;
 
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\ProductCategoryInterface", mappedBy="section")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductCategoryInterface", mappedBy="section")
          */
         protected $productCategories;
 

Model/Site/NewsInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context ;
+namespace Lc\CaracoleBundle\Model\Site ;
 
 interface NewsInterface
 {

Model/Site/News.php → Model/Site/NewsModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Site;
 
 use App\Entity\Hub;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Model\AbstractDocumentEntity;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Model\AbstractDocumentEntity;
 use Gedmo\Mapping\Annotation as Gedmo;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class News extends AbstractDocumentEntity implements FilterMerchantInterface
+abstract class NewsModel extends AbstractDocumentEntity implements FilterMerchantInterface
 {
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="news")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="news")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;

Model/Site/PageInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\Site;
 
 interface PageInterface
 {

Model/Site/Page.php → Model/Site/PageModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Site;
 
 use App\Entity\Hub;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Page extends AbstractDocumentEntity implements FilterMerchantInterface
+abstract class PageModel extends AbstractDocumentEntity implements FilterMerchantInterface
 {
         /**
          * @ORM\Column(type="text", nullable=true)
         protected $content;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="pages")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="pages")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;

Model/Ticket/TicketInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context ;
+namespace Lc\CaracoleBundle\Model\Ticket ;
 
 interface TicketInterface
 {

Model/Ticket/TicketMessageInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context ;
+namespace Lc\CaracoleBundle\Model\Ticket ;
 
 interface TicketMessageInterface
 {

Model/Ticket/TicketMessage.php → Model/Ticket/TicketMessageModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Ticket;
 
-use App\Entity\Ticket;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\TicketInterface;
+use Lc\CaracoleBundle\Model\Ticket\TicketInterface;
 use Gedmo\Mapping\Annotation as Gedmo;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class TicketMessage extends AbstractEntity
+abstract class TicketMessageModel extends AbstractEntity
 {
         use StatusTrait;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;
         protected $message;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\TicketInterface", inversedBy="ticketMessages")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Ticket\TicketInterface", inversedBy="ticketMessages")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $ticket;

Model/Ticket/Ticket.php → Model/Ticket/TicketModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\Ticket;
 
 use App\Entity\TicketMessage;
 use App\Entity\User;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
-use Lc\ShopBundle\Context\MerchantInterface;
-use Lc\ShopBundle\Context\OrderShopInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
+use Lc\CaracoleBundle\Model\Order\OrderShopInterface;
 use Gedmo\Mapping\Annotation as Gedmo;
-use Lc\ShopBundle\Context\UserInterface;
+use Lc\CaracoleBundle\Model\User\UserInterface;
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Ticket extends AbstractEntity implements FilterMerchantInterface
+abstract class TicketModel extends AbstractEntity implements FilterMerchantInterface
 {
         const TYPE_PRODUCT_UNAVAILABLE = 'product-unavailable' ;
         const TYPE_PRODUCT_ERROR = 'product-error' ;
 
         /**
          * @Gedmo\Blameable(on="create")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $createdBy;
 
         /**
          * @Gedmo\Blameable(on="update")
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface")
          * @ORM\JoinColumn(nullable=true)
          */
         protected $updatedBy;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
         protected $status;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", inversedBy="tickets")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", inversedBy="tickets")
          */
         protected $orderShop;
 
         protected $visitorToken;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\TicketMessageInterface", mappedBy="ticket", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Ticket\TicketMessageInterface", mappedBy="ticket", orphanRemoval=true)
          * @ORM\OrderBy({"id" = "ASC"})
          */
         protected $ticketMessages;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface", inversedBy="tickets")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", inversedBy="tickets")
          */
         protected $user;
 

Model/User/GroupUserInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\User;
 
 interface GroupUserInterface
 {

Model/User/GroupUser.php → Model/User/GroupUserModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\User;
 
 use Doctrine\ORM\Mapping as ORM;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 
 
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class GroupUser extends AbstractDocumentEntity implements FilterMerchantInterface
+abstract class GroupUserModel extends AbstractDocumentEntity implements FilterMerchantInterface
 {
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface", inversedBy="groupUsers")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface", inversedBy="groupUsers")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\UserInterface", mappedBy="groupUsers")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", mappedBy="groupUsers")
          */
         protected $users;
 
         }
 
         /**
-         * @return Collection|User[]
+         * @return Collection|UserModel[]
          */
         public function getUsers(): Collection
         {
             return $this->users;
         }
 
-        public function addUser(User $user): self
+        public function addUser(UserModel $user): self
         {
             if (!$this->users->contains($user)) {
                 $this->users[] = $user;
             return $this;
         }
 
-        public function removeUser(User $user): self
+        public function removeUser(UserModel $user): self
         {
             if ($this->users->contains($user)) {
                 $this->users->removeElement($user);

Model/User/UserInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\User;
 
 interface UserInterface
 {

Model/User/UserMerchantInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\User;
 
 interface UserMerchantInterface
 {

Model/User/UserMerchant.php → Model/User/UserMerchantModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\User;
 
 use App\Entity\CreditHistory;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
-use Lc\ShopBundle\Context\CreditHistoryInterface;
-use Lc\ShopBundle\Context\FilterMerchantInterface;
+use Lc\CaracoleBundle\Model\Credit\CreditHistoryInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
 
 /**
  * @ORM\MappedSuperclass()
  *
  */
-abstract class UserMerchant implements FilterMerchantInterface
+abstract class UserMerchantModel implements FilterMerchantInterface
 {
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface", inversedBy="userMerchants")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", inversedBy="userMerchants")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $user;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          * @ORM\JoinColumn(nullable=false)
          */
         protected $merchant;
         protected $creditActive;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\CreditHistoryInterface", mappedBy="userMerchant", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Credit\CreditHistoryInterface", mappedBy="userMerchant", orphanRemoval=true)
          */
         protected $creditHistories;
 
                 $this->creditHistories = new ArrayCollection();
         }
 
-        public function getUser(): ?User
+        public function getUser(): ?UserModel
         {
                 return $this->user;
         }
 
-        public function setUser(?User $user): self
+        public function setUser(?UserModel $user): self
         {
                 $this->user = $user;
 

Model/User/User.php → Model/User/UserModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\User;
 
 use App\Entity\Newsletter;
 use App\Entity\Ticket;
 use Doctrine\ORM\Mapping as ORM;
 use Gedmo\Mapping\Annotation as Gedmo;
 use Lc\SovBundle\Model\User\User as SovUserModel;
-use Lc\ShopBundle\Context\MerchantInterface;
-use Lc\ShopBundle\Context\TicketInterface;
+use Lc\CaracoleBundle\Model\Merchant\MerchantInterface;
+use Lc\CaracoleBundle\Model\Ticket\TicketInterface;
 
 /**
  * @ORM\MappedSuperclass()
  *
  */
-abstract class User extends SovUserModel
+abstract class UserModel extends SovUserModel
 {
         /**
          * @ORM\Column(type="string", length=20, nullable=true)
         protected $behaviorDisplayPrice;
 
         /**
-         * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\MerchantInterface")
+         * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
          */
         protected $merchant;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\AddressInterface", mappedBy="user", cascade={"persist"})
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Address\AddressInterface", mappedBy="user", cascade={"persist"})
          */
         protected $addresses;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\OrderShopInterface", mappedBy="user")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShopInterface", mappedBy="user")
          */
         protected $orders;
 
         protected $gender;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\NewsletterInterface", inversedBy="users")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Newsletter\NewsletterInterface", inversedBy="users")
          */
         protected $newsletters;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\GroupUserInterface", inversedBy="users")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\User\GroupUserInterface", inversedBy="users")
          */
         protected $groupUsers;
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ProductFamilyInterface")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Product\ProductFamilyInterface")
          */
         protected $favoriteProductFamilies;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\UserPointSaleInterface", mappedBy="user", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\User\UserPointSaleInterface", mappedBy="user", orphanRemoval=true)
          */
         protected $userPointSales;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\UserMerchantInterface", mappedBy="user", orphanRemoval=true)
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\User\UserMerchantInterface", mappedBy="user", orphanRemoval=true)
          */
         protected $userMerchants;
 
         /**
-         * @ORM\OneToMany(targetEntity="Lc\ShopBundle\Context\TicketInterface", mappedBy="user")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Ticket\TicketInterface", mappedBy="user")
          */
         protected $tickets;
 
 
 
         /**
-         * @ORM\ManyToMany(targetEntity="Lc\ShopBundle\Context\ReductionCreditInterface", mappedBy="users")
+         * @ORM\ManyToMany(targetEntity="Lc\CaracoleBundle\Model\Reduction\ReductionCreditInterface", mappedBy="users")
          */
         protected $reductionCredits;
 
         }
 
         /**
-         * @return Collection|GroupUser[]
+         * @return Collection|GroupUserModel[]
          */
         public function getGroupUsers(): Collection
         {
                 return $this->groupUsers;
         }
 
-        public function addGroupUser(GroupUser $groupUser): self
+        public function addGroupUser(GroupUserModel $groupUser): self
         {
                 if (!$this->groupUsers->contains($groupUser)) {
                         $this->groupUsers[] = $groupUser;
                 return $this;
         }
 
-        public function removeGroupUser(GroupUser $groupUser): self
+        public function removeGroupUser(GroupUserModel $groupUser): self
         {
                 if ($this->groupUsers->contains($groupUser)) {
                         $this->groupUsers->removeElement($groupUser);
         }
 
         /**
-         * @return Collection|UserPointSale[]
+         * @return Collection|UserPointSaleModel[]
          */
         public function getUserPointSales(): Collection
         {

Model/User/UserPointSaleInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\User;
 
 interface UserPointSaleInterface
 {

Model/User/UserPointSale.php → Model/User/UserPointSaleModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\User;
 
 use Doctrine\ORM\Mapping as ORM;
 
 /**
  * @ORM\MappedSuperclass
  */
-abstract class UserPointSale
+abstract class UserPointSaleModel
 {
     /**
-     * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\UserInterface", inversedBy="userPointSales")
+     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\User\UserInterface", inversedBy="userPointSales")
      * @ORM\JoinColumn(nullable=false)
      */
     protected $user;
 
     /**
-     * @ORM\ManyToOne(targetEntity="Lc\ShopBundle\Context\PointSaleInterface", inversedBy="userPointSales")
+     * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\PointSale\PointSaleInterface", inversedBy="userPointSales")
      * @ORM\JoinColumn(nullable=false)
      */
     protected $pointSale;
      */
     protected $comment;
 
-    public function getUser(): ?User
+    public function getUser(): ?UserModel
     {
         return $this->user;
     }
 
-    public function setUser(?User $user): self
+    public function setUser(?UserModel $user): self
     {
         $this->user = $user;
 

Model/User/UserUtilsInterface.php

-<?php
-
-namespace Lc\ShopBundle\Context;
-
-interface UserUtilsInterface
-{
-
-}

Model/User/VisitorInterface.php

 <?php
 
-namespace Lc\ShopBundle\Context;
+namespace Lc\CaracoleBundle\Model\User;
 
 interface VisitorInterface
 {

Model/User/Visitor.php → Model/User/VisitorModel.php

 <?php
 
-namespace Lc\ShopBundle\Model;
+namespace Lc\CaracoleBundle\Model\User;
 
 use App\Entity\OrderShop;
 use Doctrine\Common\Collections\ArrayCollection;
 /**
  * @ORM\MappedSuperclass()
  */
-abstract class Visitor
+abstract class VisitorModel
 {
         /**
          * @ORM\Column(type="string", length=255)
         protected $totalVisit;
 
         /**
-         * @ORM\OneToMany(targetEntity="App\Entity\OrderShop", mappedBy="visitor")
+         * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Order\OrderShop", mappedBy="visitor")
          */
         protected $orders;