Refactoring repositoryQuery id d'entité

Repository/Address/AddressRepositoryQuery.php

 
     public function __construct(AddressRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'address', $paginator);
     }
 
     public function filterByUser(UserInterface $user)

Repository/Config/TaxRateRepositoryQuery.php

 {
     public function __construct(TaxRateRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'taxRate', $paginator);
     }
 }

Repository/Config/UnitRepositoryQuery.php

 {
     public function __construct(UnitRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'unit', $paginator);
     }
 }

Repository/Credit/CreditHistoryRepositoryQuery.php

 
     public function __construct(CreditHistoryRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'creditHistory', $paginator);
     }
 
     public function joinUserMerchant(): self
             $this->isJoinUserMerchants = true;
 
             return $this
-                ->innerJoin('.userMerchant', 'um');
+                ->innerJoin('.userMerchant', 'userMerchant');
         }
         return $this;
     }
     {
         $this->joinUserMerchant();
         return $this
-            ->andWhereMerchant('um', $merchant);
+            ->andWhereMerchant('userMerchant', $merchant);
     }
 
     public function filterByUserMerchant(UserMerchantInterface $userMerchant): self

Repository/Distribution/DistributionRepositoryQuery.php

 
     public function __construct(DistributionRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'd', $paginator);
+        parent::__construct($repository, 'distribution', $paginator);
     }
 
     public function filterByYear(int $year): self

Repository/File/DocumentRepositoryQuery.php

 
     public function __construct(DocumentRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'document', $paginator);
     }
 
     public function filterByType($type)

Repository/Merchant/MerchantRepositoryQuery.php

 {
     public function __construct(MerchantRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'merchant', $paginator);
     }
 
 }

Repository/Order/OrderPaymentRepositoryQuery.php

 {
     public function __construct(OrderPaymentRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderPayment', $paginator);
     }
 }

Repository/Order/OrderProductReductionCatalogRepositoryQuery.php

 {
     public function __construct(OrderProductReductionCatalogRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderProductReductionCatalog', $paginator);
     }
 }

Repository/Order/OrderProductRefundRepositoryQuery.php

 {
     public function __construct(OrderProductRefundRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderProductRefund', $paginator);
     }
 }

Repository/Order/OrderProductRepositoryQuery.php

 
     public function __construct(OrderProductRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderProduct', $paginator);
     }
 
     public function filterByOrderShop(OrderShopInterface $orderShop): self
         $this->joinOrderStatus();
 
         return $this
-                ->andWhere('os.alias IN (:alias)')
+                ->andWhere('orderStatus.alias IN (:alias)')
                 ->setParameter('alias', $status);
     }
 
     public function selectCount(): self
     {
         return $this
-                ->select('count(r.id) as total');
+                ->select('count(orderProduct.id) as total');
     }
 
     public function joinProduct(): self
             $this->isJoinOrderStatus = true;
 
             return $this
-                    ->leftJoin('orderShop.orderStatus', 'os');
+                    ->leftJoin('orderShop.orderStatus', 'orderStatus');
         }
         return $this;
     }

Repository/Order/OrderReductionCartRepositoryQuery.php

 {
     public function __construct(OrderReductionCartRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderReductionCart', $paginator);
     }
 }

Repository/Order/OrderReductionCreditRepositoryQuery.php

 {
     public function __construct(OrderReductionCreditRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderReductionCredit', $paginator);
     }
 }

Repository/Order/OrderRefundRepositoryQuery.php

 {
     public function __construct(OrderRefundRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderRefund', $paginator);
     }
 }

Repository/Order/OrderShopRepositoryQuery.php

     protected bool $isJoinProduct = false;
     protected bool $isJoinDistribution = false;
     protected bool $isJoinProductFamily = false;
