src/Service/BaseEntityService.php line 595

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use App\Entity\CalendarEvent;
  6. use App\Entity\Client;
  7. use App\Entity\Company;
  8. use App\Entity\Form\AnySearch;
  9. use App\Entity\Machine;
  10. use App\Entity\Person;
  11. use App\Entity\Session;
  12. use App\Entity\Student;
  13. use App\Library\Route\RouteParamObjects;
  14. use App\Library\Utils\DateTimeProvider\DateTimeProviderInterface;
  15. use App\Library\Utils\DateTimeProvider\SystemDateTimeProvider;
  16. use App\Library\Utils\Dev\DoctrineUtils\DoctrineUtils;
  17. use App\Library\Utils\Dev\ReflectionUtils\ReflectionUtils;
  18. use App\Library\Utils\Other\Other;
  19. use App\Library\Utils\StringUtils;
  20. use App\Service\CarWash\CarWashService;
  21. use App\Service\Data\Paginator;
  22. use Doctrine\ORM\EntityManagerInterface;
  23. use Doctrine\ORM\EntityRepository;
  24. use Doctrine\ORM\Query\Expr\Join;
  25. use Doctrine\ORM\QueryBuilder;
  26. use Doctrine\Persistence\ObjectRepository;
  27. use Symfony\Component\Serializer\SerializerInterface;
  29. class BaseEntityService
  30. {
  31.     const MANDATORY_PARAMS = [
  32.     ];
  33.     const SEARCH_FIELDS = [
  34.         "name"
  35.     ];
  36.     const ORDER_ID_DESC = ["id", "DESC"];
  38.     private static $serviceSecFields = [];
  40.     /** @var EntityManagerInterface */
  41.     protected $em;
  42.     /**
  43.      * @var DateTimeProviderInterface
  44.      */
  45.     protected $dateTimeProvider;
  47.     protected $entityClassName = null;
  48.     protected $entityShortClassName = null;
  49.     protected $entityAlias = null;
  50.     protected $dateFieldName = "createdAt";
  51.     protected $tableName = null;
  52.     /**
  53.      * @deprecated Устарело. Не использовать.
  54.      */
  55.     protected $searchDql = 'item.id = :text or item.name like :text_like';
  56.     /**
  57.      * @var BaseEntityServiceDefault
  58.      */
  59.     private $default;
  60.     private $sqlFields = [];
  61.     /**
  62.      * @var SerializerInterface
  63.      */
  64.     private $serializer;
  65.     /**
  66.      * @var ServiceRetriever|null
  67.      */
  68.     protected $serviceRetriever;
  70.     public function __construct(EntityManagerInterface $em,
  71.                                 SerializerInterface $serializer = null,
  72.                                 ServiceRetriever $serviceRetriever = null)
  73.     {
  74.         $this->em = $em;
  75.         $this->default = new BaseEntityServiceDefault($this);
  76.         $this->serializer = $serializer;
  77.         $this->serviceRetriever = $serviceRetriever;
  78.     }
  80.     public function initialize(string $entityClassName, string $dateFieldName = "createdAt", string $searchDql = null): void
  81.     {
  82.         $this->dateFieldName = $dateFieldName;
  83.         $this->entityClassName = $entityClassName;
  84.         $this->entityShortClassName = self::getEntityShortName($entityClassName);
  85.         $this->entityAlias = self::getEntityAlias($this->entityShortClassName);
  87.         $classMetadata = $this->em->getClassMetadata($entityClassName);
  88.         $this->tableName = $classMetadata->getTableName();
  89.         $this->searchDql = $searchDql ?? $this->searchDql;
  90.     }
  92.     public function getRepository(): EntityRepository
  93.     {
  94.         return $this->em->getRepository($this->entityClassName);
  95.     }
  97.     /**
  98.      * @return BaseEntityServiceDefault
  99.      */
  100.     public function getBaseService(): BaseEntityServiceDefault
  101.     {
  102.         return $this->default;
  103.     }
  105.     public function getRandom(int $count = 1, bool $getCount = false, array $excludeIds = null, string $where = null)
  106.     {
  107.         $sql = 'SELECT ' . ($getCount ? "count(*)" : "*") . ' FROM ' . $this->tableName . ' item '
  108.             . ($excludeIds || $where ? "WHERE " : "")
  109.             . ($excludeIds ? " item.id not in (0, " . implode(",", $excludeIds) . ")" : "")
  110.             . ($where ? " $where" : "")
  111.             . ' ORDER BY RAND() LIMIT ' . $count;
  113.         $connection = $this->em->getConnection();
  114.         $stmt = $connection->prepare($sql);
  115.         $result = $stmt->executeQuery();
  117.         return ($getCount ? (int)$result->fetchNumeric()[0] : $result->fetchAllAssociative());
  118.     }
  120.     public function hasItems(Company $company = null, string $whereSql = null): bool
  121.     {
  122.         $sql = 'SELECT count(*) as count FROM ' . $this->tableName . " item where"
  123.             . ($company ? " item.company_id = {$company->getId()}" : "")
  124.             . ($whereSql ? " $whereSql" : "")
  125.             . " LIMIT 1";
  127.         $connection = $this->em->getConnection();
  128.         $stmt = $connection->prepare($sql);
  129.         $result = $stmt->executeQuery();
  131.         return (int)$result->fetchNumeric()[0] != 0;
  132.     }
  134.     public function hasNotDeletedItems(Company $company): bool
  135.     {
  136.         $sql = 'SELECT count(*) as count FROM ' . $this->tableName . " item where item.company_id = {$company->getId()} and item.status != 'deleted' LIMIT 1";
  138.         $connection = $this->em->getConnection();
  139.         $stmt = $connection->prepare($sql);
  140.         $result = $stmt->executeQuery();
  142.         return (int)$result->fetchNumeric()[0] != 0;
  143.     }
  145.     protected static $sortedDefaultQueryParams = [
  146.         "company" => null,
  147.         "machine" => null,
  148.     ];
  150.     /**
  151.      * @param array{string, string}|null $orderBy
  152.      * @return array{list: array, page: int, perPage: int, totalItems: int, pagesCount: int}
  153.      * @throws \Exception
  154.      */
  155.     public function getItemsWithPaginationDefault(int   $page, array $params = null,
  156.                                                   array $orderBy = null, $onBeforeQueryChange = null, array $excludeMandatoryParams = null,
  157.                                                         $isSql = false, array $joinClasses = null, int $perPage = Paginator::PER_PAGE): array
  158.     {
  159.         $query = $this->getQuery($params, $orderBy, $onBeforeQueryChange,
  160.             $excludeMandatoryParams, $isSql, $joinClasses);
  162.         $result = Paginator::getResult($query, $page, $perPage, false, $this->em->getConnection());
  164.         if ($isSql && $joinClasses) {
  165.             foreach ($result['list'] as $index => $itemData) {
  166.                 $newData = [];
  167.                 $jointTableNames = [];
  168.                 foreach ($itemData as $key => $value) {
  169.                     $keyArr = explode("__", $key, 2);
  170.                     $tableName = $keyArr[0];
  171.                     $columnName = $keyArr[1];
  172.                     if (!isset($newData[$tableName])) {
  173.                         $newData[$tableName] = [];
  174.                         if ($tableName != $this->tableName) {
  175.                             $jointTableNames[] = $tableName;
  176.                         }
  177.                     }
  178.                     if (in_array($columnName, ["created_at", "last_online", "last_time"])) {
  179.                         $value = new \DateTime($value);
  180.                     }
  181.                     $newData[$tableName][$columnName] = $value;
  182.                 }
  184.                 $result['list'][$index] = $newData[$this->tableName];
  185.                 foreach ($jointTableNames as $name) {
  186.                     if (isset($result['list'][$index][$name])) {
  187.                         throw new \Exception("'$name' field is already set");
  188.                     }
  189.                     $result['list'][$index][$name] = $newData[$name];
  190.                 }
  191.             }
  192.         }
  194.         return $result;
  195.     }
  197.     public function summaryDefault(array $params = null, string $field = "amount", $onBeforeQueryChange = null,
  198.                                    array $excludeMandatoryParams = null, array $joinClasses = null)
  199.     {
  200.         $query = $this->summaryQueryDefault($params, $onBeforeQueryChange, $excludeMandatoryParams, $joinClasses, $field);
  202.         $result = (int)current($query->getQuery()->getResult()[0]);
  203.         return $result;
  204.     }
  206.     public function getDefault(array $params = null, $onBeforeQueryChange = null, array $excludeMandatoryParams = null,
  207.                                array $joinClasses = null, int $limit = null, array $orderBy = null): array {
  208.         $query = $this->getQuery($params, $orderBy, $onBeforeQueryChange,
  209.             $excludeMandatoryParams, false, $joinClasses, $limit);
  210.         $result = $query->getQuery()->getResult();
  211.         return $result;
  212.     }
  214.     public function getFirst(array $params = null, $onBeforeQueryChange = null, array $excludeMandatoryParams = null,
  215.                              array $joinClasses = null, array $orderBy = null)
  216.     {
  217.         $result = $this->getDefault($params, $onBeforeQueryChange, $excludeMandatoryParams, $joinClasses, 1,
  218.             $orderBy);
  219.         if ($result) {
  220.             return $result[0];
  221.         } else {
  222.             return null;
  223.         }
  224.     }
  226.     public function summaryQueryDefault(array $params = null, $onBeforeQueryChange = null, array $excludeMandatoryParams = null,
  227.                                         array $joinClasses = null, string $field = "amount")
  228.     {
  229.         $query = $this->getQuery($params, null, $onBeforeQueryChange, $excludeMandatoryParams, false, $joinClasses);
  230.         $query->select("sum(item.$field)");
  231.         return $query;
  232.     }
  234.     /**
  235.      * @param $paramName
  236.      * @param $paramValue
  237.      * @param \Doctrine\DBAL\Query\QueryBuilder|\Doctrine\ORM\QueryBuilder $query
  238.      * @param $sortedParams
  239.      * @return false
  240.      */
  241.     protected function handleNextQueryParam($paramName, $paramValue, $query, $sortedParams, $isSql) { //need override
  242.         return false;
  243.     }
  245.     /**
  246.      * @param array|null $params
  247.      * @param null|array{string, string} $orderBy
  248.      * @param $onBeforeQueryChange
  249.      * function(string $paramName, $paramValue, \Doctrine\DBAL\Query\QueryBuilder|\Doctrine\ORM\QueryBuilder $query): bool {}
  250.      * @param array|null $excludeMandatoryParams
  251.      * @param $isSql
  252.      * @param array|null $sortedDefaultQueryParams
  253.      * @return \Doctrine\DBAL\Query\QueryBuilder|QueryBuilder
  254.      * @throws \Exception
  255.      */
  256.     public function getQuery(array $params = null,
  257.                              array $orderBy = null, $onBeforeQueryChange = null, array $excludeMandatoryParams = null, $isSql = false, array $joinClasses = null,
  258.                              int $limit = null)
  259.     {
  260.         $sortedParams = $this->getSortedParams($params, $excludeMandatoryParams);
  262.         $query = ($isSql
  263.             ? $this->em->getConnection()->createQueryBuilder()
  264.             : $this->em->getRepository($this->entityClassName)->createQueryBuilder('item'));
  266.         $select = null;
  267.         if ($joinClasses) {
  268.             if ($isSql) {
  269.                 $select .= implode(", ", array_map(function ($current) {
  270.                     return "item.$current";
  271.                 }, DoctrineUtils::getAllEntityFields($this->em, $this->getEntityClassName(), $this->tableName)));
  272.             }
  274.             $lastJoinAlias = "item";
  275.             foreach ($joinClasses as $class) {
  276.                 $table = StringUtils::toCamel(self::getEntityShortName($class));
  277.                 $alias = self::getEntityAliasByTableName($table, false);
  279.                 $metadata = $this->em->getClassMetadata($class);
  280.                 if ($isSql) {
  281.                     $select .= ", " . implode(", ", array_map(function ($current) use ($alias) {
  282.                             return "$alias.$current";
  283.                         }, DoctrineUtils::getAllEntityFields($this->em, $class, $table)));
  284.                 }
  286.                 $field = null;
  287.                 switch ($class) {
  288.                     case Machine::class:
  289.                         $field = "machine_id";
  290.                         break;
  291.                     case Company::class:
  292.                         $field = $isSql ? "company_id" : "company";
  293.                         break;
  294.                     case Client::class:
  295.                         $field = $isSql ? "client_id" : "client";
  296.                         break;
  297.                     case Person::class:
  298.                         $field = $isSql ? "person_id" : "person";
  299.                         break;
  300.                     case CalendarEvent::class:
  301.                         $field = $isSql ? "calendar_event_id" : "calendarEvent";
  302.                         break;
  303.                     case Student::class:
  304.                         $field = $isSql ? "student_id" : "student";
  305.                         break;
  306.                     default:
  307.                         throw new \Exception("Unknown: " . $class . ". Entity: " . $this->entityClassName);
  308.                 }
  309.                 if ($isSql) {
  310.                     $query->innerJoin($lastJoinAlias, $table, $alias, "$lastJoinAlias.$field = $alias.id");
  311.                 } else {
  312.                     $query->innerJoin($class, $alias, Join::WITH, "$lastJoinAlias.$field = $alias");
  313.                 }
  314.                 $lastJoinAlias = $alias;
  315.             }
  316.         } else {
  317.             if ($isSql) {
  318.                 $select = "*";
  319.             }
  320.         }
  321.         if ($isSql) {
  322.             $query->select($select);
  323.             $query->from($this->tableName, "item");
  324.         }
  326.         foreach ($sortedParams as $paramName => $paramValue) {
  327.             if ($onBeforeQueryChange) {
  328.                 if ($onBeforeQueryChange($paramName, $paramValue, $query)) {
  329.                     continue;
  330.                 }
  331.             }
  333.             /** @var \Doctrine\DBAL\Query\QueryBuilder|\Doctrine\ORM\QueryBuilder $query */
  334.             if (!$this->handleNextQueryParam($paramName, $paramValue, $query, $sortedParams, $isSql)) {
  335.                 switch ($paramName) {
  336.                     case "id":
  337.                         if (is_array($paramValue)) {
  338.                             if ($isSql) {
  339.                                 $query->andWhere("item.id IN (" . Other::objectToStringId($paramValue) . ")");
  340.                             } else {
  341.                                 $query->andWhere("item.id IN (:ids)")
  342.                                     ->setParameter('ids', $paramValue);
  343.                             }
  344.                         } else {
  345.                             if ($isSql) {
  346.                                 $query->andWhere("item.id = :id")
  347.                                     ->setParameter('id', $paramValue);
  348.                             } else {
  349.                                 $query->andWhere("item.id = :id")
  350.                                     ->setParameter('id', $paramValue);
  351.                             }
  352.                         }
  353.                         break;
  354.                     // case "type":
  355.                     // case "status":
  356.                     //     if ($isSql) {
  357.                     //         throw new \Exception("Not implemented");
  358.                     //     } else {
  359.                     //         $query->andWhere("item.$paramName = :$paramName")
  360.                     //             ->setParameter("$paramName", $paramValue);
  361.                     //     }
  362.                     //     break;
  363.                     case "company":
  364.                         if ($paramValue !== null) {
  365.                             if ($isSql) {
  366.                                 $query->andWhere("item.company_id = :companyId")
  367.                                     ->setParameter('companyId', $paramValue);
  368.                             } else {
  369.                                 $query->andWhere("item.company = :company")
  370.                                     ->setParameter("company", $paramValue);
  371.                             }
  372.                         }
  373.                         break;
  374.                     case "start":
  375.                         if ($paramValue !== null) {
  376.                             if ($isSql) {
  377.                                 $query->andWhere("item.{$this->getSqlField($this->dateFieldName)} >= :start and item.{$this->getSqlField($this->dateFieldName)} <= :end")
  378.                                     ->setParameter('start', $paramValue->format("Y-m-d H:i:s"))
  379.                                     ->setParameter('end', $sortedParams['end']->format("Y-m-d H:i:s"));
  380.                             } else {
  381.                                 $query->andWhere("item.{$this->dateFieldName} >= :start and item.{$this->dateFieldName} <= :end")
  382.                                     ->setParameter('start', $paramValue)
  383.                                     ->setParameter('end', $sortedParams['end']);
  384.                             }
  385.                         }
  386.                         break;
  387.                     case "end":
  388.                         //do nothing
  389.                         break;
  390.                     case "startTime":
  391.                         if ($paramValue !== null) {
  392.                             if ($isSql) {
  393.                                 $query->andWhere("time(item.{$this->getSqlField($this->dateFieldName)}) >= :startTime and time(item.{$this->getSqlField($this->dateFieldName)}) <= :endTime")
  394.                                     ->setParameter('startTime', $paramValue->format('H:i:s'))
  395.                                     ->setParameter('endTime', $sortedParams['endTime']->format('H:i:s'));
  396.                             } else {
  397.                                 throw new \Exception("Not available");
  398.                             }
  399.                         }
  400.                         break;
  401.                     case "endTime":
  402.                         //do nothing`
  403.                         break;
  404.                     case "machine":
  405.                         if ($paramValue !== null) {
  406.                             if (is_object($paramValue) && method_exists($paramValue, "toArray") && get_class($paramValue) != Machine::class) {
  407.                                 $paramValue = $paramValue->toArray();
  408.                             }
  409.                             if (!is_array($paramValue)) {
  410.                                 $paramValue = [$paramValue];
  411.                             }
  412.                             if ($isSql) {
  413.                                 $query->andWhere("item.machine_id in (" . implode(", ",
  414.                                         array_map(function (Machine $machine) {return $machine->getId();}, $paramValue)) . ")");
  415.                             } else {
  416.                                 $query->andWhere("item.machine in (:machines)")
  417.                                     ->setParameter("machines", $paramValue);
  418.                             }
  419.                         }
  420.                         break;
  421.                     case "name":
  422.                         if ($paramValue !== null) {
  423.                             if ($isSql) {
  424.                                 throw new \Exception("Not implemented");
  425.                             } else {
  426.                                 $query->andWhere("item.name = :name")
  427.                                     ->setParameter("name", $paramValue);
  428.                             }
  429.                         }
  430.                         break;
  431.                     case "search":
  432.                         if ($paramValue !== null && $paramValue != "") {
  433.                             if ($isSql) {
  434.                                 throw new \Exception("Not implemented");
  435.                             } else {
  436.                                 $where = "";
  437.                                 foreach ($this->getSearchFields() as $field) {
  438.                                     $where .= ($where ? " or " : "") . "item.$field like :search";
  439.                                 }
  440.                                 $query->andWhere($where)
  441.                                     ->setParameter("search", "%" . $paramValue . "%");
  442.                             }
  443.                         }
  444.                         break;
  445.                     default:
  446.                         if (is_bool($paramValue) && preg_match("/^is[A-Z0-9]/", $paramName)) {
  447.                             if ($paramValue === false) {
  448.                                 $query->andWhere("item.$paramName = 0 or item.$paramName is null");
  449.                             } else {
  450.                                 $query->andWhere("item.$paramName = 1");
  451.                             }
  452.                         } else if (is_array($paramValue) && (isset($paramValue["startDate"]) || isset($paramValue["endDate"]))) {
  453.                             if ($isSql) {
  454.                                 throw new \Exception("Not implemented");
  455.                             } else {
  456.                                 $tmpWhere = "";
  457.                                 if (isset($paramValue["startDate"])) {
  458.                                     $tmpWhere .= "item.$paramName >= :{$paramName}StartDate";
  459.                                     $query->setParameter("{$paramName}StartDate", $paramValue['startDate']);
  460.                                 }
  461.                                 if (isset($paramValue["endDate"])) {
  462.                                     $tmpWhere .= ($tmpWhere ? " and " : "") . "item.$paramName <= :{$paramName}EndDate";
  463.                                     $query->setParameter("{$paramName}EndDate", $paramValue['endDate']);
  464.                                 }
  465.                                 $query->andWhere($tmpWhere);
  466.                             }
  467.                         } else if (is_array($paramValue) && ReflectionUtils::isEntity(current($paramValue))) {
  468.                             $alias = self::getEntityAlias($paramName);
  469.                             $query
  470.                                 ->join("item.$paramName", $alias)
  471.                                 ->andWhere("$alias.id in (:{$paramName}Ids)")
  472.                                 ->setParameter(":{$paramName}Ids", Other::objectToStringId($paramValue));
  473.                         } else if (is_array($paramValue) && is_string(current($paramValue))) {
  474.                             $query->andWhere("item.$paramName in (:{$paramName}Values)")
  475.                                 ->setParameter(":{$paramName}Values", $paramValue);
  476.                         } elseif  (is_array($paramValue) && is_int(current($paramValue))) {
  477.                             if ($isSql) {
  478.                                 $query->andWhere("item.$paramName in (" . implode(", ", $paramValue) . ")");
  479.                             } else {
  480.                                 $query->andWhere("item.$paramName in (:{$paramName}Ids)")
  481.                                     ->setParameter(":{$paramName}Ids", $paramValue);
  482.                             }
  483.                         } else {
  484.                             if ($isSql) {
  485.                                 throw new \Exception("Not implemented");
  486.                             } else {
  487.                                 if (strpos($paramName, ".") !== false) {
  488.                                     $query->andWhere("$paramName = :" . str_replace(".", "_", $paramName))
  489.                                         ->setParameter(str_replace(".", "_", $paramName), $paramValue);
  490.                                 } else {
  491.                                     $query->andWhere("item.$paramName = :$paramName")
  492.                                         ->setParameter("$paramName", $paramValue);
  493.                                 }
  494.                             }
  495.                         }
  496.                 }
  497.             }
  498.         }
  500.         if ($orderBy) {
  501.             $query->orderBy("item.{$orderBy[0]}", $orderBy[1]);
  502.         }
  503.         if ($limit !== null) {
  504.             $query->setMaxResults($limit);
  505.         }
  507.         if (Other::canAddDebugLog()) {
  508.             Other::appendQueryLog(
  509.                 (get_class($query) == "Doctrine\ORM\QueryBuilder" ? "DQL: "  . $query->getDQL() : "")
  510.                 . "\nSQL: " . (get_class($query) == "Doctrine\ORM\QueryBuilder" ? $query->getQuery()->getSQL() : $query->getSQL()));
  511.         }
  513.         return $query;
  514.     }
  516.     protected function getSqlField(string $field): string
  517.     {
  518.         if (isset($this->sqlFields[$field])) {
  519.             return $this->sqlFields[$field];
  520.         }
  521.         $this->sqlFields[$field] = StringUtils::toCamel($field);
  522.         return $this->sqlFields[$field];
  523.     }
  525.     public function getSortedParams(?array $params, ?array $excludeMandatoryParams): array
  526.     {
  527.         $sortedParams = array_merge($this::$sortedDefaultQueryParams, ($params ?: []));
  529.         foreach ($this->getMandatoryParams() as $paramName) {
  530.             if ((!isset($sortedParams[$paramName]) || $sortedParams[$paramName] === null) && (!$excludeMandatoryParams || !in_array($paramName, $excludeMandatoryParams))) {
  531.                 throw new \Exception("Обязательный параметр \"$paramName\" не задан. Добавьте параметр в \$params или добавьте в исключение \$excludeMandatoryParams"
  532.                     . ". Сущность: " . $this->entityClassName);
  533.             }
  534.         }
  536.         return $sortedParams;
  537.     }
  539.     public function getMandatoryParams(): array {
  540.         return self::MANDATORY_PARAMS;
  541.     }
  543.     protected function getSearchFields(): array {
  544.         return self::SEARCH_FIELDS;
  545.     }
  547.     /**
  548.      * @deprecated Устарело. Не использовать.
  549.      * Calls in getItemsBySearchWithPagination.
  550.      * Override if you need to modify query before search query execution.
  551.      * Example:
  552.      * For other entity joining.
  553.      * $query->innerJoin(Client::class, "client_", Join::WITH, "item.client = client_");
  554.      * @param QueryBuilder $query
  555.      * @return void
  556.      */
  557.     protected function setSearchQueryParams(QueryBuilder $query): void
  558.     {
  559.     }
  561.     public function setDateTimeProvider(DateTimeProviderInterface $dateTimeProvider)
  562.     {
  563.         $this->dateTimeProvider = $dateTimeProvider;
  564.     }
  566.     public function setSystemTimeProvider()
  567.     {
  568.         $this->dateTimeProvider = new SystemDateTimeProvider();
  569.     }
  571.     public static function getEntityShortName(string $entityClassName): string
  572.     {
  573.         return (new \ReflectionClass($entityClassName))->getShortName();
  574.     }
  576.     public static function getEntityAlias(string $entityShortClassName): string
  577.     {
  578.         return lcfirst($entityShortClassName) . "_";
  579.     }
  581.     public static function getEntityAliasByTableName(string $tableName, bool $addUnderscore = true): string
  582.     {
  583.         if (!str_contains($tableName, "_")) {
  584.             return $tableName . ($addUnderscore ? "_" : "");
  585.         }
  586.         $substrings = explode("_", $tableName);
  587.         return $substrings[0] .
  588.             implode("", array_map(function ($current) {return ucfirst($current);}, array_splice($substrings, 1))) .
  589.             ($addUnderscore ? "_" : "");
  590.     }
  592.     /**
  593.      * @deprecated Устарело. Не использовать.
  594.      */
  595.     public function setQueryParams(?QueryBuilder $query = null, ?AnySearch $search = null, ?Company $company,
  596.                                    ?\DateTime $start = null, ?\DateTime $end = null, ?array $orderBy = null,
  597.                                    ?array $statuses = null, ?Client $client = null, array $carWashes = null): QueryBuilder
  598.     {
  599.         return self::setQueryParamsByEm($this->em, $this->entityClassName, $this->dateFieldName,
  600.             $query, $search, $company, $start, $end, $orderBy, $statuses, $client, $this->searchDql, $carWashes);
  601.     }
  603.     /**
  604.      * @deprecated Устарело. Не использовать.
  605.      */
  606.     public static function setQueryParamsByEm(EntityManagerInterface $em, string $entityClassName, string $dateFieldName = null,
  607.                                               ?QueryBuilder $query = null, ?AnySearch $search = null, ?Company $company,
  608.                                               ?\DateTime $start = null, ?\DateTime $end = null, ?array $orderBy = null,
  609.                                               ?array $statuses = null, ?Client $client = null, string $searchDql = null,
  610.                                               array $carWashes = null): QueryBuilder
  611.     {
  612.         $lostClients = $search && $search->isLost() && $search->getLostDays();
  614.         if (!$query) {
  615.             $query = $em->getRepository($entityClassName)->createQueryBuilder('item');
  616.         }
  617.         if ($company) {
  618.             $query->where('item.company = :company')
  619.                 ->setParameter("company", $company);
  620.         }
  622.         if ($carWashes && !$lostClients) {
  623.             $query->andWhere($query->expr()->in("carWash_", ":carWashes"))->setParameter("carWashes", $carWashes);
  624.         }
  626.         if ($search && $search->getSearch() && $search->getSearch() != '') {
  627.             $query->andWhere($searchDql ?? 'item.id = :text or item.name like :text_like')
  628.                 ->setParameter('text', $search->getSearch())
  629.                 ->setParameter('text_like', '%' . $search->getSearch() . '%');
  630.         }
  632.         if ($start && $end && (!$search || !$search->isLost())) {
  633.             $query->andWhere("item.{$dateFieldName} >= :start and item.{$dateFieldName} <= :end")
  634.                 ->setParameter('start', $start)
  635.                 ->setParameter('end', $end);
  636.         }
  638.         if ($lostClients) {
  639.             $ids = [0];
  640.             $now = new \DateTime();
  641.             foreach ($em->getRepository(Client::class)->findBy(['company' => $company]) as $tmpClient) {
  642.                 /** @var Session $session */
  643.                 $session = $em->getRepository(Session::class)->findOneBy(array_merge(['client' => $tmpClient],
  644.                     (!$carWashes ? [] : ['machine' => CarWashService::getCarWashesMachines($carWashes, false)])), ['id' => 'DESC']);
  645.                 if ($session) {
  646.                     $dt = clone $session->getEndTime();
  647.                     $dt->modify('+'. $search->getLostDays() .' days');
  648.                     if ($dt < $now) {
  649.                         $ids[] = $tmpClient->getId();
  650.                         $search->clientLastSessionsDates[$tmpClient->getId()] = $session->getEndTime();
  651.                     }
  652.                 }
  653.             }
  654.             $query->andWhere('item.id in (:ids)')
  655.                 ->setParameter('ids', $ids);
  656.         }
  658.         if ($statuses) {
  659.             if (!is_array($statuses)) {
  660.                 $statuses = [$statuses];
  661.             }
  662.             $query->andWhere($query->expr()->in('item.status', ':statuses'))
  663.                 ->setParameter('statuses', $statuses);
  664.         }
  666.         if ($client) {
  667.             $query->andWhere('item.client = :client')
  668.                 ->setParameter("client", $client);
  669.         }
  671.         if ($orderBy) {
  672.             $query->orderBy("item.{$orderBy[0]}", $orderBy[1]);
  673.         }
  675.         return $query;
  676.     }
  678.     /**
  679.      * @deprecated Устарело. Не использовать.
  680.      * @psalm-param array<string, string>|null $orderBy
  681.      * @return array
  682.      */
  683.     public function getItemsBySearchWithPagination(?AnySearch $search = null, ?Company $company = null,
  684.                                                    ?\DateTime $start = null, ?\DateTime $end = null, ?array $orderBy = null,
  685.                                                    ?array     $statuses = null, $queryCallback = null, array $carWashes = null,
  686.                                                    Client $client = null, array $options = null, RouteParamObjects $routeObjects = null): array
  687.     {
  688.         if ($routeObjects && $routeObjects->getCarWash()) {
  689.             $carWashes = [$routeObjects->getCarWash()];
  690.         }
  692.         $query = $this->createQuery($search, $company, $start, $end, $orderBy, $statuses, $client, $queryCallback, true,
  693.             $carWashes);
  695.         $result = Paginator::getResult($query, ($search->getPage() && $search->getPage() > 0) ? $search->getPage() : 1,
  696.             Paginator::PER_PAGE, false);
  698.         if (isset($options['sortByPostId']) && $options['sortByPostId']) {
  699.             $result["list"] = $this->sortMachinesByPostId($result["list"]);
  700.         }
  702.         return $result;
  703.     }
  705.     /**
  706.      * @deprecated Устарело. Не использовать.
  707.      * @psalm-param array<string, string>|null $orderBy
  708.      */
  709.     public function createQuery(?AnySearch $search = null, ?Company $company = null,
  710.                                 ?\DateTime $start = null, ?\DateTime $end = null, ?array $orderBy = null,
  711.                                 ?array     $statuses = null, $client = null, $queryCallback = null, bool $setCommonSearchQueryParams = false,
  712.                                 array $carWashes = null): QueryBuilder
  713.     {
  714.         $query = $this->em->getRepository($this->entityClassName)->createQueryBuilder('item');
  715.         if ($setCommonSearchQueryParams) {
  716.             $this->setSearchQueryParams($query);
  717.         }
  718.         /** @var QueryBuilder $q */
  719.         $q = $this->setQueryParams($query, $search, $company, $start, $end, $orderBy, $statuses, $client, $carWashes);
  721.         if ($queryCallback) {
  722.             $queryCallback($q);
  723.         }
  725.         return $query;
  726.     }
  728.     /**
  729.      * @deprecated Устарело. Не использовать.
  730.      * @psalm-param array<string, string>|null $orderBy
  731.      * @return array
  732.      */
  733.     public function getQueryBySearchWithPagination(?AnySearch $search = null, ?Company $company = null,
  734.                                                    ?\DateTime $start = null, ?\DateTime $end = null, ?array $orderBy = null,
  735.                                                    ?array     $statuses = null): QueryBuilder
  736.     {
  737.         $query = $this->em->getRepository($this->entityClassName)->createQueryBuilder('item');
  738.         $this->setSearchQueryParams($query);
  739.         $q = $this->setQueryParams($query, $search, $company, $start, $end, $orderBy, $statuses);
  741.         return $q;
  742.     }
  744.     /**
  745.      * @deprecated Устарело. Не использовать.
  746.      * @param $fieldName
  747.      * @param AnySearch $search
  748.      * @param Company|null $company
  749.      * @param \DateTime|null $start
  750.      * @param \DateTime|null $end
  751.      * @return float|int|mixed|string
  752.      * @throws \Doctrine\ORM\NoResultException
  753.      * @throws \Doctrine\ORM\NonUniqueResultException
  754.      */
  755.     public function getSummaryByField($fieldName = "amount", ?AnySearch $search = null, ?Company $company = null,
  756.                                       ?\DateTime $start = null, ?\DateTime $end = null, ?Client $client = null,
  757.                                       ?array $statuses = null, $queryCallback = null, bool $setCommonSearchParams = false)
  758.     {
  759.         $q = $this->createQuery($search, $company, $start, $end, null, $statuses, $client, $queryCallback, $setCommonSearchParams);
  760.         $q->select("sum(item.$fieldName)");
  761.         $result = $q->getQuery()->getSingleScalarResult();
  762.         if ($result === null) {
  763.             $result = 0;
  764.         }
  765.         return $result;
  766.     }
  768.     /**
  769.      * @param string|array $whereConditions
  770.      * @param array|null $joinConditions
  771.      * @param string|null $select
  772.      * @param string|null $groupBy
  773.      * @return array
  774.      */
  775.     public function getByExpression($whereConditions = [], array $joinConditions = null, string $select = null,
  776.                                     string $groupBy = null): array
  777.     {
  778.         return self::getByExpressionWithEm($this->em, $this->entityClassName, $this->entityAlias, $whereConditions,
  779.             $joinConditions, $select, $groupBy);
  780.     }
  782.     /**
  783.      * @param array $whereConditions
  784.      * @param array|null $joinConditions
  785.      * @param string|null $select
  786.      * @param string|null $groupBy
  787.      * @return mixed
  788.      */
  789.     public function getOnyByExpression(array $whereConditions = [], array $joinConditions = null, string $select = null,
  790.                                        string $groupBy = null)
  791.     {
  792.         $result = self::getByExpressionWithEm($this->em, $this->entityClassName, $this->entityAlias, $whereConditions,
  793.             $joinConditions, $select, $groupBy);
  794.         if ($result == []) {
  795.             return null;
  796.         }  else {
  797.             if (count($result) > 1) {
  798.                 throw new \Exception('Found more than one');
  799.             }
  800.             return $result[0];
  801.         }
  802.     }
  804.     /**
  805.      * @param array $whereConditions
  806.      * @param array|null $joinConditions
  807.      * @param string|null $select
  808.      * @param string|null $groupBy
  809.      * @return QueryBuilder
  810.      */
  811.     public function getQueryByExpression(array $whereConditions = [], array $joinConditions = null, string $select = null,
  812.                                          string $groupBy = null)
  813.     {
  814.         return self::getQueryByExpressionWithEm($this->em, $this->entityClassName, $this->entityAlias, $whereConditions,
  815.             $joinConditions, $select, $groupBy);
  816.     }
  818.     /**
  819.      * @deprecated Устарело. Не использовать.
  820.      * @param EntityManagerInterface $em
  821.      * @param string $entityClassName
  822.      * @param string|null $entityAlias
  823.      * @param string|array $whereConditions
  824.      * @param array|null $joinExpressions
  825.      * @param string|null $select
  826.      * @param string|null $groupBy
  827.      * @return array
  828.      */
  829.     public static function getByExpressionWithEm(EntityManagerInterface $em, string $entityClassName, string $entityAlias = null,
  830.                                                                         $whereConditions = [], $joinExpressions = null, string $select = null,
  831.                                                  string $groupBy = null, int $limit = 0): array
  832.     {
  833.         $q = self::getQueryByExpressionWithEm($em, $entityClassName, $entityAlias, $whereConditions, $joinExpressions, $select, $groupBy, $limit);
  835.         $result = $q->getQuery()->getResult();
  836.         return $result;
  837.     }
  839.     /**
  840.      * @deprecated Устарело. Не использовать.
  841.      * @param string|array $whereConditions
  842.      * [Key = 'left expression part', value = 'expression value'].
  843.      * Example: [
  844.      *             "bonusPercentUpdatedAt !=" => "null",
  845.      *             "status" => [Status::STATUS1, Status::STATUS2]
  846.      *          ]
  847.      *
  848.      * @param array|null $joinExpressions
  849.      * ['joinEntityName', 'joinEntityCondition', 'joinEntityWhereExpression', 'joinEntityWhereValue']
  850.      * Example: ['cashbackRule', "id = client_.cashbackRule", 'status =', Status::STATUS_ACTIVE]
  851.      *
  852.      * @return QueryBuilder
  853.      */
  854.     public static function getQueryByExpressionWithEm(EntityManagerInterface $em, string $entityClassName, string $entityAlias = null,
  855.                                                                              $whereConditions = [], array $joinExpressions = null, string $select = null,
  856.                                                       string $groupBy = null, int $limit = 0)
  857.     {
  858.         if (!$entityAlias) {
  859.             $entityAlias = self::getEntityAlias(self::getEntityShortName($entityClassName));
  860.         }
  862.         $q = $em->getRepository($entityClassName)->createQueryBuilder($entityAlias);
  863.         if ($select) {
  864.             $q->select($select);
  865.         }
  867.         if ($joinExpressions) {
  868.             if (!is_array($joinExpressions[0])) {
  869.                 $joinExpressions = [$joinExpressions];
  870.             }
  871.             $joinParamIndex = 0;
  872.             foreach ($joinExpressions as $joinParams) {
  873.                 $joinEntity = $joinParams[0];
  874.                 $joinEntityAlias = "{$joinEntity}_";
  875.                 $joinCondition = $joinParams[1];
  876.                 $joinWhereExpression = $joinParams[2] ?? null;
  877.                 $joinWhereValue = $joinParams[3] ?? null;
  878.                 $q = $q->innerJoin("$entityAlias.$joinEntity", $joinEntityAlias, "WITH", "$joinEntityAlias.$joinCondition");
  880.                 $joinParamIndex++;
  881.                 $joinParamName = "joinParam$joinParamIndex";
  882.                 if ($joinWhereExpression) {
  883.                     $q->andWhere("$joinEntityAlias.$joinWhereExpression :$joinParamName")
  884.                         ->setParameter($joinParamName, $joinWhereValue);
  885.                 }
  886.             }
  887.         }
  889.         if (is_string($whereConditions)) {
  890.             $q->where($whereConditions);
  891.         } else {
  892.             $paramIndex = 0;
  893.             foreach ($whereConditions as $leftExpressionPart => $value) {
  894.                 $or = false;
  895.                 if (str_starts_with(strtolower($leftExpressionPart), "or ")) {
  896.                     $or = true;
  897.                     $leftExpressionPart = substr($leftExpressionPart, 3);
  898.                 }
  900.                 $paramIndex++;
  901.                 $paramName = "param$paramIndex";
  902.                 if (is_object($value) && strpos(get_class($value), "App\Entity") !== 0 && method_exists($value, "toArray")) {
  903.                     $value = $value->toArray();
  904.                 }
  905.                 if ($or) {
  906.                     if (is_array($value)) {
  907.                         $q
  908.                             ->orWhere($q->expr()->in("$entityAlias.$leftExpressionPart", ":$paramName"))
  909.                             ->setParameter($paramName, $value);
  910.                     } else {
  911.                         if ($value === null) {
  912.                             $q
  913.                                 ->orWhere("$entityAlias.$leftExpressionPart null");
  914.                         } else {
  915.                             $q
  916.                                 ->orWhere("$entityAlias.$leftExpressionPart :$paramName")
  917.                                 ->setParameter($paramName, $value);
  918.                         }
  919.                     }
  920.                 } else {
  921.                     if (is_array($value)) {
  922.                         $q
  923.                             ->andWhere($q->expr()->in("$entityAlias.$leftExpressionPart", ":$paramName"))
  924.                             ->setParameter($paramName, $value);
  925.                     } else {
  926.                         if ($value === null) {
  927.                             $q
  928.                                 ->andWhere("$entityAlias.$leftExpressionPart null");
  929.                         } else {
  930.                             $q
  931.                                 ->andWhere("$entityAlias.$leftExpressionPart :$paramName")
  932.                                 ->setParameter($paramName, $value);
  933.                         }
  934.                     }
  935.                 }
  936.             }
  937.         }
  939.         if ($groupBy) {
  940.             $q->groupBy($groupBy);
  941.         }
  942.         if ($limit) {
  943.             $q->setMaxResults($limit);
  944.         }
  946.         return $q;
  947.     }
  949.     /**
  950.      * @param array $whereConditions
  951.      * @param array|null $joinConditions
  952.      * @param string|null $select
  953.      * @param string|null $groupBy
  954.      * @return array
  955.      */
  956.     public function getBySqlExpression(array $whereConditions = [], array $joinConditions = null, string $select = null,
  957.                                        string $groupBy = null, string $tableName = null, int $limit = null): array
  958.     {
  959.         return self::getBySqlExpressionWithEm($this->em, $this->entityClassName,
  960.             (!$tableName ? $this->entityAlias : self::getEntityAliasByTableName($tableName)),
  961.             $whereConditions, $joinConditions, $select, $groupBy, ($tableName ?? $this->tableName), $limit);
  962.     }
  964.     /**
  965.      * @deprecated Устарело. Не использовать.
  966.      * @param array $whereConditions
  967.      * @param array|null $joinConditions
  968.      * @param string|null $select
  969.      * @param string|null $groupBy
  970.      * @return \Doctrine\DBAL\Query\QueryBuilder
  971.      */
  972.     public function getQueryBySqlExpression(array $whereConditions = [], array $joinConditions = null, string $select = null,
  973.                                             string $groupBy = null, string $tableName = null, int $limit = null)
  974.     {
  975.         return self::getQueryBySqlExpressionWithEm($this->em, $this->entityClassName,
  976.             (!$tableName ? $this->entityAlias : self::getEntityAliasByTableName($tableName)), $whereConditions,
  977.             $joinConditions, $select, $groupBy, ($tableName ?? $this->tableName), $limit);
  978.     }
  980.     /**
  981.      * @deprecated Устарело. Не использовать.
  982.      * @param EntityManagerInterface $em
  983.      * @param string $entityClassName
  984.      * @param string|null $entityAlias
  985.      * @param array $whereConditions
  986.      * @param array|null $joinExpressions
  987.      * @param string|null $select
  988.      * @param string|null $groupBy
  989.      */
  990.     public static function getBySqlExpressionWithEm(EntityManagerInterface $em, string $entityClassName, string $entityAlias = null,
  991.                                                     array $whereConditions = [], array $joinExpressions = null, string $select = null,
  992.                                                     string $groupBy = null, string $tableName = null, int $limit = null): array
  993.     {
  994.         $q = self::getQueryBySqlExpressionWithEm($em, $entityClassName, $entityAlias, $whereConditions, $joinExpressions, $select, $groupBy, $tableName, $limit);
  995.         $stmt = $q->execute();
  996.         $result = is_bool($stmt) ? $q->fetchAll() : $stmt->fetchAll();
  997.         return $result;
  998.     }
  1000.     /**
  1001.      * @deprecated Устарело. Не использовать.
  1002.      * @param array $whereConditions
  1003.      * [Key = 'left expression part', value = 'expression value'].
  1004.      * Example: [
  1005.      *             "bonusPercentUpdatedAt !=" => "null",
  1006.      *             "status" => [Status::STATUS1, Status::STATUS2]
  1007.      *          ]
  1008.      *
  1009.      * @param array|null $joinExpressions
  1010.      * ['joinTableName', 'joinColumnCondition', 'joinColumnWhereExpression', 'joinColumnWhereValue', 'joinType']
  1011.      * Example: ['client', "id = bonus.client_id", 'company_id =', 116, "left"]
  1012.      *
  1013.      * @return \Doctrine\DBAL\Query\QueryBuilder
  1014.      */
  1015.     public static function getQueryBySqlExpressionWithEm(EntityManagerInterface $em, string $entityClassName, string $entityAlias = null,
  1016.                                                          array $whereConditions = [], array $joinExpressions = null, string $select = null,
  1017.                                                          string $groupBy = null, string $tableName = null, int $limit = null)
  1018.     {
  1019.         if (!$entityAlias) {
  1020.             $entityAlias = self::getEntityAlias(self::getEntityShortName($entityClassName));
  1021.         }
  1022.         if (!$tableName) {
  1023.             throw new \Exception("\$tableName is not set");
  1024.         }
  1026.         $connection = $em->getConnection();
  1027.         $q = $connection->createQueryBuilder()
  1028.             ->select($select ?? "$entityAlias.id")
  1029.             ->from($tableName, $entityAlias);
  1031.         if ($joinExpressions) {
  1032.             if (!is_array($joinExpressions[0])) {
  1033.                 $joinExpressions = [$joinExpressions];
  1034.             }
  1035.             foreach ($joinExpressions as $joinParams) {
  1036.                 $joinTableName = $joinParams[0];
  1037.                 $joinEntityAlias = self::getEntityAliasByTableName($joinTableName);
  1038.                 $joinCondition = $joinParams[1];
  1039.                 $joinWhereExpression = $joinParams[2] ?? null;
  1040.                 $joinWhereValue = $joinParams[3] ?? null;
  1041.                 $preparedValue = self::prepareSqlValue($joinWhereValue);
  1042.                 $joinType = $joinParams[4] ?? null;
  1043.                 switch ($joinType) {
  1044.                     case null:
  1045.                     case "inner":
  1046.                         $q = $q->innerJoin($entityAlias, $joinTableName, $joinEntityAlias, "$joinEntityAlias.$joinCondition");
  1047.                         break;
  1048.                     case "left":
  1049.                         $q = $q->leftJoin($entityAlias, $joinTableName, $joinEntityAlias, "$joinEntityAlias.$joinCondition");
  1050.                         break;
  1051.                     default:
  1052.                         throw new \Exception("Unknown: $joinType" . ". Entity: " . $entityClassName);
  1053.                 }
  1055.                 if ($joinWhereExpression) {
  1056.                     if (is_array($joinWhereValue)) {
  1057.                         $q->andWhere("$joinEntityAlias.$joinWhereExpression in ($preparedValue)");
  1058.                     } else {
  1059.                         $q->andWhere("$joinEntityAlias.$joinWhereExpression $preparedValue");
  1060.                     }
  1061.                 }
  1062.             }
  1063.         }
  1065.         foreach ($whereConditions as $leftExpressionPart => $value) {
  1066.             $or = false;
  1067.             if (str_starts_with(strtolower($leftExpressionPart), "or ")) {
  1068.                 $or = true;
  1069.                 $leftExpressionPart = substr($leftExpressionPart, 3);
  1070.             }
  1072.             $isFullExpression = is_numeric($leftExpressionPart);
  1073.             $preparedValue = self::prepareSqlValue($value);
  1074.             if ($isFullExpression) {
  1075.                 $q->andWhere($value);
  1076.             } else {
  1077.                 if ($or) {
  1078.                     if (is_array($value)) {
  1079.                         $q->orWhere("$entityAlias.$leftExpressionPart in ($preparedValue)");
  1080.                     } else {
  1081.                         $q->orWhere("$entityAlias.$leftExpressionPart $preparedValue");
  1082.                     }
  1083.                 } else {
  1084.                     if (is_array($value)) {
  1085.                         $q->andWhere("$entityAlias.$leftExpressionPart in ($preparedValue)");
  1086.                     } else {
  1087.                         $q->andWhere("$entityAlias.$leftExpressionPart $preparedValue");
  1088.                     }
  1089.                 }
  1090.             }
  1091.         }
  1093.         if ($groupBy) {
  1094.             $q->groupBy($groupBy);
  1095.         }
  1096.         if ($limit) {
  1097.             $q->setMaxResults($limit);
  1098.         }
  1100.         return $q;
  1101.     }
  1103.     /**
  1104.      * @param $value
  1105.      * @return mixed|string|int
  1106.      */
  1107.     private static function prepareSqlValue($value)
  1108.     {
  1109.         if ($value === null) {
  1110.             $value = "null";
  1111.         } else if (is_string($value) && !str_starts_with($value, "'") && !str_starts_with($value, "\"")) {
  1112.             $value = "'" . $value . "'";
  1113.         } else if (is_array($value)) {
  1114.             $value = implode(", ", $value);
  1115.         }
  1116.         return $value;
  1117.     }
  1119.     /**
  1120.      * @deprecated Устарело. Не использовать.
  1121.      */
  1122.     public function getBy(array $criteria, ?Company $company = null): array
  1123.     {
  1124.         if ($company) {
  1125.             $criteria['company'] = $company;
  1126.         }
  1127.         return $this->em->getRepository($this->entityClassName)->findBy($criteria);
  1128.     }
  1130.     /**
  1131.      * @deprecated Устарело. Не использовать.
  1132.      */
  1133.     public function getOneBy(array $criteria, ?Company $company = null)
  1134.     {
  1135.         if ($company) {
  1136.             $criteria['company'] = $company;
  1137.         }
  1138.         return $this->em->getRepository($this->entityClassName)->findOneBy($criteria);
  1139.     }
  1141.     public function getMachineIds(array $machines, $addZeroId = false): array
  1142.     {
  1143.         $result = array_map(function ($machine) {return $machine->getId();}, $machines);
  1144.         if ($addZeroId) {
  1145.             array_unshift($result, 0);
  1146.         }
  1147.         return $result;
  1148.     }
  1150.     public function getMultiDimensionalSqlResultsByMachineIdAndDate(array $sqlResults, array $additionalFieldsBefore = null,
  1151.                                                                     array $additionalFieldsAfter = null): array
  1152.     {
  1153.         return DoctrineUtils::getMultiDimensionalSqlResults($sqlResults,
  1154.             array_merge(($additionalFieldsBefore ?? []), ["machine_id", "date"], ($additionalFieldsAfter ?? [])));
  1155.     }
  1157.     public function getSessionsServiceSecSumSelectSql(string $tableAlias): string
  1158.     {
  1159.         $select = '';
  1160.         for ($num = 1; $num <= Machine::maxServiceNum; $num++) {
  1161.             $select .= ($select ? ",\n" : '') . "SUM($tableAlias.service{$num}sec) as service{$num}sec";
  1162.         }
  1163.         return $select;
  1164.     }
  1166.     public function getSessionServiceSecSumSelectSql(string $tableAlias, bool $paidPauseSec = false): string
  1167.     {
  1168.         $select = '';
  1169.         for ($num = 1; $num <= Machine::maxServiceNum; $num++) {
  1170.             $select .= ($select ? " + " : '') . "$tableAlias.service{$num}sec";
  1171.         }
  1172.         if ($paidPauseSec) {
  1173.             $select .= " + $tableAlias.paid_pause_sec";
  1174.         }
  1175.         return $select;
  1176.     }
  1178.     public function getSessionAmountsSumSelectSql(string $tableAlias): string
  1179.     {
  1180.         $arrayFields = ['coin_amount', 'note_amount', 'no_cash_amount', 'cash_sess', 'card_sess', 'bonus_for_session'];
  1181.         $select = "";
  1182.         foreach ($arrayFields as $field) {
  1183.             $select .= ($select ? ",\n " : "") . "IFNULL(SUM($tableAlias.$field), 0) as $field";
  1184.         }
  1185.         return $select;
  1186.     }
  1188.     public function getMachinePaymentsSummary(array $data): float
  1189.     {
  1190.         return $data["payments_qr_amount"] + $data["payments_yandex_amount"];
  1191.     }
  1193.     public function getMachinesMethodParameter($machine)
  1194.     {
  1195.         $machines = $machine;
  1196.         if (!is_array($machines)) {
  1197.             $machines = [$machine];
  1198.         }
  1199.         return $machines;
  1200.     }
  1202.     /**
  1203.      * @return null
  1204.      */
  1205.     public function getEntityClassName()
  1206.     {
  1207.         return $this->entityClassName;
  1208.     }
  1210.     public function getIncomeMoneyFields(bool $refusual = false): array
  1211.     {
  1212.         $result = ["coin_amount", "note_amount", "no_cash_amount", "ping_amount", "qr_amount"];
  1213.         if ($refusual) {
  1214.             $result[] = "refusual";
  1215.         }
  1216.         return $result;
  1217.     }
  1219.     public function getAllMoneyFields(): array
  1220.     {
  1221.         return ["note_amount", "no_cash_amount", "payments_qr_amount", "payments_yandex_amount", "refusual",
  1222.             "gross_profit", "server_bonus", "bonus_for_session", "card_sess"];
  1223.     }
  1225.     public function getServiceSecFields(): array
  1226.     {
  1227.         if (self::$serviceSecFields) {
  1228.             return self::$serviceSecFields;
  1229.         }
  1231.         $result = [];
  1232.         for ($i = 1; $i <= Machine::maxServiceNum; $i++) {
  1233.             $result[] = "service{$i}sec";
  1234.         }
  1235.         $result[] = "paid_pause_sec";
  1236.         self::$serviceSecFields = $result;
  1237.         return $result;
  1238.     }
  1240.     public function createOrGetDefault(array $params)
  1241.     {
  1242.         $item = $this->getFirst($params);
  1243.         if (!$item) {
  1244.             $item = (new $this->entityClassName());
  1245.             foreach ($params as $key => $value) {
  1246.                 $setter = 'set' . ucfirst($key);
  1247.                 $item->$setter($value);
  1248.             }
  1249.             $this->saveDefault($item);
  1250.         }
  1251.         return $item;
  1252.     }
  1254.     public function saveDefault($item)
  1255.     {
  1256.         $this->em->persist($item);
  1257.         $this->em->flush();
  1258.     }
  1260.     public function removeDefault($item, $flush = true)
  1261.     {
  1262.         $this->em->remove($item);
  1263.         if ($flush) {
  1264.             $this->em->flush();
  1265.         }
  1266.     }
  1268.     public function serializeDefault($item, array $includeFields = null, array $excludeFields = null): string
  1269.     {
  1270.         return $this->serializer->serialize($item, 'json', [
  1271.             'attributes' => $includeFields,
  1272.             'ignored_attributes' => $excludeFields
  1273.         ]);
  1274.     }
  1276.     public function getSameItemCheckFields(): array
  1277.     {
  1278.         throw new \Exception("Not implemented");
  1279.     }
  1281.     public function hasSameDefault($item): bool
  1282.     {
  1283.         $fields = $this->getSameItemCheckFields();
  1284.         $criteria = [];
  1285.         foreach ($fields as $field) {
  1286.             $getter = 'get' . ucfirst($field);
  1287.             if ($item->$getter() !== null) {
  1288.                 $criteria[$field] = $item->$getter();
  1289.             }
  1290.         }
  1292.         $same = $this->getDefault($criteria);
  1293.         foreach ($same as $sameItem) {
  1294.             if ($sameItem->getId() != $item->getId()) {
  1295.                 return true;
  1296.             }
  1297.         }
  1298.         return false;
  1299.     }
  1301.     public function removeForeignKeyConstraintEntities($entity, $foreignEntity, string $foreignEntityField)
  1302.     {
  1303.         if ($foreignEntity) {
  1304.             $this->em->remove($foreignEntity);
  1305.         }
  1307.         if ($entity) {
  1308.             $setter = 'set' . ucfirst($foreignEntityField);
  1309.             $entity->$setter(null);
  1310.             $this->em->flush();
  1311.         } else {
  1312.             $this->em->flush();
  1313.         }
  1315.         $this->removeDefault($entity);
  1316.     }
  1317. }