Merge branch 'develop'

Controller/AbstractAdminController.php

 
 namespace Lc\CaracoleBundle\Controller;
 
+use EasyCorp\Bundle\EasyAdminBundle\Collection\FieldCollection;
+use EasyCorp\Bundle\EasyAdminBundle\Collection\FilterCollection;
+use EasyCorp\Bundle\EasyAdminBundle\Config\Option\EA;
+use EasyCorp\Bundle\EasyAdminBundle\Context\AdminContext;
+use EasyCorp\Bundle\EasyAdminBundle\Contracts\Controller\CrudControllerInterface;
+use EasyCorp\Bundle\EasyAdminBundle\Dto\FieldDto;
+use EasyCorp\Bundle\EasyAdminBundle\Factory\ControllerFactory;
+use EasyCorp\Bundle\EasyAdminBundle\Field\AssociationField;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterMerchantInterface;
+use Lc\CaracoleBundle\Doctrine\Extension\FilterSectionInterface;
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\SovBundle\Controller\AbstractAdminController as SovAbstractAdminController;
+use Lc\SovBundle\Definition\ActionDefinition;
+use Lc\SovBundle\Doctrine\Extension\StatusInterface;
+use Lc\SovBundle\Field\Filter\FilterManager;
+use Lc\SovBundle\Repository\EntityRepository;
+use Symfony\Component\HttpFoundation\JsonResponse;
 
 abstract class AbstractAdminController extends SovAbstractAdminController
 {
     use AdminControllerTrait;
+
+    public function autocompleteFilter(AdminContext $context): JsonResponse
+    {
+        $repositoryQuery = $this->get(EntityRepository::class)->createRepositoryQuery(
+            $this->getRepositoryQuery(),
+            $context->getSearch(),
+            $context->getEntity(),
+            FieldCollection::new([]),
+            FilterCollection::new()
+        );
+
+        if ($this->isInstanceOf(StatusInterface::class)) {
+            $repositoryQuery->filterIsOnlineAndOffline();
+        }
+        if ($this->isInstanceOf(FilterSectionInterface::class)) {
+            $repositoryQuery->filterBySection($this->getSectionCurrent());
+        }
+
+        if ($this->isInstanceOf(FilterMerchantInterface::class)) {
+            $repositoryQuery->filterByMerchant($this->getMerchantCurrent());
+        }
+
+        $autocompleteContext = $context->getRequest()->get(AssociationField::PARAM_AUTOCOMPLETE_CONTEXT);
+
+        /** @var CrudControllerInterface $controller */
+        $controller = $this->get(ControllerFactory::class)->getCrudControllerInstance(
+            $autocompleteContext[EA::CRUD_CONTROLLER_FQCN],
+            ActionDefinition::INDEX,
+            $context->getRequest()
+        );
+        /** @var FieldDto $field */
+        $field = FieldCollection::new(
+            $controller->configureFields($autocompleteContext['originatingPage'])
+        )->getByProperty($autocompleteContext['propertyName']);
+
+        $filterManager = $this->get(FilterManager::class);
+        $filteredValue = ['value' => $context->getRequest()->query->get('q')];
+        $filterManager->applyFilter($repositoryQuery, $field, $filteredValue);
+        $repositoryQuery->select('.' . $autocompleteContext['propertyName']);
+        //dump($repositoryQuery->getQueryBuilder()->getQuery()->getDQL());
+
+        $responses = array();
+        foreach ($repositoryQuery->find() as $result) {
+            $responses[] = array_values($result)[0];
+        }
+
+        return JsonResponse::fromJsonString(json_encode($responses));
+    }
 }

Definition/Field/Product/ProductCategoryFieldDefinition.php

         return [
                 'main',
                 'seo',
+                'opengraph',
                 'conf'
         ];
     }

Model/User/UserModel.php

      */
     protected $isSaleAlwaysOpen;
 
-
     /**
      * @ORM\ManyToOne(targetEntity="Lc\CaracoleBundle\Model\Merchant\MerchantInterface")
      */
     protected $favoriteMerchant;
 
-    /**
-     * @ORM\Column(type="datetime", nullable=true)
-     */
-    protected $lastLogin;
-
     /**
      * @ORM\OneToMany(targetEntity="Lc\CaracoleBundle\Model\Address\AddressInterface", mappedBy="user", cascade={"persist"})
      */
         return $this;
     }
 
-    public function getLastLogin()
-    {
-        return $this->lastLogin;
-    }
-
-    public function setLastLogin(\DateTime $time = null)
-    {
-        $this->lastLogin = $time;
-
-        return $this;
-    }
-
-
     /**
      * @return Collection|AddressInterface[]
      */