-    protected bool $isJoinOrderProduct = false;
+    protected bool $isJoinOrderProducts = false;
     protected bool $isJoinOrderReductionCredits = false;
     protected bool $isJoinOrderReductionCarts = false;
     protected bool $isJoinOrderStatus = false;
 
     public function __construct(OrderShopRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderShop', $paginator);
     }
 
 
     {
         return $this
                 ->select(
-                        'SUM(DISTINCT(r.statTotalWithTax)) as total'
+                        'SUM(DISTINCT(orderShop.statTotalWithTax)) as total'
                 );
     }
 
     public function selectSumQuantityOrder(): self
     {
-        $this->joinOrderProduct();
+        $this->joinOrderProducts();
         return $this
                 ->select(
-                        'SUM(orderProduct.quantityOrder) as quantity'
+                        'SUM(orderProducts.quantityOrder) as quantity'
                 );
     }
 
         $this->joinDistribution();
         return $this
                 ->select(
-                        'SUM(orderProduct.quantityOrder) as quantity, distribution.cycleNumber as cycleNumber, distribution.year as year , product.id as productId'
+                        'SUM(orderProducts.quantityOrder) as quantity, distribution.cycleNumber as cycleNumber, distribution.year as year , product.id as productId'
                 );
     }
 
     public function selectCountUser(): self
     {
         return $this
-                ->select('count(DISTINCT(r.user)) as total');
+                ->select('count(DISTINCT(orderShop.user)) as total');
     }
 
 
     public function selectCount(): self
     {
         return $this
-                ->select('count(DISTINCT(r.id)) as total');
+                ->select('count(DISTINCT(orderShop.id)) as total');
     }
 
     public function joinUser(): self
         $this->joinOrderStatus();
 
         return $this
-                ->andWhere('os.alias IN (:alias)')
+                ->andWhere('orderStatus.alias IN (:alias)')
                 ->setParameter('alias', $status);
     }
 
 
     public function filterByProducts(array $products): self
     {
-        $this->joinOrderProduct();
+        $this->joinOrderProducts();
 
         return $this
                 ->andWhere('product.id IN(:products)')
         $this->joinProduct();
 
         return $this
-                ->andWhere('orderProduct.product = :product')
+                ->andWhere('orderProducts.product = :product')
                 ->setParameter('product', $product);
     }
 
         $this->joinOrderStatus();
 
         return $this
-                ->andWhere('os.alias IN (:alias)')
+                ->andWhere('orderStatus.alias IN (:alias)')
                 ->setParameter('alias', $statusArray);
     }
 
         $this->joinOrderReductionCredits();
 
         return $this
-                ->andWhere('orc.reductionCredit = :reductionCredit')
+                ->andWhere('orderReductionCredits.reductionCredit = :reductionCredit')
                 ->setParameter('reductionCredit', $reductionCredit);
     }
 
         $this->joinOrderReductionCarts();
 
         return $this
-                ->andWhere('orcart.reductionCart = :reductionCart')
+                ->andWhere('orderReductionCarts.reductionCart = :reductionCart')
                 ->setParameter('reductionCart', $reductionCart);
     }
 
     {
         $this->joinOrderReductionCarts();
 
-        return $this->addSelect('orcart');
+        return $this->addSelect('orderReductionCarts');
     }
 
 
-    public function joinOrderProduct(bool $addSelect = false): self
+    public function joinOrderProducts(bool $addSelect = false): self
     {
-        if (!$this->isJoinOrderProduct) {
-            $this->isJoinOrderProduct = true;
+        if (!$this->isJoinOrderProducts) {
+            $this->isJoinOrderProducts = true;
 
-            $this->leftJoin('.orderProducts', 'orderProduct');
+            $this->leftJoin('.orderProducts', 'orderProducts');
 
             if ($addSelect) {
-                $this->addSelect('orderProduct');
+                $this->addSelect('orderProducts');
             }
         }
         return $this;
 
     public function joinProduct(bool $addSelect = false): self
     {
-        $this->joinOrderProduct($addSelect);
+        $this->joinOrderProducts($addSelect);
         if (!$this->isJoinProduct) {
             $this->isJoinProduct = true;
 
-            $this->leftJoin('orderProduct.product', 'product');
+            $this->leftJoin('orderProducts.product', 'product');
 
             if ($addSelect) {
                 $this->addSelect('product');
             $this->isJoinOrderReductionCredits = true;
 
             return $this
-                    ->innerJoin('.orderReductionCredits', 'orc');
+                    ->innerJoin('.orderReductionCredits', 'orderReductionCredits');
         }
         return $this;
     }
             $this->isJoinOrderStatus = true;
 
             return $this
-                    ->leftJoin('.orderStatus', 'os');
+                    ->leftJoin('.orderStatus', 'orderStatus');
         }
         return $this;
     }
             $this->isJoinOrderReductionCarts = true;
 
             return $this
-                    ->leftJoin('.orderReductionCarts', 'orcart');
+                    ->leftJoin('.orderReductionCarts', 'orderReductionCarts');
         }
         return $this;
     }
             $this->isJoinDeliveryPointSale = true;
 
             return $this
