Events.php

<?php

namespace QUI\ERP\Coupons;

use QUI;
use QUI\ERP\Order\AbstractOrder;
use QUI\ERP\Products\Handler\Fields;
use QUI\ERP\Products\Interfaces\ProductInterface;
use Quiqqer\Engine\Collector;
use QUI\ERP\Order\Basket\Basket;
use QUI\ERP\Order\Basket\BasketGuest;
use QUI\ERP\Coupons\Handler as CouponsHandler;
use QUI\ERP\Discount\EventHandling as DiscountEvents;
use QUI\ERP\Coupons\Products\CouponProductType;
use QUI\ERP\Coupons\Products\CouponProductException;

/**
 * Class Events
 *
 * Global Event Handler for quiqqer/payment-paypal
 */
class Events
{
    /**
     * quiqqer/quiqqer: onPackageSetup
     *
     * @param QUI\Package\Package $Package
     * @return void
     */
    public static function onPackageSetup(QUI\Package\Package $Package)
    {
        try {
            self::createProductFields();
        } catch (\Exception $Exception) {
            QUI\System\Log::writeException($Exception);
        }
    }

    /**
     * Template event quiqqer/order: onQuiqqer::order::orderProcessBasketEnd
     *
     * @param Collector $Collector
     * @param BasketGuest $Basket
     * @param $Order
     */
    public static function templateOrderProcessBasketEnd(Collector $Collector, $Basket, $Order)
    {
        if (!($Basket instanceof Basket)
            && !($Basket instanceof QUI\ERP\Order\Basket\BasketOrder)
        ) {
            return;
        }

        if (isset($Order) && isset($_GET['coupon'])) {
            try {
                $code = Handler::sanitizeCode($_GET['coupon']);

                $CouponCode = Handler::getCouponCodeByCode($code);
                $CouponCode->checkRedemption(QUI::getUserBySession());
                $CouponCode->addToOrder($Order);
            } catch (\Exception $Exception) {
            }
        }

        $Collector->append(
            '<div data-qui="package/quiqqer/coupons/bin/frontend/controls/CouponCodeInput"></div>'
        );
    }

    /**
     * @param QUI\ERP\Order\OrderProcess $OrderProcess
     * @throws QUI\ERP\Order\Exception
     * @throws QUI\Exception
     */
    public static function onOrderProcess(QUI\ERP\Order\OrderProcess $OrderProcess)
    {
        $CurrentStep = $OrderProcess->getCurrentStep();
        $currentStep = $CurrentStep->getType();

        if ($currentStep !== QUI\ERP\Order\Controls\OrderProcess\Basket::class) {
            return;
        }

        $coupons = QUI::getSession()->get('quiqqer-coupons');

        if (\is_string($coupons)) {
            $coupons = \json_decode($coupons, true);
        }

        if (!\is_array($coupons)) {
            $coupons = [];
        }

        if (isset($_GET['coupon'])) {
            $coupons[] = $_GET['coupon'];
        }

        $coupons = \array_unique($coupons);

        if (empty($coupons)) {
            return;
        }

        $Order = $OrderProcess->getOrder();

        foreach ($coupons as $coupon) {
            self::addCouponToOrder($Order, $coupon);
        }
    }