Repository/Product/ProductFamilyStore.php

     }
 
     public function getByParentCategory(
-        ProductCategoryInterface $parentCategory,
-                                 $user = null,
-                                 $query = null
-    )
-    {
+            ProductCategoryInterface $parentCategory,
+            $user = null,
+            $query = null
+    ) {
         $productFamiliesArray = [];
 
         foreach ($parentCategory->getChildrens() as $i => $category) {
-            $productFamiliesCategory = $this->getByCategory($category, $query);
+            $productFamiliesCategory = $this->getByCategory($category);
             foreach ($productFamiliesCategory as $productFamily) {
                 $productFamiliesArray[$productFamily->getId()] = $productFamily;
             }
+            uasort($productFamiliesArray, array($this, 'compMethodSortProductFamiliesByPosition'));
         }
 
         return $this->getWithReductions($productFamiliesArray, $user, true);
     }
 
+    private function compMethodSortProductFamiliesByPosition($a, $b)
+    {
+        return $a->getPosition() > $b->getPosition();
+    }
+
     // getProductFamiliesByCategory
     public function getByCategory(
-        ProductCategoryInterface $productCategory,
-                                 $query = null
-    )
-    {
+            ProductCategoryInterface $productCategory,
+            $query = null
+    ) {
         $query = $this->createDefaultQuery($query);
 
         $query
-            ->filterIsOnline()
-            ->filterByProductCategory($productCategory);
+                ->filterIsOnline()
+                ->filterByProductCategory($productCategory);
 
         return $query->find();
     }
 
     //TODO ajouter status en donné de contexte pour éviter ce truc
     public function getByCategoryOnlineAndOffline(
-        ProductCategoryInterface $productCategory,
-                                 $query = null
-    )
-    {
+            ProductCategoryInterface $productCategory,
+            $query = null
+    ) {
         $query = $this->createDefaultQuery($query);
 
         $query
-            ->filterByProductCategory($productCategory);
+                ->filterByProductCategory($productCategory);
 
         return $query->find();
     }
         $query = $this->createDefaultQuery($query);
 
         $query
-            ->filterByPropertyNoveltyExpirationDate()
-            ->filterIsOnline();
+                ->filterByPropertyNoveltyExpirationDate()
+                ->filterIsOnline();
 
         $results = $query->find();
 
         $query = $this->createDefaultQuery($query);
 
         $query