-                    ->leftJoin('.deliveryPointSale', 'pointSale');
+                    ->leftJoin('.deliveryPointSale', 'deliveryPointSale');
         }
         return $this;
     }

Repository/Order/OrderShopStore.php

 
     public function relationsDefault(RepositoryQueryInterface $query): RepositoryQueryInterface
     {
-        $query->joinOrderProduct(true);
+        $query->joinOrderProducts(true);
         return $query;
     }
 

Repository/Order/OrderStatusHistoryRepositoryQuery.php

 {
     public function __construct(OrderStatusHistoryRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderStatusHistory', $paginator);
     }
 }

Repository/Order/OrderStatusRepositoryQuery.php

 {
     public function __construct(OrderStatusRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'orderStatus', $paginator);
     }
 
     public function filterByAlias(string $alias)

Repository/PointSale/PointSaleRepositoryQuery.php

 
     public function __construct(PointSaleRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'pointSale', $paginator);
     }
 
     public function filterByUser(UserInterface $user): self

Repository/Product/ProductCategoryRepositoryQuery.php

 
     public function __construct(ProductCategoryRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'productCategory', $paginator);
     }
 
     public function joinProductFamilies(): self
             $this->isJoinProductFamilies = true;
 
             return $this
-                    ->innerJoin('.productFamilies', 'pf');
+                    ->innerJoin('.productFamilies', 'productFamilies');
         }
 
         return $this;
     {
         $this->joinProductFamilies();
 
-        return $this->andWhere('pf.status = 1');
+        return $this->andWhere('productFamilies.status = 1');
     }
 
 }

Repository/Product/ProductFamilyRepositoryQuery.php

 
     public function __construct(ProductFamilyRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'pf', $paginator);
+        parent::__construct($repository, 'productFamily', $paginator);
     }
 
     public function joinProductFamilySectionProperties(bool $addSelect = true): self
         if (!$this->isJoinProductFamilySectionProperties) {
             $this->isJoinProductFamilySectionProperties = true;
 
-            $this->leftJoin('.productFamilySectionProperties', 'pfsp');
+            $this->leftJoin('.productFamilySectionProperties', 'productFamilySectionProperties');
             if ($addSelect) {
-                $this->addSelect('pfsp');
+                $this->addSelect('productFamilySectionProperties');
             }
         }
         return $this;
         if (!$this->isJoinQualityLabels) {
             $this->isJoinQualityLabels = true;
 
-            $this->leftJoin('.qualityLabels', 'pfql');
+            $this->leftJoin('.qualityLabels', 'qualityLabels');
             if ($addSelect) {
-                $this->addSelect('pfql');
+                $this->addSelect('qualityLabels');
             }
         }
         return $this;
         if (!$this->isJoinSections) {
             $this->isJoinSections = true;
 
-            $this->leftJoin('pfsp.section', 'section');
+            $this->leftJoin('productFamilySectionProperties.section', 'section');
             if ($addSelect) {
                 $this->addSelect('section');
             }
         return $this;
     }
 