    /**
     * @param QUI\ERP\Order\Basket\Basket $Basket
     * @param $pos
     */
    public static function onQuiqqerOrderBasketRemovePos(
        QUI\ERP\Order\Basket\Basket $Basket,
        $pos
    ) {
        $Order = null;

        try {
            $Order = $Basket->getOrder();
        } catch (QUI\Exception $Exception) {
            $Orders = QUI\ERP\Order\Handler::getInstance();

            try {
                $Order = $Orders->getLastOrderInProcessFromUser(QUI::getUserBySession());
            } catch (QUI\Exception $Exception) {
            }
        }

        if (!$Order) {
            QUI::getSession()->remove('quiqqer-coupons');

            return;
        }


        $Article      = $Order->getArticles()->getArticle($pos);
        $customData   = $Article->getCustomData();
        $orderCoupons = $Order->getDataEntry('quiqqer-coupons');

        $articleCouponCode = false;

        if (isset($customData['package']) && isset($customData['code'])) {
            $articleCouponCode = $customData['code'];
        }

        if (!$articleCouponCode) {
            return;
        }

        // custom data has code params, so article is an coupon code
        // we need to delete it
        if (\in_array($articleCouponCode, $orderCoupons)) {
            $pos = \array_search($articleCouponCode, $orderCoupons);
            unset($orderCoupons[$pos]);

            $Order->setData('quiqqer-coupons', $orderCoupons);

            try {
                $Order->save();
            } catch (QUI\Exception $Exception) {
            }
        }

        // look at session coupons
        // we need to delete it
        $coupons = QUI::getSession()->get('quiqqer-coupons');

        if (\is_string($coupons)) {
            $coupons = \json_decode($coupons, true);
        }

        if (!\is_array($coupons) || empty($coupons)) {
            return;
        }

        if (!\in_array($customData['code'], $coupons)) {
            return;
        }

        // remove code from session
        // because code is deleted
        $newCouponList = [];

        foreach ($coupons as $coupon) {
            if ($customData['code'] !== $coupon) {
                $newCouponList[] = $coupon;
            }
        }

        if (empty($newCouponList)) {
            QUI::getSession()->remove('quiqqer-coupons');
        } else {
            QUI::getSession()->set('quiqqer-coupons', \json_encode($newCouponList));
        }
    }

    /**
     * event - on price factor init
     *
     * @param $Basket
     * @param QUI\ERP\Order\AbstractOrder $Order
     * @param QUI\ERP\Products\Product\ProductList $Products
     */
    public static function onQuiqqerOrderBasketToOrder(
        $Basket,
        QUI\ERP\Order\AbstractOrder $Order,
        QUI\ERP\Products\Product\ProductList $Products
    ) {
        $coupons        = $Order->getDataEntry('quiqqer-coupons');
        $sessionCoupons = QUI::getSession()->get('quiqqer-coupons');

        if (!\is_array($coupons)) {
            $coupons = [];
        }

        if (\is_string($sessionCoupons)) {
            $sessionCoupons = \json_decode($sessionCoupons, true);

            if (\is_array($sessionCoupons)) {
                $coupons = \array_merge($coupons, $sessionCoupons);
            }

            $coupons = \array_unique($coupons);

            self::addSessionCouponsToOrder($Order, $sessionCoupons);
        }

        if (empty($coupons)) {
            return;
        }

        $PriceFactors = $Products->getPriceFactors();
        $products     = $Products->toArray();
        $productCount = $Products->count();
        $subSum       = $products['calculations']['subSum'];

        $checkRedeemable = !$Order->isSuccessful(); // if order is successful we dont need a check
        $OrderInProcess  = $Order->getAttribute('OrderInProcess');
        $added           = false;

        if ($Order->getAttribute('inOrderCreation')) {
            $checkRedeemable = false;
        }

        if ($OrderInProcess instanceof QUI\ERP\Order\OrderInProcess
            && $OrderInProcess->getAttribute('inOrderCreation')
        ) {
            $checkRedeemable = false;
        }

        foreach ($coupons as $coupon) {
            /* @var $Coupon CouponCode */
            try {
                $Coupon = Handler::getCouponCodeByCode($coupon);
            } catch (\Exception $Exception) {
                continue;
            }

            // coupon check
            if ($checkRedeemable && !$Coupon->isRedeemable($Order->getCustomer())) {
                continue;
            }

            /* @var $Discount QUI\ERP\Discount\Discount */
            $discounts = $Coupon->getDiscounts();

            foreach ($discounts as $Discount) {
                if (!DiscountEvents::isDiscountUsableWithQuantity($Discount, $productCount)) {
                    continue;
                }

                if ($Discount->getAttribute('scope') === QUI\ERP\Discount\Handler::DISCOUNT_SCOPE_GRAND_TOTAL) {
                    // do nothing for this scope
                    // since this scope requires all price factors etc, this cannot be calculated here
                } elseif (!DiscountEvents::isDiscountUsableWithPurchaseValue($Discount, $subSum)) {
                    continue;
                }

                $PriceFactor = $Discount->toPriceFactor(null, $Order->getCustomer());
                $PriceFactor->setTitle(
                    QUI::getLocale()->get('quiqqer/coupons', 'coupon.discount.title', [
                        'code' => $Coupon->getCode()
                    ])
                );

                $isUnique     = $Discount->getAttribute('scope') === QUI\ERP\Discount\Handler::DISCOUNT_SCOPE_UNIQUE;
                $everyProduct = $Discount->getAttribute('scope') === QUI\ERP\Discount\Handler::DISCOUNT_SCOPE_EVERY_PRODUCT;

                if ($everyProduct || $isUnique) {
                    // add to the product
                    $products     = $Products->getProducts();
                    $alreadyAdded = false;

                    foreach ($products as $Product) {
                        if ($Discount->canUsedWith($Product) === false) {
                            continue;
                        }

                        if ($isUnique && $alreadyAdded) {
                            continue;
                        }

                        if ($Product instanceof QUI\ERP\Products\Product\UniqueProduct) {
                            $Product->getPriceFactors()->add($PriceFactor);
                            $added        = true;
                            $alreadyAdded = true;
                        }
                    }

                    continue;
                }

                $added = true;
                $PriceFactors->addToEnd($PriceFactor);
            }
        }

        if ($added) {
            try {
                $Products->recalculation();
            } catch (QUI\Exception $Exception) {
                QUI\System\Log::writeDebugException($Exception);
            }
        }
    }

