custom/plugins/CogiLicenseManager/src/Service/LicenseManagerService.php line 547

Open in your IDE?
  1. <?php
  3. namespace Cogi\CogiLicenseManager\Service;
  5. use Cogi\CogiLicenseManager\CogiLicenseManager;
  6. use Cogi\CogiLicenseManager\Core\LicenseEmail\LicenseEmailEntity;
  7. use Cogi\CogiLicenseManager\Core\LicenseKey\LicenseKeyCollection;
  8. use Cogi\CogiLicenseManager\Core\LicenseKey\LicenseKeyEntity;
  9. use Cogi\CogiLicenseManager\Core\LicenseMultiKeyLog\LicenseMultiKeyLogEntity;
  10. use Cogi\CogiLicenseManager\Core\LicensePool\LicensePoolEntity;
  11. use Cogi\CogiLicenseManager\Core\LicenseProduct\LicenseProductEntity;
  12. use Doctrine\DBAL\Connection;
  13. use Exception;
  14. use Shopware\Core\Checkout\Order\Aggregate\OrderDelivery\OrderDeliveryEntity;
  15. use Shopware\Core\Checkout\Order\Aggregate\OrderLineItem\OrderLineItemEntity;
  16. use Shopware\Core\Checkout\Order\Aggregate\OrderTransaction\OrderTransactionEntity;
  17. use Shopware\Core\Checkout\Order\OrderEntity;
  18. use Shopware\Core\Content\Mail\Service\AbstractMailService;
  19. use Shopware\Core\Content\MailTemplate\MailTemplateEntity;
  20. use Shopware\Core\Content\Media\MediaService;
  21. use Shopware\Core\Framework\Api\Context\SystemSource;
  22. use Shopware\Core\Framework\Context;
  23. use Shopware\Core\Framework\DataAbstractionLayer\EntityCollection;
  24. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  25. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InconsistentCriteriaIdsException;
  26. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  27. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  28. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  29. use Shopware\Core\Framework\Uuid\Uuid;
  30. use Shopware\Core\Framework\Validation\DataBag\DataBag;
  31. use Shopware\Core\System\Salutation\SalutationEntity;
  32. use Shopware\Core\System\SystemConfig\SystemConfigService;
  33. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  35. class LicenseManagerService extends AbstractController {
  36.     /**
  37.      * @var AbstractMailService $mailService
  38.      */
  39.     private AbstractMailService $mailService;
  41.     /**
  42.      * @var EntityRepository $mailTemplateRepository
  43.      */
  44.     private EntityRepository $mailTemplateRepository;
  46.     /**
  47.      * @var EntityRepository $salutationRepository
  48.      */
  49.     private EntityRepository $salutationRepository;
  51.     /**
  52.      * @var SystemConfigService $systemConfigService
  53.      */
  54.     private SystemConfigService $systemConfigService;
  56.     /**
  57.      * @var EntityRepository
  58.      */
  59.     protected EntityRepository $licenseProductRepository;
  61.     /**
  62.      * @var EntityRepository
  63.      */
  64.     protected EntityRepository $licenseRepository;
  66.     /**
  67.      * @var EntityRepository
  68.      */
  69.     protected EntityRepository $licensePoolRepository;
  71.     /**
  72.      * @var EntityRepository $orderRepository
  73.      */
  74.     private EntityRepository $orderRepository;
  76.     /**
  77.      * @var EntityRepository $orderTransactionRepository
  78.      */
  79.     private EntityRepository $orderTransactionRepository;
  81.     /**
  82.      * @var EntityRepository $orderDeliveryRepository
  83.      */
  84.     private EntityRepository $orderDeliveryRepository;
  86.     /**
  87.      * @var EntityRepository
  88.      */
  89.     protected EntityRepository $licenseUrlRepository;
  91.     /**
  92.      * @var EntityRepository
  93.      */
  94.     protected EntityRepository $licenseMultiKeyLogRepository;
  96.     /**
  97.      * @var EntityRepository
  98.      */
  99.     protected EntityRepository $productRepository;
  101.     /**
  102.      * @var array
  103.      */
  104.     protected array $config;
  106.     /**
  107.      * @var MediaService
  108.      */
  109.     private MediaService $mediaService;
  111.     /**
  112.      * @param MediaService $mediaService
  113.      * @param AbstractMailService $mailService
  114.      * @param EntityRepository $mailTemplateRepository
  115.      * @param EntityRepository $salutationRepository
  116.      * @param SystemConfigService $systemConfigService
  117.      * @param EntityRepository $licenseProductRepository
  118.      * @param EntityRepository $licenseRepository
  119.      * @param EntityRepository $licensePoolRepository
  120.      * @param EntityRepository $orderRepository
  121.      * @param EntityRepository $orderTransactionRepository
  122.      * @param EntityRepository $orderDeliveryRepository
  123.      * @param EntityRepository $licenseUrlRepository
  124.      * @param EntityRepository $productRepository
  125.      * @param EntityRepository $licenseMultiKeyLogRepository
  126.      */
  127.     public function __construct(MediaService $mediaService, AbstractMailService $mailService, EntityRepository $mailTemplateRepository, EntityRepository $salutationRepository, SystemConfigService $systemConfigService, EntityRepository $licenseProductRepository, EntityRepository $licenseRepository, EntityRepository $licensePoolRepository, EntityRepository $orderRepository, EntityRepository $orderTransactionRepository, EntityRepository $orderDeliveryRepository, EntityRepository $licenseUrlRepository, EntityRepository $productRepository, EntityRepository $licenseMultiKeyLogRepository) {
  128.         $this->mailService = $mailService;
  129.         $this->mailTemplateRepository = $mailTemplateRepository;
  130.         $this->salutationRepository = $salutationRepository;
  131.         $this->systemConfigService = $systemConfigService;
  132.         $this->licenseProductRepository = $licenseProductRepository;
  133.         $this->licenseRepository = $licenseRepository;
  134.         $this->licensePoolRepository = $licensePoolRepository;
  135.         $this->orderRepository = $orderRepository;
  136.         $this->orderTransactionRepository = $orderTransactionRepository;
  137.         $this->orderDeliveryRepository = $orderDeliveryRepository;
  138.         $this->licenseUrlRepository = $licenseUrlRepository;
  139.         $this->productRepository = $productRepository;
  140.         $this->licenseMultiKeyLogRepository = $licenseMultiKeyLogRepository;
  141.         $this->mediaService = $mediaService;
  142.         $this->config = $systemConfigService->getDomain('CogiLicenseManager.config');
  143.     }
  145.     /**
  146.      * @param OrderEntity $order
  147.      * @param OrderLineItemEntity $lineItem
  148.      * @param Context $context
  149.      */
  150.     public function processLicenseOrder(OrderEntity $order, OrderLineItemEntity $lineItem, Context $context) {
  151.         $criteria = new Criteria();
  152.         $criteria->addAssociation('pool');
  153.         $criteria->addAssociation('product');
  154.         $criteria->setLimit(1);
  155.         $criteria->addFilter(new EqualsFilter('productId', $lineItem->getReferencedId()));
  156.         /** @var LicenseProductEntity $result */
  157.         $result = $this->licenseProductRepository->search($criteria, $context)->getEntities()->first();
  160.         $multiKey = $this->getMultiKey($result->getPool()->getId(), $context, $result->getCount() * $lineItem->getQuantity());
  162.         if ($multiKey->count() <= 0) {
  163.             $licenseList = $this->getFreeLicenses($result->getPool()->getId(), $context, $result->getCount() * $lineItem->getQuantity(), true);
  164.         } else {
  165.             $licenseList = $multiKey;
  166.         }
  168.         if (count($licenseList) < $result->getCount() && $multiKey === null) {
  169.             try {
  170.                 $mailTemplate = $this->getMailTemplate(CogiLicenseManager::MAIL_TEMPLATE_ADMIN_EMPTY_POOL);
  172.                 $licenseEmail = new LicenseEmailEntity();
  173.                 $licenseEmail->setCustomer($order->getOrderCustomer());
  174.                 $licenseEmail->setOrder($order);
  175.                 $licenseEmail->setPool($result->getPool());
  176.                 $licenseEmail->setLicenseProduct($result);
  178.                 $this->sendEmptyPoolMail($licenseEmail, $mailTemplate);
  179.             } catch (InconsistentCriteriaIdsException $e) {
  180.                 return;
  181.             }
  183.         } else if (count($licenseList) <= 0) {
  184.             try {
  185.                 $mailTemplate = $this->getMailTemplate(CogiLicenseManager::MAIL_TEMPLATE_ADMIN_EMPTY_POOL);
  187.                 $licenseEmail = new LicenseEmailEntity();
  188.                 $licenseEmail->setCustomer($order->getOrderCustomer());
  189.                 $licenseEmail->setOrder($order);
  190.                 $licenseEmail->setPool($result->getPool());
  191.                 $licenseEmail->setLicenseProduct($result);
  193.                 $this->sendEmptyPoolMail($licenseEmail, $mailTemplate);
  194.             } catch (InconsistentCriteriaIdsException $e) {
  195.                 return;
  196.             }
  197.         } else {
  198.             $this->reserveLicense($licenseList, $order, $lineItem, $result->getPool()->getId(), $result->getCount() * $lineItem->getQuantity());
  200.             $orderCustomFields = $order->getCustomFields() ?: [];
  201.             $licenseKeys = [];
  202.             if (isset($orderCustomFields['licenseKeys'])) $licenseKeys = $orderCustomFields['licenseKeys'] ?: [];
  203.             /** @var LicenseKeyEntity $license */
  204.             foreach ($licenseList->getElements() as $license) {
  205.                 array_push($licenseKeys, $license->getLicense());
  206.             }
  207.             $orderCustomFields['licenseKeys'] = $licenseKeys;
  210.             $order->setCustomFields($orderCustomFields);
  211.             $this->orderRepository->update([
  212.                 [
  213.                     'id' => $order->getId(),
  214.                     'customFields' => $orderCustomFields
  215.                 ]
  216.             ], $context);
  219.             try {
  220.                 $mailTemplate = $this->getMailTemplate(CogiLicenseManager::MAIL_TEMPLATE_ADMIN);
  221.                 if (isset($mailTemplate)) {
  222.                     $licenseEmail = new LicenseEmailEntity();
  223.                     $licenseEmail->setCustomer($order->getOrderCustomer());
  224.                     $licenseEmail->setOrder($order);
  225.                     $licenseEmail->setLicenseKeys($licenseList->getElements());
  226.                     $licenseEmail->setPool($result->getPool());
  227.                     $licenseEmail->setLicenseList($licenseList);
  228.                     $licenseEmail->setLicenseProduct($result);
  230.                     $this->sendAdminMail($licenseEmail, $mailTemplate);
  231.                 }
  232.             } catch (InconsistentCriteriaIdsException $e) {
  233.                 return;
  234.             }
  236.         }
  237.     }
  239.     /**
  240.      * @param EntityCollection $licenseList
  241.      * @param OrderEntity $order
  242.      * @param OrderLineItemEntity $lineItem
  243.      * @param string $poolId
  244.      * @param int $count
  245.      */
  246.     private function reserveLicense(EntityCollection $licenseList, OrderEntity $order, OrderLineItemEntity $lineItem, string $poolId, int $count) {
  247.         /** @var LicenseKeyEntity $license */
  248.         foreach ($licenseList as $license) {
  249.             if (!$license->isMultiKey()) {
  250.                 $this->licenseRepository->update([
  251.                     [
  252.                         'id' => $license->getId(),
  253.                         'sold' => false,
  254.                         'delivered' => false,
  255.                         'reserved' => true,
  256.                         'orderId' => $order->getId(),
  257.                         'customerId' => $order->getOrderCustomer()->getCustomer()->getId(),
  258.                         'productId' => $lineItem->getProductId(),
  259.                     ]
  260.                 ], Context::createDefaultContext());
  261.             } else {
  263.                 $this->licenseMultiKeyLogRepository->create([
  264.                     [
  265.                         'id' => Uuid::randomHex(),
  266.                         'keyId' => $license->getId(),
  267.                         'count' => $count,
  268.                         'sold' => false,
  269.                         'deliverd' => false,
  270.                         'reserved' => true,
  271.                         'orderId' => $order->getId(),
  272.                         'customerId' => $order->getOrderCustomer()->getCustomer()->getId(),
  273.                         'productId' => $lineItem->getProductId(),
  274.                     ]
  275.                 ], Context::createDefaultContext());
  276.             }
  277.         }
  278.     }
  280.     /**
  281.      * @param OrderEntity $order
  282.      * @param Context $context
  283.      * @param bool $isResend
  284.      */
  285.     public function processSendKeys(OrderEntity $order, Context $context, bool $isResend = false) {
  286.         $keys = $this->getKeysToBeSent($order, $context, $isResend);
  288.         if (count($keys) <= 0 && !isset($order->getCustomFields()["licenseHasSendSuccess"])) {
  289.             $criteria = new Criteria([$order->getId()]);
  290.             $criteria->addAssociation("orderCustomer");
  291.             $criteria->addAssociation("orderCustomer.customer");
  292.             $criteria->addAssociation("salesChannel");
  293.             $criteria->addAssociation("currency");
  294.             $criteria->addAssociation("billingAddress");
  295.             $criteria->addAssociation("deliveries");
  296.             $criteria->addAssociation("lineItems");
  297.             $criteria->addAssociation("transactions");
  298.             $order = $this->orderRepository->search($criteria, $context)->first();
  300.             foreach ($order->getLineItems() as $lineItem) {
  302.                 if (isset($lineItem->getPayload()['isLicense'])) {
  304.                     if ($lineItem->getPayload()['isLicense'] !== null) {
  305.                         if ($lineItem->getPayload()['isLicense']) {
  306.                             $this->processLicenseOrder($order, $lineItem, $context);
  307.                         }
  308.                     }
  309.                 }
  310.             }
  311.             $keys = $this->getKeysToBeSent($order, $context, $isResend);
  312.         }
  314.         if (!$isResend) {
  315.             $this->updateOrderState($order, $context);
  317.             foreach ($keys as $key) {
  319.                 if (!isset($key->keyId)) {
  320.                     $this->licenseRepository->update([
  321.                         [
  322.                             'id' => $key->getId(),
  323.                             'sold' => true,
  324.                             'delivered' => true,
  325.                         ]
  326.                     ], Context::createDefaultContext());
  327.                 } else {
  328.                     $this->licenseMultiKeyLogRepository->update([
  329.                         [
  330.                             'id' => $key->getId(),
  331.                             'sold' => true,
  332.                             'deliverd' => true,
  333.                             'reserved' => true
  334.                         ]
  335.                     ], Context::createDefaultContext());
  337.                     $this->licenseRepository->update([
  338.                         [
  339.                             'id' => $key->getKey()->getId(),
  340.                             'multiKeyUsed' => ($key->getKey()->getMultiKeyUsed() + $key->getCount()),
  341.                         ]
  342.                     ], Context::createDefaultContext());
  343.                 }
  344.             }
  345.         }
  347.         $keyPoolArr = array();
  349.         $keyCounts = [];
  350.         foreach ($keys as $key) {
  351.             if (!isset($key->keyId)) {
  352.                 $keyPoolArr[$key->getPool()->getId()][] = $key;
  353.             } else {
  354.                 $keyCounts[$key->keyId] = $key->count;
  356.                 $multiKey = $key->getKey();
  357.                 $multiKey->setCustomer($key->getCustomer());
  358.                 $multiKey->setOrder($key->getOrder());
  359.                 $multiKey->setProduct($key->getProduct());
  361.                 $keyPoolArr[$key->getKey()->getPool()->getId()][] = $multiKey;
  362.             }
  363.         }
  365.         foreach ($keyPoolArr as $poolItems) {
  366.             $pool = $poolItems[0]->getPool();
  368.             $licenseList = new LicenseKeyCollection();
  369.             foreach ($poolItems as $license) {
  370.                 $licenseList->add($license);
  371.             }
  373.             $licenseEmail = new LicenseEmailEntity();
  374.             $licenseEmail->setCustomer($order->getOrderCustomer());
  375.             $licenseEmail->setOrder($order);
  376.             $licenseEmail->setLicenseKeys($poolItems);
  377.             $licenseEmail->setPool($pool);
  378.             $licenseEmail->setLicenseList($licenseList);
  379.             $licenseEmail->setCount($keyCounts[$poolItems[0]->id] ?? 1);
  380.             $licenseEmail->setHidenMailUrl($this->config['CogiLicenseManager.config.openKeyUrl'] ?? null);
  382.             if (isset($pool)) $licenseEmail->setUrlList($this->getUrls($pool, $context) ?: null);
  383.             if (isset($pool)) $licenseEmail->setMediaList($pool->getMedialist() ?: null);
  384.             if (isset($pool)) $licenseEmail->setEmailContent($pool->getEmailcontent() ?: null);
  386.             try {
  387.                 $mailTemplate = $this->getMailTemplate(CogiLicenseManager::MAIL_TEMPLATE_CUSTOMER);
  388.             } catch (InconsistentCriteriaIdsException $e) {
  389.                 return;
  390.             }
  392.             if (!$isResend) {
  393.                 try {
  394.                     $orderCustomFields = $order->getCustomFields() ?: [];
  395. //                    $orderCustomFields['licenseEmail'] = json_decode(json_encode($licenseEmail));
  396.                     $orderCustomFields['licenseHasSendSuccess'] = true;
  397.                     $order->setCustomFields($orderCustomFields);
  398.                     $this->orderRepository->update([
  399.                         [
  400.                             'id' => $order->getId(),
  401.                             'customFields' => $orderCustomFields
  402.                         ]
  403.                     ], $context);
  404.                 } catch (Exeption $e) {
  405.                 }
  406.             }
  407.             $this->sendEmail($licenseEmail, $mailTemplate);
  408.         }
  409.     }
  411.     /**
  412.      * @param OrderEntity $order
  413.      * @param Context $context
  414.      */
  415.     public function checkState(OrderEntity $order, Context $context) {
  416.         $transaction = $this->getTransaction($order);
  417.         $paymentState = $transaction->getStateMachineState()->getId();
  418.         $hasLicense = false;
  419.         foreach ($order->getLineItems() as $lineItem){
  420.             if(isset($lineItem->getPayload()['isLicense'])) {
  421.                 if ($lineItem->getPayload()['isLicense'] !== null) {
  422.                     if ($lineItem->getPayload()['isLicense']) {
  423.                         $hasLicense = true;
  424.                         break;
  425.                     }
  426.                 }
  427.             }
  428.         }
  429.         if (!$this->checkForPaymentCanceled($order, $context, $paymentState) && $hasLicense) {
  430.             if (isset($this->config['CogiLicenseManager.config.transactionStatus'])) {
  431.                 if ($this->config['CogiLicenseManager.config.transactionStatus'] === $paymentState) {
  432.                     $this->processSendKeys($order, $context);
  433.                 }
  434.             }
  435.         }
  436.     }
  439.     /**
  440.      * @param OrderEntity $order
  441.      * @param Context $context
  442.      * @param $paymentState
  443.      * @return bool
  444.      */
  445.     private function checkForPaymentCanceled(OrderEntity $order, Context $context, $paymentState): bool {
  446.         if (is_array($this->config['CogiLicenseManager.config.transactionAbordStatus'])) {
  447.             if (in_array($paymentState, $this->config['CogiLicenseManager.config.transactionAbordStatus'])) {
  448.                 $this->cancelLicense($order, $context);
  449.                 return true;
  450.             }
  451.         } else if ($this->config['CogiLicenseManager.config.transactionAbordStatus'] === $paymentState) {
  452.             $this->cancelLicense($order, $context);
  453.             return true;
  454.         }
  455.         return false;
  456.     }
  458.     /**
  459.      * @param OrderEntity $order
  460.      * @param Context $context
  461.      */
  462.     private function cancelLicense(OrderEntity $order, Context $context) {
  463.         $keys = $this->getKeysToBeSent($order, $context);
  465.         $poolId = null;
  466.         $productId = null;
  468.         foreach ($keys as $key) {
  469.             if (!isset($key->keyId)) {
  470.                 $this->licenseRepository->update([
  471.                     [
  472.                         'id' => $key->getId(),
  473.                         'sold' => false,
  474.                         'delivered' => false,
  475.                         'reserved' => false,
  476.                         'orderId' => null,
  477.                         'customerId' => null,
  478.                         'productId' => null,
  479.                     ]
  480.                 ], Context::createDefaultContext());
  483.                 if ($productId === null) {
  484.                     $productId = $key->getProduct()->getId();
  485.                 }
  486.                 if ($poolId === null) {
  487.                     $poolId = $key->getPool();
  488.                 }
  489.                 if ($poolId !== $key->getPool() || $productId !== $key->getProduct()->getId()) $this->updateProductStock($productId, $poolId);
  490.             } else {
  491.                 $this->licenseMultiKeyLogRepository->update([
  492.                     [
  493.                         'id' => $key->getId(),
  494.                         'sold' => false,
  495.                         'deliverd' => false,
  496.                         'reserved' => false
  497.                     ]
  498.                 ], Context::createDefaultContext());
  499.             }
  501.         }
  502.     }
  504.     /**
  505.      * @param $salutationId
  506.      * @return SalutationEntity|null
  507.      */
  508.     private function getSalutation($salutationId): ?SalutationEntity {
  509.         $context = new Context(new SystemSource());
  511.         $criteria = new Criteria();
  512.         $criteria->addFilter(new EqualsFilter('id', $salutationId));
  513.         $criteria->setLimit(1);
  515.         /** @var SalutationEntity|null $salutation */
  516.         $salutation = $this->salutationRepository->search($criteria, $context)->first();
  518.         return $salutation;
  519.     }
  521.     /**
  522.      * Gibt das bennötigte EMail Template wieder
  523.      * @param string $technicalName
  524.      * @return MailTemplateEntity|null
  525.      */
  526.     private function getMailTemplate(string $technicalName): ?MailTemplateEntity {
  527.         $context = new Context(new SystemSource());
  529.         $criteria = new Criteria();
  530.         $criteria->addFilter(new EqualsFilter('mailTemplateType.technicalName', $technicalName));
  531.         $criteria->setLimit(1);
  533.         /** @var MailTemplateEntity|null $mailTemplate */
  534.         $mailTemplate = $this->mailTemplateRepository->search($criteria, $context)->first();
  536.         return $mailTemplate;
  537.     }
  540.     /**
  541.      * @param string $poolId
  542.      * @param Context $context
  543.      * @param int $count
  544.      * @param bool $noMultiKey
  545.      * @return EntityCollection
  546.      */
  547.     public function getFreeLicenses(string $poolId, Context $context, int $count, bool $noMultiKey = false): EntityCollection {
  548.         $criteria = new Criteria();
  549.         $criteria->addAssociation('pool');
  550.         if ($count > 0) {
  551.             $criteria->setLimit($count);
  552.         } else {
  553.             $criteria->setLimit(500);
  554.         }
  555.         $criteria->addFilter(new EqualsFilter('poolId', $poolId));
  556.         $criteria->addFilter(new EqualsFilter('active', true));
  557.         $criteria->addFilter(new EqualsFilter('delivered', false));
  558.         $criteria->addFilter(new EqualsFilter('sold', false));
  559.         $criteria->addFilter(new EqualsFilter('reserved', false));
  560.         if ($noMultiKey) $criteria->addFilter(new EqualsFilter('isMultiKey', false));
  562.         return $this->licenseRepository->search($criteria, $context)->getEntities();
  563.     }
  566.     /**
  567.      * @param string $poolId
  568.      * @param Context $context
  569.      * @param int $count
  570.      * @return LicenseKeyCollection
  571.      */
  572.     public function getMultiKey(string $poolId, Context $context, int $count): LicenseKeyCollection {
  573.         $criteria = new Criteria();
  574.         $criteria->addAssociation('pool');
  575.         $criteria->setLimit(500);
  576.         $criteria->addFilter(new EqualsFilter('poolId', $poolId));
  577.         $criteria->addFilter(new EqualsFilter('active', true));
  578.         $criteria->addFilter(new EqualsFilter('delivered', false));
  579.         $criteria->addFilter(new EqualsFilter('sold', false));
  580.         $criteria->addFilter(new EqualsFilter('reserved', false));
  581.         $criteria->addFilter(new EqualsFilter('isMultiKey', true));
  583.         $keys = $this->licenseRepository->search($criteria, $context)->getEntities();
  585.         $list = new LicenseKeyCollection ();
  587.         /** @var LicenseKeyEntity $key */
  588.         foreach ($keys as $key) {
  589.             if ($key->isMultiKey()) {
  590.                 $criteria = new Criteria();
  591.                 $criteria->setLimit(500);
  592.                 $criteria->addFilter(new EqualsFilter('reserved', true));
  593.                 $criteria->addFilter(new EqualsFilter('sold', false));
  594.                 $criteria->addFilter(new EqualsFilter('deliverd', false));
  595.                 $criteria->addFilter(new EqualsFilter('keyId', $key->id));
  596.                 $reserved = $this->licenseMultiKeyLogRepository->search($criteria, $context)->getEntities()->count();
  598.                 if (($key->getMultiKeyLimit() - $key->getMultiKeyUsed() - $reserved) < $count) {
  599.                     continue;
  600.                 } else if (($key->getMultiKeyLimit() - $key->getMultiKeyUsed() - $reserved) >= $count) {
  601.                     $list->add($key);
  602.                     return $list;
  603.                 }
  604.             }
  605.         }
  606.         return $list;
  607.     }
  609.     /**
  610.      * @param string $id
  611.      * @param Context $context
  612.      * @return int
  613.      */
  614.     public function getReservedCountMultiKey(string $id, Context $context): int {
  615.         $count = 0;
  616.         $criteria = new Criteria();
  617.         $criteria->setLimit(500);
  618.         $criteria->addFilter(new EqualsFilter('reserved', true));
  619.         $criteria->addFilter(new EqualsFilter('sold', false));
  620.         $criteria->addFilter(new EqualsFilter('deliverd', false));
  621.         $criteria->addFilter(new EqualsFilter('keyId', $id));
  622.         /** @var LicenseMultiKeyLogEntity $key */
  623.         foreach ($this->licenseMultiKeyLogRepository->search($criteria, $context)->getEntities() as $key) {
  624.             $count += $key->getCount();
  625.         }
  627.         return $count;
  628.     }
  630.     /**
  631.      * @param OrderEntity $order
  632.      * @param Context $context
  633.      * @param bool $isResend
  634.      * @return EntityCollection
  635.      */
  636.     private function getKeysToBeSent(OrderEntity $order, Context $context, bool $isResend = false): EntityCollection {
  637.         $criteria = new Criteria();
  638.         $criteria->setLimit(500);
  639.         $criteria->addAssociation('pool.medialist');
  640.         $criteria->addAssociation('product');
  641.         $criteria->addAssociation('order');
  642.         $criteria->addAssociation('order.billingAddress');
  643.         $criteria->addAssociation('order.deliveries');
  644.         $criteria->addAssociation('order.lineItems');
  645.         $criteria->addAssociation('order.transactions');
  646.         $criteria->addAssociation('order.currency');
  647.         $criteria->addAssociation('order.language');
  648.         $criteria->addAssociation('order.addresses');
  649.         $criteria->addAssociation('customer');
  650.         $criteria->addAssociation('customer.salutation');
  651.         $criteria->addAssociation('customer.addresses');
  652.         $criteria->addAssociation('customer.language');
  653.         $criteria->addFilter(new EqualsFilter('orderId', $order->getId()));
  654.         $criteria->addFilter(new EqualsFilter('active', true));
  655.         if (!$isResend) {
  656.             $criteria->addFilter(new EqualsFilter('delivered', false));
  657.         }
  658.         $criteria->addFilter(new EqualsFilter('reserved', true));
  659.         $criteria->addSorting(new FieldSorting("createdAt", "ASC"));
  660.         $list = $this->licenseRepository->search($criteria, $context)->getEntities();
  663.         if ($list->count() <= 0) {
  664.             $criteria = new Criteria();
  665.             $criteria->setLimit(500);
  666.             $criteria->addAssociation('key');
  667.             $criteria->addAssociation('key.pool');
  668.             $criteria->addAssociation('key.pool.medialist');
  669.             $criteria->addAssociation('product');
  670.             $criteria->addAssociation('order');
  671.             $criteria->addAssociation('order.billingAddress');
  672.             $criteria->addAssociation('order.deliveries');
  673.             $criteria->addAssociation('order.lineItems');
  674.             $criteria->addAssociation('order.transactions');
  675.             $criteria->addAssociation('order.currency');
  676.             $criteria->addAssociation('order.language');
  677.             $criteria->addAssociation('order.addresses');
  678.             $criteria->addAssociation('customer');
  679.             $criteria->addAssociation('customer.salutation');
  680.             $criteria->addAssociation('customer.addresses');
  681.             $criteria->addAssociation('customer.language');
  682.             $criteria->addFilter(new EqualsFilter('orderId', $order->getId()));
  683.             if (!$isResend) {
  684.                 $criteria->addFilter(new EqualsFilter('deliverd', false));
  685.             }
  686.             $criteria->addFilter(new EqualsFilter('reserved', true));
  687.             $criteria->addSorting(new FieldSorting("createdAt", "ASC"));
  688.             $list = $this->licenseMultiKeyLogRepository->search($criteria, $context)->getEntities();
  689.         }
  691.         return $list;
  692.     }
  694.     /**
  695.      * @param LicensePoolEntity $pool
  696.      * @param Context $context
  697.      * @return EntityCollection
  698.      */
  699.     private function getUrls(LicensePoolEntity $pool, Context $context): EntityCollection {
  700.         $criteria = new Criteria();
  701.         $criteria->setLimit(500);
  702.         $criteria->addFilter(new EqualsFilter('poolId', $pool->getId()));
  703.         return $this->licenseUrlRepository->search($criteria, $context)->getEntities();
  704.     }
  706.     /**
  707.      * @param OrderEntity $order
  708.      * @param Context $context
  709.      */
  710.     private function updateOrderState(OrderEntity $order, Context $context) {
  711.         $containsNoDigitalProduct = false;
  713.         /** @var OrderLineItemEntity $lineItem */
  714.         foreach ($order->getLineItems() as $lineItem) {
  715.             if ($lineItem->getType() === "product") {
  716.                 if (isset($lineItem->getPayload()['isLicense'])) {
  717.                     if ($lineItem->getPayload()['isLicense'] !== null) {
  718.                         if (!$lineItem->getPayload()['isLicense']) {
  719.                             $containsNoDigitalProduct = true;
  720.                         }
  721.                     } else {
  722.                         $containsNoDigitalProduct = true;
  723.                     }
  724.                 } else {
  725.                     $containsNoDigitalProduct = true;
  726.                 }
  727.             }
  728.         }
  730.         try {
  731.             if ($this->config['CogiLicenseManager.config.deliveryStatus'] != null && !$containsNoDigitalProduct) {
  734.                 $criteria = new Criteria();
  735.                 $criteria->setLimit(1);
  736.                 $criteria->addFilter(new EqualsFilter('orderId', $order->getId()));
  738.                 /** @var OrderDeliveryEntity $result */
  739.                 $result = $this->orderDeliveryRepository->search($criteria, $context)->getEntities()->first();
  741.                 if (isset($result)) {
  742.                     $this->orderDeliveryRepository->update([
  743.                         [
  744.                             'id' => $result->getId(),
  745.                             'stateId' => $this->config['CogiLicenseManager.config.deliveryStatus'],
  746.                         ]
  747.                     ], Context::createDefaultContext());
  748.                 }
  751.                 if ($this->config['CogiLicenseManager.config.orderStatus'] != null) {
  752.                     $this->orderRepository->update([
  753.                         [
  754.                             'id' => $order->getId(),
  755.                             'stateId' => $this->config['CogiLicenseManager.config.orderStatus'],
  756.                         ]
  757.                     ], Context::createDefaultContext());
  758.                 }
  761.             } else if ($this->config['CogiLicenseManager.config.deliveryStatusPartial'] != null && $containsNoDigitalProduct) {
  763.                 $criteria = new Criteria();
  764.                 $criteria->setLimit(1);
  765.                 $criteria->addFilter(new EqualsFilter('orderId', $order->getId()));
  767.                 /** @var OrderDeliveryEntity $result */
  768.                 $result = $this->orderDeliveryRepository->search($criteria, $context)->getEntities()->first();
  770.                 if (isset($result)) {
  771.                     $this->orderDeliveryRepository->update([
  772.                         [
  773.                             'id' => $result->getId(),
  774.                             'stateId' => $this->config['CogiLicenseManager.config.deliveryStatusPartial'],
  775.                         ]
  776.                     ], Context::createDefaultContext());
  777.                 }
  778.             }
  779.         } catch (Exception $e) {
  780.         }
  781.     }
  783.     /**
  784.      * Returns transaction.
  785.      *
  786.      * @param OrderEntity $order
  787.      *
  788.      * @return OrderTransactionEntity|null
  789.      *
  790.      * @throws InconsistentCriteriaIdsException
  791.      */
  792.     private function getTransaction(OrderEntity $order): ?OrderTransactionEntity {
  793.         $context = new Context(new SystemSource());
  795.         $criteria = new Criteria();
  796.         $criteria->setLimit(500);
  797.         $criteria->addFilter(new EqualsFilter('orderId', $order->getId()));
  799.         return $this->orderTransactionRepository->search($criteria, $context)->first();
  800.     }
  803.     /**
  804.      * @param string $productId
  805.      * @param string $poolId
  806.      * @return float|int
  807.      * @throws \Doctrine\DBAL\Exception
  808.      */
  809.     public function updateProductStock(string $productId, string $poolId) {
  810. //        if(!$this->config['CogiLicenseManager.config.stockupdate']) {
  811. //            return -1;
  812. //        }
  814.         $context = new Context(new SystemSource());
  816.         $criteria = new Criteria();
  817.         $criteria->addFilter(new EqualsFilter('poolId', $poolId));
  818.         $criteria->addFilter(new EqualsFilter('active', true));
  819.         $criteria->addFilter(new EqualsFilter('delivered', false));
  820.         $criteria->addFilter(new EqualsFilter('sold', false));
  821.         $criteria->addFilter(new EqualsFilter('reserved', false));
  822.         /** @var LicenseKeyCollection $licenses */
  823.         $licenses = $this->licenseRepository->search($criteria, $context)->getEntities();
  826.         $criteria = new Criteria();
  827.         $criteria->addFilter(new EqualsFilter('productId', $productId));
  828.         /** @var LicenseProductEntity $product */
  829.         $product = $this->licenseProductRepository->search($criteria, $context)->getEntities()->first();
  831.         $count = $product->getCount();
  832.         $stock = 0;
  834.         /** @var LicenseKeyEntity $license */
  835.         foreach ($licenses as $license) {
  836.             if ($license->isMultiKey()) {
  837.                 $i = $license->getMultiKeyLimit() - $license->getMultiKeyUsed();
  838.                 if ($i > 0) {
  839.                     $stock += $i;
  840.                 }
  841.             } else {
  842.                 $stock++;
  843.             }
  844.         }
  846.         if ($stock > 1) {
  847.             if (($stock / $count) < 1) {
  848.                 $stock = 0;
  849.             } else {
  850.                 $i = ($stock / $count);
  851.                 $stock = round($i, 0, PHP_ROUND_HALF_DOWN);
  852.                 if ($stock < 1) $stock = 1;
  853.             }
  854.         }
  856. //        $this->productRepository->update([
  857. //            [
  858. //                'id' => $productId,
  859. //                'stock' => intval($stock),
  860. //                'availableStock' => intval($stock),
  861. //                'max_purchase' => intval($stock),
  862. //            ]
  863. //        ], Context::createDefaultContext());
  865.         /** @var Connection $connection */
  866.         $connection = $this->container->get(Connection::class);
  867.         $connection->executeStatement("UPDATE `product` SET `stock` = :stock, `available_stock` = :stock, `max_purchase` = :stock WHERE `id` = UNHEX(:id);", [
  868.             'id' => $productId,
  869.             'stock' => intval($stock)
  870.         ]);
  872.         return $stock;
  873.     }
  875.     /**
  876.      * Email an den Kunden senden
  877.      * @param LicenseEmailEntity $licenseEmail
  878.      * @param MailTemplateEntity $mailTemplate
  879.      */
  880.     private function sendEmail(LicenseEmailEntity $licenseEmail, MailTemplateEntity $mailTemplate) {
  881.         $recipients = [
  882.             $licenseEmail->getCustomer()->getEmail() => $licenseEmail->getCustomer()->getFirstName() . ' ' . $licenseEmail->getCustomer()->getLastName()
  883.         ];
  885.         $context = new Context(new SystemSource());
  887.         $attachments = [];
  888.         $data = new DataBag();
  890.         $data->set('recipients', $recipients);
  891.         $data->set('senderName', $mailTemplate->getSenderName());
  892.         $data->set('salesChannelId', $licenseEmail->getOrder()->getSalesChannelId());
  894.         $data->set('contentHtml', $mailTemplate->getContentHtml());
  895.         $data->set('contentPlain', $mailTemplate->getContentPlain());
  896.         $data->set('subject', $mailTemplate->getSubject());
  899.         if ($licenseEmail->getMediaList() !== null) {
  900.             foreach ($licenseEmail->getMediaList()->getElements() as $mailTemplateMedia) {
  901.                 $attachments[] = $this->mediaService->getAttachment($mailTemplateMedia, $context);
  902.             }
  903.         }
  905.         $data->set('binAttachments', $attachments);
  907.         $this->mailService->send($data->all(), $context, [
  908.             'licenseEmail' => $licenseEmail,
  909.         ]);
  910.     }
  912.     /**
  913.      * @param LicenseEmailEntity $licenseEmail
  914.      * @param MailTemplateEntity $mailTemplate
  915.      */
  916.     private function sendAdminMail(LicenseEmailEntity $licenseEmail, MailTemplateEntity $mailTemplate) {
  917.         if (isset($this->config['CogiLicenseManager.config.storeMail'])) {
  918.             if (isset($this->config['CogiLicenseManager.config.sendAdminMail'])) {
  919.                 if ($this->config['CogiLicenseManager.config.sendAdminMail']) {
  920.                     $recipients = [
  921.                         $this->config['CogiLicenseManager.config.storeMail'] => 'SHOP'
  922.                     ];
  924.                     $context = new Context(new SystemSource());
  926.                     $attachments = [];
  927.                     $data = new DataBag();
  929.                     $data->set('recipients', $recipients);
  930.                     $data->set('senderName', $mailTemplate->getSenderName());
  931.                     $data->set('salesChannelId', $licenseEmail->getOrder()->getSalesChannelId());
  933.                     $data->set('contentHtml', $mailTemplate->getContentHtml());
  934.                     $data->set('contentPlain', $mailTemplate->getContentPlain());
  935.                     $data->set('subject', $mailTemplate->getSubject());
  938.                     if ($licenseEmail->getMediaList() !== null) {
  939.                         foreach ($licenseEmail->getMediaList()->getElements() as $mailTemplateMedia) {
  940.                             $attachments[] = $this->mediaService->getAttachment($mailTemplateMedia, $context);
  941.                         }
  942.                     }
  944.                     $data->set('binAttachments', $attachments);
  947.                     $this->mailService->send($data->all(), $context, [
  948.                         'licenseEmail' => $licenseEmail
  949.                     ]);
  950.                 }
  951.             }
  952.         }
  953.     }
  955.     /**
  956.      * @param LicenseEmailEntity $licenseEmail
  957.      * @param MailTemplateEntity $mailTemplate
  958.      */
  959.     private function sendEmptyPoolMail(LicenseEmailEntity $licenseEmail, MailTemplateEntity $mailTemplate) {
  960.         if (isset($this->config['CogiLicenseManager.config.storeMail'])) {
  961.             if (isset($this->config['CogiLicenseManager.config.sendMailKeyEmpty'])) {
  962.                 if ($this->config['CogiLicenseManager.config.sendMailKeyEmpty']) {
  963.                     $recipients = [
  964.                         $this->config['CogiLicenseManager.config.storeMail'] => 'SHOP'
  965.                     ];
  967.                     $context = new Context(new SystemSource());
  969.                     $attachments = [];
  970.                     $data = new DataBag();
  972.                     $data->set('recipients', $recipients);
  973.                     $data->set('senderName', $mailTemplate->getSenderName());
  974.                     $data->set('salesChannelId', $licenseEmail->getOrder()->getSalesChannelId());
  976.                     $data->set('contentHtml', $mailTemplate->getContentHtml());
  977.                     $data->set('contentPlain', $mailTemplate->getContentPlain());
  978.                     $data->set('subject', $mailTemplate->getSubject());
  981.                     if ($licenseEmail->getMediaList() !== null) {
  982.                         foreach ($licenseEmail->getMediaList()->getElements() as $mailTemplateMedia) {
  983.                             $attachments[] = $this->mediaService->getAttachment($mailTemplateMedia, $context);
  984.                         }
  985.                     }
  987.                     $data->set('binAttachments', $attachments);
  990.                     $this->mailService->send($data->all(), $context, [
  991.                         'licenseEmail' => $licenseEmail
  992.                     ]);
  993.                 }
  994.             }
  995.         }
  996.     }
  997. }