-    public function filterBySection(SectionInterface $section,bool $addSelectProductFamilySectionProperties = true)
+    public function filterBySection(SectionInterface $section, bool $addSelectProductFamilySectionProperties = true)
     {
         $this->joinProductFamilySectionProperties($addSelectProductFamilySectionProperties);
-        $this->andWhereSection('pfsp', $section);
-        $this->andWhere('pfsp.status = 1');
+        $this->andWhereSection('productFamilySectionProperties', $section);
+        $this->andWhere('productFamilySectionProperties.status = 1');
     }
 
     public function filterByMerchantViaSection(MerchantInterface $merchant)
         $this->joinProductFamilySectionProperties(false);
         $this->joinSections(false);
         $this->andWhereMerchant('section', $merchant);
-        $this->andWhere('pfsp.status = 1');
+        $this->andWhere('productFamilySectionProperties.status = 1');
     }
 
 
     public function selectCount(): self
     {
-        return $this->select('count(pf.id)');
+        return $this->select('count(productFamily.id)');
     }
 
     public function selectProductCategories(): self
     public function filterLikeBehaviorStockCycle(string $behaviorStockCycle): self
     {
         return $this
-                ->andWhere('.behaviorStockCycle LIKE :behaviorStockCycle')
-                ->setParameter('behaviorStockCycle', $behaviorStockCycle);
+            ->andWhere('.behaviorStockCycle LIKE :behaviorStockCycle')
+            ->setParameter('behaviorStockCycle', $behaviorStockCycle);
     }
 
     public function filterByProductCategory(ProductCategoryInterface $category): self
     {
         $this->joinProductCategories();
         return $this
-                ->andWhere(':category MEMBER OF .productCategories')
-                ->setParameter('category', $category->getId());
+            ->andWhere(':category MEMBER OF .productCategories')
+            ->setParameter('category', $category->getId());
     }
 
 
         }
 
         return $this->andWhere(':now <= .propertyNoveltyExpirationDate')
-                ->setParameter('now', $dateTime);
+            ->setParameter('now', $dateTime);
     }
 
     public function filterIsOrganicLabel(): self
     public function filterIsNovelty()
     {
         return $this->andWhere(':now <= .propertyNoveltyExpirationDate')
-                ->setParameter('now', new \DateTime()) ;
+            ->setParameter('now', new \DateTime());
     }
 
     public function filterByTerms($terms): self
     {
-        $this->andWhere('.title LIKE :terms OR cat.title LIKE :terms');
-        $this->setParameter(':terms', '%'.$terms.'%') ;
+        $this->andWhere('.title LIKE :terms OR productCategories.title LIKE :terms');
+        $this->setParameter(':terms', '%' . $terms . '%');
         return $this;
     }
 
         if (!$this->isJoinProductCategories) {
             $this->isJoinProductCategories = true;
 
-            return $this
-                    ->leftJoin('.productCategories', 'cat')
-                    ->addSelect('cat')
-                    ;
+            $this->leftJoin('.productCategories', 'productCategories');
+            if ($addSelect) {
+                $this->addSelect('productCategories');
+            }
+            return $this;
         }
         return $this;
     }
 
     public function selectProducts(): self
     {
-        $this->joinProducts();
-
-        return $this->addSelect('products');
+        return $this->joinProducts(true);
     }
 
-    public function joinProducts(): self
+    public function joinProducts(bool $addSelect = true): self
     {
         if (!$this->isJoinProducts) {
             $this->isJoinProducts = true;
 
-            return $this
-                    ->innerJoin('.products', 'pfp')
-                    ->addSelect('pfp')
-                    ;
+            $this->innerJoin('.products', 'products');
+            if ($addSelect) {
+                $this->addSelect('products');
+            }
         }
         return $this;
     }

Repository/Product/ProductFamilySectionPropertyRepositoryQuery.php

 
     public function __construct(ProductFamilySectionPropertyRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'pfsp', $paginator);
+        parent::__construct($repository, 'productFamilySectionProperty', $paginator);
     }
 
     public function filterByProductFamily(ProductFamilyInterface $productFamily): self