    /**
     * quiqqer/order: onQuiqqerOrderSuccessful
     *
     * Redeem coupons used in (completed) orders
     *
     * @param QUI\ERP\Order\Order|QUI\ERP\Order\OrderInProcess $Order
     * @return void
     */
    public static function onQuiqqerOrderSuccessful($Order)
    {
        $coupons = $Order->getDataEntry('quiqqer-coupons');

        if (empty($coupons)) {
            return;
        }

        foreach ($coupons as $couponCode) {
            try {
                $CouponCode = CouponsHandler::getCouponCodeByCode($couponCode);
                $CouponCode->redeem($Order->getCustomer(), $Order);
            } catch (\Exception $Exception) {
                QUI\System\Log::writeException($Exception);
            }
        }
    }

    /**
     * @param $Order
     * @param $coupons
     */
    protected static function addSessionCouponsToOrder($Order, $coupons)
    {
        if (!\is_array($coupons)) {
            return;
        }

        // coupons as article if not added
        $Articles     = $Order->getArticles();
        $isInArticles = function ($code) use ($Articles) {
            foreach ($Articles as $Article) {
                $customData = $Article->getCustomData();

                if (isset($customData['code']) && $customData['code'] === $code) {
                    return true;
                }
            }

            return false;
        };

        foreach ($coupons as $coupon) {
            if ($isInArticles($coupon) === false) {
                self::addCouponToOrder($Order, $coupon);
            }
        }
    }

    /**
     * @param $Order
     * @param $coupon
     */
    protected static function addCouponToOrder($Order, $coupon)
    {
        if (!($Order instanceof QUI\ERP\Order\OrderInProcess)) {
            return;
        }

        try {
            $code = Handler::sanitizeCode($coupon);

            $CouponCode = Handler::getCouponCodeByCode($code);
            $CouponCode->checkRedemption(QUI::getUserBySession());
            $CouponCode->checkOrderRedemption($Order);

            $coupons   = $Order->getDataEntry('quiqqer-coupons');
            $coupons[] = $code;

            $coupons = \array_unique($coupons);

            $Order->setData('quiqqer-coupons', $coupons);
            $Order->update();

            $CouponCode->addToOrder($Order);
        } catch (\Exception $Exception) {
        }
    }

