kupshop/class/Query/Order.php

<?php

namespace Query;

use Doctrine\DBAL\Connection;
use KupShop\KupShopBundle\Query\JsonOperator;

class Order
{
    /**
     * @param array $paymentMethods ['METHOD_ONLINE', 'METHOD_TRANSFER', ...] constants from class.Payment.php
     *
     * @return \Closure
     */
    public static function byPaymentMethods(array $paymentMethods)
    {
        static $counter = 0;

        return function (QueryBuilder $qb) use ($paymentMethods, &$counter) {
            $filteredPaymentClasses = [];
            $paymentReflection = new \ReflectionClass('Payment');
            foreach (\Payment::listClasses() as $class => $className) {
                try {
                    $tmpMethod = \Payment::getClass($class)->getPayMethod();
                    foreach ($paymentMethods as $method) {
                        if (is_string($method)) {
                            $method = $paymentReflection->getConstant($method);
                        }
                        if ($method === $tmpMethod) {
                            $filteredPaymentClasses[] = $class;
                        }
                    }
                } catch (\Exception $e) {
                    // don't kill me for eating this exception
                }
            }

            $parameter = 'dtp_filtered_classes'.$counter++;
            $qb->join('o', 'delivery_type', 'dt', 'dt.id = o.id_delivery')
                ->join('dt', 'delivery_type_payment', 'dtp', 'dtp.id = dt.id_payment');
            $qb->setParameter($parameter, $filteredPaymentClasses, Connection::PARAM_STR_ARRAY);

            return $qb->expr()->in('COALESCE(dtp.class, \'\')', ":{$parameter}");
        };
    }

    public static function byVirtualDelivery(): callable
    {
        static $counter = 0;

        return function (QueryBuilder $qb) use (&$counter) {
            $filteredDeliveryClasses = [];
            foreach (\Delivery::listClasses() as $class => $className) {
                try {
                    if (\Delivery::getClass($class)->getType() === \Delivery::TYPE_VIRTUAL) {
                        $filteredDeliveryClasses[] = $class;
                    }
                } catch (\Exception $e) {
                    // don't kill me for eating this exception
                }
            }

            $parameter = 'dtd_filtered_classes_virtual'.$counter;
            $qb->join('o', 'delivery_type', 'dt', 'dt.id = o.id_delivery')
                ->join('dt', 'delivery_type_delivery', 'dtd', 'dtd.id = dt.id_delivery');

            $qb->setParameter($parameter, $filteredDeliveryClasses, Connection::PARAM_STR_ARRAY);

            return $qb->expr()->in('COALESCE(dtd.class, \'\')', ":{$parameter}");
        };
    }

    public static function byInPersonDelivery(bool $inPersonDelivery = true)
    {
        static $counter = 0;

        return function (QueryBuilder $qb) use ($inPersonDelivery, &$counter) {
            $filteredPaymentClasses = [];
            foreach (\Delivery::listClasses() as $class => $className) {
                try {
                    if (\Delivery::getClass($class)->isInPerson() === $inPersonDelivery) {
                        $filteredPaymentClasses[] = $class;
                    }
                } catch (\Exception $e) {
                    // don't kill me for eating this exception
                }
            }

            $parameter = 'dtd_filtered_classes'.$counter;
            $qb->join('o', 'delivery_type', 'dt', 'dt.id = o.id_delivery')
                ->join('dt', 'delivery_type_delivery', 'dtd', 'dtd.id = dt.id_delivery');
            $qb->setParameter($parameter, $filteredPaymentClasses, Connection::PARAM_STR_ARRAY);

            return $qb->expr()->in('COALESCE(dtd.class, \'\')', ":{$parameter}");
        };
    }

    public static function byStatus(array $statuses)
    {
        return Operator::inIntArray($statuses, 'o.status');
    }

    /**
     * @param array of allowed delivery IDs
     * @param string $alias
     *
     * @return \Closure
     */
    public static function byDeliveryIDs(array $deliveryIDs, $alias = 'o')
    {
        static $counter = 0;

        return function (QueryBuilder $qb) use ($deliveryIDs, &$counter, $alias) {
            $parameter = 'dtd_filtered_ids'.$counter++;
            $qb->join($alias, 'delivery_type', 'dt', "dt.id = {$alias}.id_delivery")
            ->setParameter($parameter, $deliveryIDs, Connection::PARAM_INT_ARRAY);

            return $qb->expr()->in('COALESCE(dt.id_delivery, \'\')', ":{$parameter}");
        };
    }

    public static function byPaymentIDs(array $paymentIDs, string $alias = 'o'): callable
    {
        static $counter = 0;

        return function (QueryBuilder $qb) use ($paymentIDs, &$counter, $alias) {
            $parameter = 'dtp_filtered_ids'.$counter++;
            $qb->join($alias, 'delivery_type', 'dt', "dt.id = {$alias}.id_delivery")
                ->setParameter($parameter, $paymentIDs, Connection::PARAM_INT_ARRAY);

            return $qb->expr()->in('COALESCE(dt.id_payment, \'\')', ":{$parameter}");
        };
    }

    public static function itemType($alias = 'oi'): string
    {
        return JsonOperator::value("{$alias}.note", 'item_type');
    }

    /**
     * @param string $alias
     *
     * @return \Closure
     */
    public static function byItemType($itemType, $alias = 'oi')
    {
        static $counter = 0;

        return function (QueryBuilder $qb) use ($itemType, &$counter, $alias) {
            if (is_null($itemType)) {
                return $qb->expr()->isNull(self::itemType($alias));
            } else {
                $parameter = 'order_item_type'.$counter++;
                $qb->setParameter($parameter, $itemType);

                return $qb->expr()->eq(Operator::coalesce(self::itemType($alias), "''"), ":{$parameter}");
            }
        };
    }

    public static function byPaidStatus(bool $isPaid = true): string
    {
        $paid = $isPaid ? '1' : '0';

        return "o.status_payed = {$paid}";
    }

    /**
     * @param $code string|array
     *
     * @return callable|void
     */
    public static function byOrderNo($code, $alias = 'o')
    {
        return Operator::orX(array_map(function ($val) use ($alias) {
            return Operator::like(["{$alias}.order_no" => "{$val}%", "{$alias}.order_no_reverse" => strrev($val).'%'], 'OR');
        }, is_array($code) ? $code : [$code]));
    }

    public static function activeOnly()
    {
        return 'o.status_storno = 0';
    }

    public static function notPackedOrders(): callable
    {
        return Operator::andX(
            Operator::inIntArray(getStatuses('notpacked'), 'o.status'),
            Operator::equals(['o.status_storno' => 0]));
    }
}