Repository/Product/ProductRepositoryQuery.php

 
     public function __construct(ProductRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'product', $paginator);
     }
     public function orderByDefault(): \Lc\SovBundle\Repository\AbstractRepositoryQuery
     {
             $this->isJoinProductFamily = true;
 
             return $this
-                    ->innerJoin('.productFamily', 'pf')
-                    ->addSelect('pf');
+                    ->innerJoin('.productFamily', 'productFamily')
+                    ->addSelect('productFamily');
         }
         return $this;
     }
     public function filterBySection(SectionInterface $section):self
     {
         $this->joinProductFamilySectionProperties(false);
-        $this->andWhereSection('pfsp', $section);
-        $this->andWhere('pfsp.status = 1');
+        $this->andWhereSection('productFamilySectionProperties', $section);
+        $this->andWhere('productFamilySectionProperties.status = 1');
 
         return $this;
     }
         if (!$this->isJoinProductFamilySectionProperties) {
             $this->isJoinProductFamilySectionProperties = true;
 
-            $this->leftJoin('pf.productFamilySectionProperties', 'pfsp');
+            $this->leftJoin('productFamily.productFamilySectionProperties', 'productFamilySectionProperties');
             if ($addSelect) {
-                $this->addSelect('pfsp');
+                $this->addSelect('productFamilySectionProperties');
             }
         }
         return $this;
     public function filterIsOnline():self
     {
         $this->joinProductFamily();
-        $this->andWhereStatus('pf', 1);
+        $this->andWhereStatus('productFamily', 1);
         $this->andWhereStatus($this->id, 1);
         return $this;
     }
                 $this->query->expr()->orX(
                         $this->query->expr()->andX(
                                 $this->query->expr()->orX(
-                                        'pf.behaviorCountStock LIKE :behaviorCountStockByProductFamily',
-                                        'pf.behaviorCountStock LIKE :behaviorCountStockByMeasure'
+                                        'productFamily.behaviorCountStock LIKE :behaviorCountStockByProductFamily',
+                                        'productFamily.behaviorCountStock LIKE :behaviorCountStockByMeasure'
                                 ),
-                                'pf.availableQuantity < 0 '
+                                'productFamily.availableQuantity < 0 '
                         ),
                         $this->query->expr()->andX(
-                                'pf.behaviorCountStock LIKE :behaviorCountStockByProduct',
-                                'r.availableQuantity < 0 '
+                                'productFamily.behaviorCountStock LIKE :behaviorCountStockByProduct',
+                                'product.availableQuantity < 0 '
                         )
                 )
         );
                 $this->query->expr()->orX(
                         $this->query->expr()->andX(
                                 $this->query->expr()->orX(
-                                        'pf.behaviorCountStock LIKE :behaviorCountStockByProductFamily',
-                                        'pf.behaviorCountStock LIKE :behaviorCountStockByMeasure'
+                                        'productFamily.behaviorCountStock LIKE :behaviorCountStockByProductFamily',
+                                        'productFamily.behaviorCountStock LIKE :behaviorCountStockByMeasure'
                                 ),
-                                'pf.availableQuantitySupplier < 0 '
+                                'productFamily.availableQuantitySupplier < 0 '
                         ),
                         $this->query->expr()->andX(
-                                'pf.behaviorCountStock LIKE :behaviorCountStockByProduct',
-                                'r.availableQuantitySupplier < 0 '
+                                'productFamily.behaviorCountStock LIKE :behaviorCountStockByProduct',
+                                'product.availableQuantitySupplier < 0 '
                         )
                 )
         );

Repository/Product/QualityLabelRepositoryQuery.php

 {
     public function __construct(QualityLabelRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'qualityLabel', $paginator);
     }
 
     public function orderByDefault(): AbstractRepositoryQuery

Repository/Reduction/ReductionCartRepositoryQuery.php

 
     public function __construct(ReductionCartRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'reductionCart', $paginator);
     }
 
     public function filterByCode(string $code)