    /**
     * Removes all coupons from the current session.
     *
     * @return void
     */
    public static function removeCouponsFromSession()
    {
        QUI::getSession()->remove('quiqqer-coupons');
    }

    /**
     * Create all fixed product fields that quiqqer/stock-management provides
     *
     * @return void
     * @throws QUI\Exception
     */
    protected static function createProductFields()
    {
        $fields = [
            CouponProductType::PRODUCT_FIELD_ID_TRANSFERABLE             => [
                'title'         => [
                    'de' => 'Gutschein-Code ist übertragbar',
                    'en' => 'Coupon code is transferable'
                ],
                'type'          => Fields::TYPE_BOOL,
                'public'        => false,
                'standard'      => false,
                'requiredField' => false
            ],
            CouponProductType::PRODUCT_FIELD_ID_SEND_MAIL                => [
                'title'         => [
                    'de' => 'Gutschein-Code per E-Mail senden',
                    'en' => 'Send coupon code via email'
                ],
                'type'          => Fields::TYPE_BOOL,
                'public'        => false,
                'standard'      => false,
                'requiredField' => false
            ],
            CouponProductType::PRODUCT_FIELD_ID_GENERATE_PDF             => [
                'title'         => [
                    'de' => 'Gutschein-Code als PDF bereitstellen',
                    'en' => 'Provide coupon code as PDF'
                ],
                'type'          => Fields::TYPE_BOOL,
                'public'        => false,
                'standard'      => false,
                'requiredField' => false
            ],
            CouponProductType::PRODUCT_FIELD_ID_COUPON_AMOUNT            => [
                'title'         => [
                    'de' => 'Gutschein Wert',
                    'en' => 'Coupon amount'
                ],
                'type'          => Fields::TYPE_FLOAT,
                'public'        => false,
                'standard'      => false,
                'requiredField' => true
            ],
            CouponProductType::PRODUCT_FIELD_ID_DAYS_VALID               => [
                'title'         => [
                    'de' => 'Gutschein-Code Gültigkeit (Tage)',
                    'en' => 'Coupon code validity (days)'
                ],
                'type'          => Fields::TYPE_INT,
                'public'        => false,
                'standard'      => false,
                'requiredField' => true
            ],
            CouponProductType::PRODUCT_FIELD_ID_COUPON_DESCRIPTION       => [
                'title'         => [
                    'de' => 'Gutschein-Beschreibung',
                    'en' => 'Coupon description'
                ],
                'type'          => Fields::TYPE_INPUT_MULTI_LANG,
                'public'        => false,
                'standard'      => false,
                'requiredField' => true
            ],
            CouponProductType::PRODUCT_FIELD_ID_IS_SINGLE_PURPOSE_COUPON => [
                'title'         => [
                    'de' => 'Ist Einzweck-Gutschein (Besteuerung bei Gutschein-Kauf)',
                    'en' => 'Is single purpose coupon (taxation on voucher purchase)'
                ],
                'type'          => Fields::TYPE_BOOL,
                'public'        => false,
                'standard'      => false,
                'requiredField' => false
            ]
        ];

        $fieldsCreated = false;

        foreach ($fields as $fieldId => $field) {
            try {
                Fields::getField($fieldId);
                continue;
            } catch (\Exception $Exception) {
                // Field does not exist -> create it
            }

            try {
                Fields::createField([
                    'id'            => $fieldId,
                    'type'          => $field['type'],
                    'titles'        => $field['title'],
                    'workingtitles' => $field['title'],
                    'systemField'   => 0,
                    'standardField' => !empty($field['standard']) ? 1 : 0,
                    'publicField'   => !empty($field['public']) ? 1 : 0,
                    'options'       => !empty($field['options']) ? $field['options'] : null,
                    'requiredField' => !empty($field['requiredField']) ? 1 : 0
                ]);
            } catch (\Exception $Exception) {
                QUI\System\Log::writeException($Exception);
                continue;
            }

            $fieldsCreated = true;
        }

        if ($fieldsCreated) {
            QUI\Translator::publish('quiqqer/products');
        }
    }