-            ->filterIsOrganicLabel()
-            ->filterIsOnline();
+                ->filterIsOrganicLabel()
+                ->filterIsOnline();
 
         $results = $query->find();
 
     {
         if ($user) {
             return $this->getWithReductions(
-                $user->getFavoriteProductFamilies(),
-                $user,
-                false,
-                $organizeByParentCategory
+                    $user->getFavoriteProductFamilies(),
+                    $user,
+                    false,
+                    $organizeByParentCategory
             );
         }
 
 
     // findByTerms
     public function getByTerms(
-        $terms,
-        $maxResults = false,
-        $organizeByParentCategory = false,
-        $user = null,
-        $query = null
-    )
-    {
+            $terms,
+            $maxResults = false,
+            $organizeByParentCategory = false,
+            $user = null,
+            $query = null
+    ) {
         $query = $this->createDefaultQuery($query);
 
         $query->filterIsOnline();
     }
 
     public function getBestReductionCatalog(
-        ProductFamilyInterface    $productFamily,
-        ReductionCatalogInterface $reductionCatalog1,
-        ReductionCatalogInterface $reductionCatalog2
-    )
-    {
+            ProductFamilyInterface $productFamily,
+            ReductionCatalogInterface $reductionCatalog1,
+            ReductionCatalogInterface $reductionCatalog2
+    ) {
         $price1 = $this->priceSolver->getPriceWithTaxByReduction(
-            $productFamily,
-            $reductionCatalog1
+                $productFamily,
+                $reductionCatalog1
         );
         $price2 = $this->priceSolver->getPriceWithTaxByReduction(
-            $productFamily,
-            $reductionCatalog2
+                $productFamily,
+                $reductionCatalog2
         );
 
 
 
     // setReductionForProductFamilies
     public function getWithReductions(
-        $productFamilies,
-        UserInterface $user = null,
-        $organizeByCategory = false,
-        $organizeByParentCategory = false,
-        $onlyOnDiscount = false
-    )
-    {
+            $productFamilies,
+            UserInterface $user = null,
+            $organizeByCategory = false,
+            $organizeByParentCategory = false,
+            $onlyOnDiscount = false
+    ) {
         $conditions = [
-            'productFamiliesIds' => [],
-            'categories' => [],
-            'productFamilies' => [],
+                'productFamiliesIds' => [],
+                'categories' => [],
+                'productFamilies' => [],
         ];
 
         foreach ($productFamilies as $productFamily) {
             $conditions['productFamiliesIds'][] = $productFamily->getId();
             $conditions['productFamilies'][] = $productFamily;
             $conditions['categories'] = array_merge(
-                $conditions['categories'],
-                $productFamily->getProductCategories()->toArray()
+                    $conditions['categories'],
+                    $productFamily->getProductCategories()->toArray()
             );
         }
 
         if ($productFamilies) {
             $reductionCatalogs = $this->reductionCatalogStore->getByProductFamiliesConditions(
-                $conditions,
-                $user
+                    $conditions,
+                    $user
             );
         }
 
                 $conditionProductFamilies = $conditionProductFamily = $conditionProductCategory = false;
 
                 if ($reductionCatalog->getProductFamilies()->contains(
-                        $productFamily
-                    ) || $reductionCatalog->getProductFamilies()->isEmpty()) {
+                                $productFamily
+                        ) || $reductionCatalog->getProductFamilies()->isEmpty()) {
                     $conditionProductFamilies = true;
                 }
 
-                if ($reductionCatalog->getProductFamily() == $productFamily || $reductionCatalog->getProductFamily() === null) {
+                if ($reductionCatalog->getProductFamily() == $productFamily || $reductionCatalog->getProductFamily(
+                        ) === null) {
                     $conditionProductFamily = true;
                 }
 
                 foreach ($productFamily->getProductCategories() as $productCategory) {
                     if ($reductionCatalog->getProductCategories()->contains(
-                            $productCategory
-                        ) || $reductionCatalog->getProductCategories()->isEmpty()) {
+                                    $productCategory
+                            ) || $reductionCatalog->getProductCategories()->isEmpty()) {
                         $conditionProductCategory = true;
                     }
                 }
                 if ($conditionProductFamilies && $conditionProductFamily && $conditionProductCategory) {
                     if ($productFamily->getReductionCatalog()) {
                         $productFamily->setReductionCatalog(
-                            $this->getBestReductionCatalog(
-                                $productFamily,
-                                $reductionCatalog,
-                                $productFamily->getReductionCatalog()
-                            )
+                                $this->getBestReductionCatalog(
+                                        $productFamily,
+                                        $reductionCatalog,
+                                        $productFamily->getReductionCatalog()
+                                )
                         );
                     } else {
                         $productFamily->setReductionCatalog($reductionCatalog);
 
             if (($onlyOnDiscount && $productFamily->getReductionCatalog()) || !$onlyOnDiscount) {
                 if ($organizeByParentCategory) {
-
                     $productCategories = $productFamily->getProductCategories();
 
                     if ($productCategories && count($productCategories) > 0) {
                         if ($this->productCategorySolver->isDisplay($parentCategory, $user)) {
                             if (!isset($productFamiliesToReturn[$parentCategory->getId()])) {
                                 $productFamiliesToReturn[$parentCategory->getId()] = [
-                                    'category' => $parentCategory,
-                                    'products' => []
+                                        'category' => $parentCategory,
+                                        'products' => []
                                 ];
                             }
                             $productFamiliesToReturn[$parentCategory->getId()]['products'][] = $productFamily;

Resolver/MerchantResolver.php

 use Lc\SovBundle\Solver\Setting\SettingSolver;
 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 use Symfony\Component\HttpFoundation\RequestStack;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
 use Symfony\Component\Security\Core\Security;
 
             return $this->currentMerchant;
         }
         else {
-            throw new \ErrorException('Aucun merchant courant');
+            throw new NotFoundHttpException('Aucun marchand n\'est défini');
         }
     }
 

Resolver/OpeningResolver.php

 
         $dateOpeningNextSale = $this->getFormatedDateOpeningNextSale($section);
         if ($dateOpeningNextSale && strlen($dateOpeningNextSale) > 0) {
-            return 'Réouverture aux commandes le <u>'.$dateOpeningNextSale.'</u>' ;
+            return 'Réouverture aux commandes le  <span class="underline">'.$dateOpeningNextSale.'</span>' ;
         }
 
         return null;

Solver/Order/OrderShopSolver.php

 
         return $orderShop;
     }
-
+    public function refreshOrderShops(array $orderShops): array
+    {
+        foreach ($orderShops as $orderShop) {
+            foreach ($orderShop->getOrderProducts() as $orderProduct) {
+                $this->entityManager->refresh($orderProduct);
+            }
+            $this->entityManager->refresh($orderShop);
+        }
+        return $orderShops;
+    }
     public function isReductionCreditAddedToOrder(
             OrderShopInterface $orderShop,
             ReductionCreditInterface $reductionCredit