Repository/Reduction/ReductionCatalogRepositoryQuery.php

 
     public function __construct(ReductionCatalogRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'reductionCatalog', $paginator);
     }
 
     public function joinUsers()
             $this->isJoinUsers = true;
 
             return $this
-                    ->leftJoin('.users', 'pf_users')
-                    ->addSelect('pf_users') ;
+                    ->leftJoin('.users', 'users')
+                    ->addSelect('users') ;
         }
         return $this;
     }
             $this->isJoinGroupUsers = true;
 
             return $this
-                    ->leftJoin('.groupUsers', 'pf_groupusers')
-                    ->addSelect('pf_groupusers') ;
+                    ->leftJoin('.groupUsers', 'groupusers')
+                    ->addSelect('groupusers') ;
         }
         return $this;
     }
             $this->isJoinProductFamilies = true;
 
             return $this
-                    ->leftJoin('.productFamilies', 'pfs')
-                    ->addSelect('pfs') ;
+                    ->leftJoin('.productFamilies', 'productFamilies')
+                    ->addSelect('productFamilies') ;
         }
         return $this;
     }
             $this->isJoinProductFamily = true;
 
             return $this
-                    ->leftJoin('.productFamily', 'pf')
-                    ->addSelect('pf') ;
+                    ->leftJoin('.productFamily', 'productFamily')
+                    ->addSelect('productFamily') ;
         }
         return $this;
     }
             $this->isJoinProductCategories = true;
 
             return $this
-                    ->leftJoin('.productCategories', 'pcs')
-                    ->addSelect('pcs') ;
+                    ->leftJoin('.productCategories', 'productCategories')
+                    ->addSelect('productCategories') ;
         }
         return $this;
     }

Repository/Reduction/ReductionCreditRepositoryQuery.php

 
     public function __construct(ReductionCreditRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'reductionCredit', $paginator);
     }
 
     public function filterByUser(UserInterface $user)

Repository/Section/OpeningRepositoryQuery.php

 
     public function __construct(OpeningRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'opening', $paginator);
     }
 }

Repository/Section/SectionRepositoryQuery.php

 
     public function __construct(SectionRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'section', $paginator);
     }
 
     public function filterByIsDefault(bool $isDefault)

Repository/Setting/MerchantSettingRepositoryQuery.php

 
     public function __construct(MerchantSettingRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'merchantSetting', $paginator);
     }
 }

Repository/Setting/SectionSettingRepositoryQuery.php

 
     public function __construct(SectionSettingRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'sectionSetting', $paginator);
     }
 }

Repository/User/UserMerchantRepositoryQuery.php

 
     public function __construct(UserMerchantRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'userMerchant', $paginator);
     }
 
     public function filterByUser(UserInterface $user)

Repository/User/UserPointSaleRepositoryQuery.php

 {
     public function __construct(UserPointSaleRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'userPointSale', $paginator);
     }
 }

Repository/User/UserRepositoryQuery.php

             $this->isJoinUserMerchants = true;
 
             return $this
-                ->innerJoin('.userMerchants', 'um');
+                ->innerJoin('.userMerchants', 'userMerchants');
         }
         return $this;
     }
     {
         $this->joinUserMerchants();
         return $this
-            ->andWhere('um.active = 1');
+            ->andWhere('userMerchants.active = 1');
     }
 
     public function filterByMerchant(Merchant $merchant): self
     {
         $this->joinUserMerchants();
         return $this
-            ->andWhere('um.merchant = :merchant')
+            ->andWhere('userMerchants.merchant = :merchant')
             ->setParameter('merchant', $merchant);
     }
 }

Repository/User/VisitorRepositoryQuery.php

 {
     public function __construct(VisitorRepository $repository, PaginatorInterface $paginator)
     {
-        parent::__construct($repository, 'r', $paginator);
+        parent::__construct($repository, 'visitor', $paginator);
     }
 
     public function filterByCookie(string $cookie = null)