    /**
     * Assign plan product fields to a product
     *
     * @param ProductInterface $Product
     * @return void
     *
     * @throws QUI\Exception
     */
    public static function onQuiqqerProductsProductCreate(ProductInterface $Product)
    {
        if (!($Product instanceof CouponProductType)) {
            return;
        }

        $UniqueProduct = $Product->createUniqueProduct();
        $UniqueProduct->calc();

        $fields = [
            CouponProductType::PRODUCT_FIELD_ID_TRANSFERABLE             => true,
            CouponProductType::PRODUCT_FIELD_ID_SEND_MAIL                => true,
            CouponProductType::PRODUCT_FIELD_ID_GENERATE_PDF             => true,
            CouponProductType::PRODUCT_FIELD_ID_COUPON_AMOUNT            => $UniqueProduct->getPrice()->getValue(),
            CouponProductType::PRODUCT_FIELD_ID_DAYS_VALID               => 1095, // 3 years
            CouponProductType::PRODUCT_FIELD_ID_COUPON_DESCRIPTION       => null,
            CouponProductType::PRODUCT_FIELD_ID_IS_SINGLE_PURPOSE_COUPON => false,
        ];

        foreach ($fields as $fieldId => $value) {
            try {
                $Field = Fields::getField($fieldId);
                $Field->setValue($value);

                $Product->addOwnField($Field);
            } catch (\Exception $Exception) {
                QUI\System\Log::writeException($Exception);
            }
        }

        // No VAT tax types -> Choose first one found
        $noVatTaxTypes = QUI\ERP\Coupons\Products\Handler::getNoVatTaxTypes();

        if (!empty($noVatTaxTypes)) {
            $Product->getField(Fields::FIELD_VAT)->setValue($noVatTaxTypes[0]->getId());
        }

        try {
            $Product->update(QUI::getUsers()->getSystemUser());
        } catch (\Exception $Exception) {
            QUI\System\Log::writeException($Exception);
        }
    }

    /**
     * quiqqer/products: onQuiqqerProductsProductActivate
     *
     * Check if a coupon product has the correct tax type!
     *
     * @param ProductInterface $Product
     *
     * @throws CouponProductException
     * @throws QUI\Exception
     */
    public static function onQuiqqerProductsProductActivate(ProductInterface $Product)
    {
        if (!($Product instanceof CouponProductType)) {
            return;
        }

        $isSinglePurposeCoupon = $Product->getFieldValue(CouponProductType::PRODUCT_FIELD_ID_IS_SINGLE_PURPOSE_COUPON);

        if (!empty($isSinglePurposeCoupon)) {
            return;
        }

        $productTaxTypeId = (int)$Product->getFieldValue(Fields::FIELD_VAT);
        $noVatTaxTypes    = QUI\ERP\Coupons\Products\Handler::getNoVatTaxTypes();

        foreach ($noVatTaxTypes as $TaxType) {
            if ($TaxType->getId() === $productTaxTypeId) {
                return;
            }
        }

        throw new CouponProductException([
            'quiqqer/coupons',
            'exception.CouponProduct.no_vat_tax_type_required',
            [
                'productTitle' => $Product->getTitle(),
                'productId'    => $Product->getId()
            ]
        ]);
    }

    /**
     * quiqqer/order: onQuiqqerOrderCreated
     *
     * Parse coupon attributes from order and create coupon codes for the buyer.
     *
     * @param AbstractOrder $Order
     * @return void
     */
    public static function onQuiqqerOrderCreated(AbstractOrder $Order)
    {
        QUI\ERP\Coupons\Products\Handler::createCouponCodesFromOrder($Order);
    }
}