593 lines
25 KiB
PHP
593 lines
25 KiB
PHP
<?php
|
|
|
|
namespace KupShop\GraphQLBundle\ApiAdmin\Util;
|
|
|
|
use KupShop\AdminBundle\Util\Filter\OrdersFilterSpecs;
|
|
use KupShop\DropshipBundle\Util\DropshipmentUtil;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Collection\OrderCollection;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Enums\Order\OrderDocumentType;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Order\Input\OrderCreateInput;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Order\Input\OrderStornoInput;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Order\Input\OrderUpdateInput;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Order\Order;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Order\OrderDocument;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Order\Response\OrderMutateResponse;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Parameters;
|
|
use KupShop\GraphQLBundle\ApiAdmin\Types\Purchase\Input\PurchaseCalculateInput;
|
|
use KupShop\GraphQLBundle\ApiShared\ApiUtil;
|
|
use KupShop\GraphQLBundle\Exception\GraphQLNotFoundException;
|
|
use KupShop\GraphQLBundle\Exception\GraphQLValidationException;
|
|
use KupShop\KupShopBundle\Config;
|
|
use KupShop\KupShopBundle\Context\ContextManager;
|
|
use KupShop\KupShopBundle\Context\CountryContext;
|
|
use KupShop\KupShopBundle\Context\CurrencyContext;
|
|
use KupShop\KupShopBundle\Context\LanguageContext;
|
|
use KupShop\KupShopBundle\Email\OrderMessageEmail;
|
|
use KupShop\KupShopBundle\Exception\UnknownEmailTypeException;
|
|
use KupShop\KupShopBundle\Util\Contexts;
|
|
use KupShop\KupShopBundle\Util\Mail\EmailLocator;
|
|
use KupShop\KupShopBundle\Util\ObjectUtil;
|
|
use KupShop\KupShopBundle\Util\Price\Price;
|
|
use KupShop\OrderingBundle\Entity\Order\OrderItem;
|
|
use KupShop\OrderingBundle\Entity\Purchase\PurchaseState;
|
|
use KupShop\OrderingBundle\OrderList\OrderList;
|
|
use KupShop\OrderingBundle\Util\Order\OrderInfo;
|
|
use KupShop\OrderingBundle\Util\Purchase\PurchaseUtil;
|
|
use Query\Operator;
|
|
use Query\QueryBuilder;
|
|
|
|
class OrderUtil
|
|
{
|
|
/** @var OrderList */
|
|
private $orderList;
|
|
|
|
public function __construct(
|
|
private readonly OrdersFilterSpecs $ordersFilterSpecs,
|
|
private readonly EmailLocator $emailLocator,
|
|
private readonly \KupShop\GraphQLBundle\ApiAdmin\Util\PurchaseUtil $graphqlPurchaseUtil,
|
|
private readonly PurchaseUtil $purchaseUtil,
|
|
private readonly ContextManager $contextManager,
|
|
private readonly ?DropshipmentUtil $dropshipmentUtil,
|
|
) {
|
|
}
|
|
|
|
public function getOrder(int $id): ?Order
|
|
{
|
|
$orderList = $this->getOrderList();
|
|
$orderList->andSpec(Operator::equals(['o.id' => $id]));
|
|
|
|
$orders = $orderList->getOrders();
|
|
|
|
if (!($order = $orders->current())) {
|
|
throw new GraphQLNotFoundException('Order not found');
|
|
}
|
|
|
|
$order->productList->fetchPhotos('product_gallery', ['Y', 'N']);
|
|
|
|
return new Order($order, $orders);
|
|
}
|
|
|
|
public function getOrders(?int $offset, int $limit, ?Parameters $sort, ?Parameters $filter): OrderCollection
|
|
{
|
|
$sortValues = $sort ? array_filter($sort->getData()) : [];
|
|
$filterValues = $filter ? array_filter($filter->getData()) : [];
|
|
|
|
$orderList = clone $this->orderList;
|
|
|
|
// limit
|
|
$orderList->limit(ApiUtil::getLimit($limit), $offset);
|
|
|
|
// sorting
|
|
foreach ($sortValues as $field => $sortValue) {
|
|
$orderList->andSpec(function (QueryBuilder $qb) use ($field, $sortValue) {
|
|
$qb->addOrderBy($field, $sortValue->value);
|
|
});
|
|
}
|
|
|
|
if ($specs = $this->getOrdersFilterSpecs($filterValues)) {
|
|
$orderList->andSpec(Operator::andX($specs));
|
|
}
|
|
|
|
return (new OrderCollection($orderList->getOrders($totalCount)))
|
|
->setItemsTotalCount($totalCount ?? 0)
|
|
->setLimit($limit)
|
|
->setOffset($offset);
|
|
}
|
|
|
|
public function stornoOrder(OrderStornoInput $input): OrderMutateResponse
|
|
{
|
|
try {
|
|
$order = \Order::get($input->id);
|
|
} catch (\InvalidArgumentException $e) {
|
|
throw new GraphQLNotFoundException($e->getMessage());
|
|
}
|
|
|
|
if ($order->status_storno == 1) {
|
|
throw new GraphQLValidationException('Cannot cancel order! Order is already cancelled.');
|
|
}
|
|
|
|
$stornoHistoryMessage = '[API] Stornování objednávky.';
|
|
if ($input->message) {
|
|
$stornoHistoryMessage .= 'Důvod: '.$input->message;
|
|
}
|
|
|
|
$order->logHistory($stornoHistoryMessage);
|
|
$order->storno(false, $input->message, $input->sendMail);
|
|
|
|
return new OrderMutateResponse(true, $this->getOrder($input->id));
|
|
}
|
|
|
|
public function updateOrder(OrderUpdateInput $input): OrderMutateResponse
|
|
{
|
|
try {
|
|
$order = \Order::get($input->id);
|
|
} catch (\InvalidArgumentException $e) {
|
|
throw new GraphQLNotFoundException($e->getMessage());
|
|
}
|
|
|
|
$updateLog = [];
|
|
|
|
// aktualizace polozek objednavky
|
|
if (ObjectUtil::isPropertyInitialized($input, 'items')) {
|
|
foreach ($input->items ?: [] as $item) {
|
|
if (!ObjectUtil::isPropertyInitialized($item, 'id') || empty($item->id)) {
|
|
throw new GraphQLValidationException(
|
|
'OrderUpdateInput.items.id: Item ID is mandatory when updating order items!'
|
|
);
|
|
}
|
|
|
|
/** @var OrderItem $orderItem */
|
|
$orderItem = $order->getItems()[$item->id] ?? false;
|
|
|
|
if (!$orderItem) {
|
|
throw new GraphQLValidationException(
|
|
sprintf('OrderUpdateInput.items: Item with ID "%s" is not included in the order!', $item->id)
|
|
);
|
|
}
|
|
|
|
if (ObjectUtil::isPropertyInitialized($item, 'delete')) {
|
|
if ($item->delete === true) {
|
|
$order->deleteItem($item->id);
|
|
$updateLog[] = "Smazání položky \"{$item->id}\": {$orderItem->getDescr()}; {$orderItem->getPieces()} ks";
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (ObjectUtil::isPropertyInitialized($item, 'quantity')) {
|
|
if ($item->quantity < 0) {
|
|
throw new GraphQLValidationException(
|
|
'OrderUpdateInput.items.quantity: Quantity cannot be negative value!'
|
|
);
|
|
}
|
|
|
|
// aktualizace poctu kusu u polozky
|
|
if ($orderItem->getPieces() != $item->quantity) {
|
|
$order->updateItem($item->id, $item->quantity);
|
|
$updateLog[] = "Aktualizace položky \"{$item->id}\": {$orderItem->getDescr()}; {$orderItem->getPieces()} -> {$item->quantity} ks";
|
|
}
|
|
}
|
|
}
|
|
|
|
// smazani items cache, aby se pripadne polozky prenacetly podle aktualniho stavu
|
|
$order->items = [];
|
|
}
|
|
|
|
// aktualizace cisla baliku
|
|
if (ObjectUtil::isPropertyInitialized($input, 'packageId')) {
|
|
$order->setPackageId($input->packageId);
|
|
$updateLog[] = "Nastaveno číslo balíku: {$input->packageId}";
|
|
}
|
|
|
|
// custom faktura - TODO: odebrat az si to na sartoru zmeni
|
|
if (ObjectUtil::isPropertyInitialized($input, 'invoiceUrl') && !ObjectUtil::isPropertyInitialized($input, 'documents')) {
|
|
$document = new OrderDocument();
|
|
$document->type = OrderDocumentType::from('order_invoice');
|
|
$document->url = $input->invoiceUrl;
|
|
$input->documents = [$document];
|
|
}
|
|
|
|
// custom doklady
|
|
if (ObjectUtil::isPropertyInitialized($input, 'documents')) {
|
|
$externalDocuments = $order->getData('externalDocuments') ?: [];
|
|
foreach ($input->documents ?: [] as $document) {
|
|
$externalDocuments[$document->type->getValue()] = $document->url;
|
|
$updateLog[] = sprintf('Nastaven doklad <strong>%s</strong>: <a href="%2$s" target="_blank">%2$s</a>', $document->type->getValue(), $document->url);
|
|
}
|
|
$order->setData('externalDocuments', $externalDocuments);
|
|
}
|
|
|
|
if (ObjectUtil::isPropertyInitialized($input, 'userId')) {
|
|
if (!$this->checkUserExists($input->userId)) {
|
|
throw new GraphQLNotFoundException(sprintf('User with ID %s was not found!', $input->userId));
|
|
}
|
|
|
|
$order->assignUser($input->userId);
|
|
}
|
|
|
|
// zmena stavu objednavky
|
|
if (ObjectUtil::isPropertyInitialized($input, 'status') && $input->status) {
|
|
if (!(getOrderStatuses()[$input->status->id] ?? false)) {
|
|
throw new GraphQLNotFoundException(
|
|
sprintf('Status with ID "%s" was not found!', $input->status->id)
|
|
);
|
|
}
|
|
|
|
if ($input->status->comment) {
|
|
$order->logHistory($input->status->comment);
|
|
}
|
|
|
|
if ($input->status->emailType) {
|
|
try {
|
|
$this->emailLocator->getEmailService($input->status->emailType);
|
|
} catch (UnknownEmailTypeException) {
|
|
throw new GraphQLValidationException(
|
|
sprintf('Email type "%s" does not exists!', $input->status->emailType)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!$input->status->userMessage) {
|
|
$input->status->userMessage = $this->getOrderMessageByStatus($input->status->id);
|
|
}
|
|
|
|
if (ObjectUtil::isPropertyInitialized($input->status, 'sendEmail')) {
|
|
$sendEmail = $input->status->sendEmail;
|
|
}
|
|
|
|
$order->changeStatus(
|
|
$input->status->id,
|
|
null,
|
|
$sendEmail ?? null,
|
|
$input->status->userMessage,
|
|
$input->status->emailType,
|
|
);
|
|
}
|
|
|
|
// zaloguju info o zmenach, ktere byly behem API volani provedeny
|
|
if (!empty($updateLog)) {
|
|
$order->logHistory('<strong>[API] Byly provedeny následující aktualizace:</strong><br>'.implode('<br>', array_map(fn ($x) => "- {$x}", $updateLog)));
|
|
}
|
|
|
|
return new OrderMutateResponse(true, $this->getOrder($input->id));
|
|
}
|
|
|
|
private function getOrderMessageByStatus(int $statusId): ?string
|
|
{
|
|
$email = sqlQueryBuilder()
|
|
->select('name')
|
|
->from('emails')
|
|
->where(
|
|
Operator::equals(
|
|
[
|
|
'enabled' => 'Y',
|
|
'type' => OrderMessageEmail::getType(),
|
|
'order_status' => $statusId,
|
|
]
|
|
)
|
|
)->execute()->fetchOne();
|
|
|
|
if ($email) {
|
|
return $email;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public function getOrdersFilterSpecs(array $filterValues): ?callable
|
|
{
|
|
$specs = [];
|
|
$filter = [];
|
|
|
|
if ($filterValues['id'] ?? false) {
|
|
$specs[] = Operator::inIntArray((array) $filterValues['id'], 'o.id');
|
|
}
|
|
|
|
if ($filterValues['code'] ?? false) {
|
|
$codeFilter = (array) $filterValues['code'];
|
|
|
|
if (count($codeFilter) === 1) {
|
|
$specs[] = Operator::equals(['o.order_no' => reset($codeFilter)]);
|
|
} else {
|
|
$specs[] = Operator::inIntArray((array) $filterValues['code'], 'o.order_no');
|
|
}
|
|
}
|
|
|
|
if (!empty($filterValues['dateCreated'])) {
|
|
$specs[] = ApiUtil::getDateTimeFilter($filterValues['dateCreated'], 'o.date_created');
|
|
}
|
|
|
|
if (!empty($filterValues['dateUpdated'])) {
|
|
$specs[] = ApiUtil::getDateTimeFilter($filterValues['dateUpdated'], 'o.date_updated');
|
|
}
|
|
|
|
if ($filterValues['status'] ?? false) {
|
|
$filter['statuses'] = (array) $filterValues['status'];
|
|
}
|
|
|
|
if ($filterValues['userId'] ?? false) {
|
|
$filter['reg_users'] = (array) $filterValues['userId'];
|
|
}
|
|
|
|
if ($filterValues['deliveryId'] ?? false) {
|
|
$filter['deliveries'] = (array) $filterValues['deliveryId'];
|
|
}
|
|
|
|
if ($filterValues['paymentId'] ?? false) {
|
|
$filter['payments'] = (array) $filterValues['paymentId'];
|
|
}
|
|
|
|
if ($filterValues['sellerId'] ?? false) {
|
|
$filter['sellers'] = (array) $filterValues['sellerId'];
|
|
}
|
|
|
|
if ($filterValues['source'] ?? false) {
|
|
$filter['source'] = (array) $filterValues['source'];
|
|
}
|
|
|
|
if ($filterValues['dropshipId'] ?? false) {
|
|
$filter['dropship'] = (array) $filterValues['dropshipId'];
|
|
}
|
|
|
|
// deprecated - just backward compatibility
|
|
if (($filterValues['date_created']['from'] ?? false) || ($filterValues['date_created']['to'] ?? false)) {
|
|
$from = ApiUtil::prepareDateTimeForDB($filterValues['date_created']['from'] ?? null);
|
|
$to = ApiUtil::prepareDateTimeForDB($filterValues['date_created']['to'] ?? null);
|
|
|
|
$specs[] = Operator::between(
|
|
'o.date_created',
|
|
new \Range($from, $to)
|
|
);
|
|
}
|
|
|
|
return $this->ordersFilterSpecs->getSpecs($filter, $specs);
|
|
}
|
|
|
|
private function getOrderList(): OrderList
|
|
{
|
|
return clone $this->orderList;
|
|
}
|
|
|
|
/**
|
|
* @required
|
|
*/
|
|
public function setOrderList(OrderList $orderList): void
|
|
{
|
|
$this->orderList = $orderList;
|
|
}
|
|
|
|
public function createOrder(OrderCreateInput $orderCreateInput, array $fetchOptions = []): OrderMutateResponse
|
|
{
|
|
$this->validateOrderCreateInput($orderCreateInput);
|
|
|
|
return sqlGetConnection()->transactional(function () use ($orderCreateInput, $fetchOptions) {
|
|
return $this->contextManager->activateContexts([CountryContext::class => $orderCreateInput->deliveryAddress?->country ?? $orderCreateInput->invoiceAddress->country],
|
|
function () use ($orderCreateInput, $fetchOptions) {
|
|
$purchaseCalculateInput = new PurchaseCalculateInput();
|
|
$purchaseCalculateInput->items = $orderCreateInput->items;
|
|
$purchaseCalculateInput->coupons = $orderCreateInput->coupons ?? [];
|
|
|
|
$purchaseStateInfo = $this->graphqlPurchaseUtil->calculatePurchaseState($purchaseCalculateInput);
|
|
$purchaseState = $purchaseStateInfo->getPurchaseState() ?? new PurchaseState([]);
|
|
|
|
$languageContext = Contexts::get(LanguageContext::class);
|
|
$currencyContext = Contexts::get(CurrencyContext::class);
|
|
|
|
$flags = array_intersect($orderCreateInput->flags ?? [], array_keys(Config::get()['Order']['Flags']));
|
|
|
|
$orderData = [
|
|
'source' => OrderInfo::ORDER_SOURCE_API,
|
|
|
|
'note_invoice' => $orderCreateInput->invoice->note ?? null,
|
|
|
|
'date_created' => ApiUtil::prepareDateTimeForDB($orderCreateInput->dateCreated ?: new \DateTime()),
|
|
'date_accept' => ApiUtil::prepareDateTimeForDB($orderCreateInput->dateAccept) ?: null,
|
|
'date_handle' => ApiUtil::prepareDateTimeForDB($orderCreateInput->dateHandle) ?: null,
|
|
'date_delivered' => ApiUtil::prepareDateTimeForDB($orderCreateInput->dateDelivered) ?: null,
|
|
'date_due' => ApiUtil::prepareDateTimeForDB($orderCreateInput->dateDue) ?: null,
|
|
|
|
'status' => $orderCreateInput->status ?: 0,
|
|
|
|
'id_user' => $orderCreateInput->userId ?? null,
|
|
|
|
// invoice
|
|
'invoice_email' => $orderCreateInput->invoiceAddress->email,
|
|
'invoice_name' => $orderCreateInput->invoiceAddress->name,
|
|
'invoice_surname' => $orderCreateInput->invoiceAddress->surname,
|
|
'invoice_phone' => $orderCreateInput->invoiceAddress->phone ?? '',
|
|
'invoice_firm' => $orderCreateInput->invoiceAddress->firm ?? '',
|
|
'invoice_ico' => $orderCreateInput->invoiceAddress->ico ?? '',
|
|
'invoice_dic' => $orderCreateInput->invoiceAddress->dic ?? '',
|
|
'invoice_street' => $orderCreateInput->invoiceAddress->street ?? '',
|
|
'invoice_city' => $orderCreateInput->invoiceAddress->city ?? '',
|
|
'invoice_zip' => $orderCreateInput->invoiceAddress->zip ?? '',
|
|
'invoice_custom_address' => $orderCreateInput->invoiceAddress->customAddress ?? '',
|
|
'invoice_state' => $orderCreateInput->invoiceAddress->state ?? '',
|
|
'invoice_country' => $orderCreateInput->invoiceAddress->country ?? '',
|
|
|
|
// delivery
|
|
'delivery_name' => $orderCreateInput->deliveryAddress->name ?? $orderCreateInput->invoiceAddress->name ?? '',
|
|
'delivery_surname' => $orderCreateInput->deliveryAddress->surname ?? $orderCreateInput->invoiceAddress->surname ?? '',
|
|
'delivery_firm' => $orderCreateInput->deliveryAddress->firm ?? $orderCreateInput->invoiceAddress->firm ?? '',
|
|
'delivery_street' => $orderCreateInput->deliveryAddress->street ?? $orderCreateInput->invoiceAddress->street ?? '',
|
|
'delivery_city' => $orderCreateInput->deliveryAddress->city ?? $orderCreateInput->invoiceAddress->city ?? '',
|
|
'delivery_zip' => $orderCreateInput->deliveryAddress->zip ?? $orderCreateInput->invoiceAddress->zip ?? '',
|
|
'delivery_country' => $orderCreateInput->deliveryAddress->country ?? $orderCreateInput->invoiceAddress->country ?? '',
|
|
'delivery_state' => $orderCreateInput->deliveryAddress->state ?? $orderCreateInput->invoiceAddress->state ?? '',
|
|
'delivery_custom_address' => $orderCreateInput->deliveryAddress->customAddress ?? $orderCreateInput->invoiceAddress->customAddress ?? '',
|
|
'delivery_phone' => $orderCreateInput->deliveryAddress->phone ?? $orderCreateInput->invoiceAddress->phone ?? '',
|
|
'delivery_email' => $orderCreateInput->deliveryAddress->email ?? '',
|
|
|
|
'flags' => implode(',', $flags),
|
|
|
|
'note_user' => $orderCreateInput->noteUser ?? '',
|
|
];
|
|
|
|
$customData = [];
|
|
foreach ($orderCreateInput->data ?? [] as $data) {
|
|
$customData[$data->key] = $data->value;
|
|
}
|
|
|
|
$orderData['note_admin'] = json_encode($customData);
|
|
|
|
if (findModule(\Modules::INVOICES) && $orderCreateInput->invoice && ObjectUtil::isPropertyInitialized($orderCreateInput->invoice, 'code')) {
|
|
$orderData['invoice_no'] = $orderCreateInput->invoice->code ?? null;
|
|
}
|
|
|
|
if (findModule(\Modules::CURRENCIES)) {
|
|
$orderData['id_language'] = $orderCreateInput->language ?? $languageContext->getDefaultId();
|
|
$orderData['currency'] = $orderCreateInput->currency ?? $currencyContext->getDefaultId();
|
|
$orderData['currency_rate'] = $orderCreateInput->currencyRate ?? $currencyContext->getOrDefault($orderData['currency'])->getRate();
|
|
}
|
|
|
|
$purchaseState->setSource(OrderInfo::ORDER_SOURCE_API);
|
|
|
|
if ($deliveryId = $orderCreateInput->deliveryType?->id ?? false) {
|
|
$deliveryType = \DeliveryType::get($deliveryId, true);
|
|
|
|
$purchaseState->setDeliveryType($deliveryType);
|
|
|
|
if (($deliveryPrice = $orderCreateInput->deliveryType?->deliveryPrice) !== null) {
|
|
$deliveryVat = $deliveryType->getPrice()->getVat()->asFloat();
|
|
$price = new Price(toDecimal($deliveryPrice)->removeVat($deliveryVat), $currencyContext->getOrDefault($orderData['currency']), $deliveryVat);
|
|
|
|
$purchaseState->setDeliveryPrice($price);
|
|
}
|
|
}
|
|
|
|
$purchaseState->setCustomData(
|
|
[
|
|
'order' => $orderData,
|
|
]
|
|
);
|
|
|
|
$purchaseState = $this->purchaseUtil->recalculateTotalPrices($purchaseState);
|
|
|
|
$order = $this->purchaseUtil->createOrderFromPurchaseState(
|
|
purchaseState: $purchaseState,
|
|
useDeliveryFromPurchaseState: true,
|
|
onCreatedCallback: fn (int $orderId) => $this->insertOrderDropshipment($orderId, $orderCreateInput)
|
|
);
|
|
|
|
$order->logHistory('[API] Objednávka vznikla přes API');
|
|
// log user note to order so it is visible in history
|
|
if ($orderCreateInput->noteUser) {
|
|
$order->logHistory($orderCreateInput->noteUser);
|
|
}
|
|
|
|
return new OrderMutateResponse(true, $this->getOrder($order->id, $fetchOptions));
|
|
});
|
|
});
|
|
}
|
|
|
|
protected function validateOrderCreateInput(OrderCreateInput $input): void
|
|
{
|
|
if ($this->dropshipmentUtil) {
|
|
if (!$this->dropshipmentUtil->getDropshipment($input->dropshipment->id)) {
|
|
throw new GraphQLValidationException('OrderCreateInput.dropshipment.id: Given dropshipment ID does not exist!');
|
|
}
|
|
|
|
if (empty($input->dropshipment->externalId)) {
|
|
throw new GraphQLValidationException('OrderCreateInput.dropshipment.externalId: Order externalId cannot be empty!');
|
|
}
|
|
|
|
$dropshipmentOrderExists = sqlQueryBuilder()
|
|
->select('id_order')
|
|
->from('order_dropshipment')
|
|
->where(Operator::equals(['id_external' => $input->dropshipment->externalId]))
|
|
->execute()->fetchOne();
|
|
|
|
if ($dropshipmentOrderExists) {
|
|
throw new GraphQLValidationException(
|
|
sprintf('OrderCreateInput.dropshipment.externalId: Order with this external ID already exists!')
|
|
);
|
|
}
|
|
}
|
|
|
|
if ($input->status && !$this->checkOrderStatus($input->status)) {
|
|
throw new GraphQLValidationException('Specified order status is not valid. Use configuration.orderStatuses to get available statuses.');
|
|
}
|
|
|
|
if ($input->invoice) {
|
|
if (ObjectUtil::isPropertyInitialized($input->invoice, 'code') && !empty($input->invoice->code) && $this->checkInvoiceExists($input->invoice->code)) {
|
|
throw new GraphQLValidationException(sprintf('Invoice with this code "%s" already exists', $input->invoice->code));
|
|
}
|
|
}
|
|
|
|
if ($input->language && !$this->checkLanguageValid($input->language)) {
|
|
throw new GraphQLValidationException(sprintf('Language "%s" is not supported.', $input->language));
|
|
}
|
|
|
|
if ($input->currency && !$this->checkCurrencyValid($input->currency)) {
|
|
throw new GraphQLValidationException(sprintf('Currency "%s" is not supported', $input->currency));
|
|
}
|
|
|
|
if ($input->deliveryType?->id && !$this->checkDeliveryTypeValid($input->deliveryType->id)) {
|
|
throw new GraphQLValidationException('Specified delivery type is not valid. Use configuration.deliveryTypes to get available delivery types.');
|
|
}
|
|
|
|
if ($input->userId && !$this->checkUserExists($input->userId)) {
|
|
throw new GraphQLValidationException(sprintf('User with this ID "%s" does not exist', $input->userId));
|
|
}
|
|
}
|
|
|
|
protected function insertOrderDropshipment(int $orderId, OrderCreateInput $input): void
|
|
{
|
|
$dropshipmentData = [];
|
|
foreach ($input->dropshipment->data ?? [] as $data) {
|
|
$dropshipmentData[$data->key] = $data->value;
|
|
}
|
|
|
|
$dropshipment = [
|
|
'id_order' => $orderId,
|
|
'id_dropshipment' => $input->dropshipment->id,
|
|
'id_external' => $input->dropshipment->externalId,
|
|
'data' => json_encode($dropshipmentData),
|
|
];
|
|
|
|
sqlQueryBuilder()
|
|
->insert('order_dropshipment')
|
|
->directValues($dropshipment)
|
|
->execute();
|
|
}
|
|
|
|
public function checkOrderStatus(int $orderStatus): bool
|
|
{
|
|
return in_array($orderStatus, array_keys(getOrderStatuses()));
|
|
}
|
|
|
|
public function checkInvoiceExists(?string $code): bool
|
|
{
|
|
return sqlQueryBuilder()
|
|
->select('id')
|
|
->from('orders')
|
|
->where(Operator::equals(['invoice_no' => $code]))
|
|
->execute()->fetchOne();
|
|
}
|
|
|
|
public function checkLanguageValid(string $language): bool
|
|
{
|
|
return isset(Contexts::get(LanguageContext::class)->getAll()[$language]);
|
|
}
|
|
|
|
public function checkCurrencyValid(string $currency): bool
|
|
{
|
|
$currencyContext = Contexts::get(CurrencyContext::class);
|
|
|
|
return $currencyContext->isValid($currency);
|
|
}
|
|
|
|
public function checkDeliveryTypeValid(int $deliveryId): bool
|
|
{
|
|
return \DeliveryType::get($deliveryId, true)->id > 0;
|
|
}
|
|
|
|
public function checkUserExists(int $userId): bool
|
|
{
|
|
return sqlQueryBuilder()
|
|
->select('id')
|
|
->from('users')
|
|
->where(Operator::equals(['id' => $userId]))
|
|
->execute()->fetchOne();
|
|
}
|
|
}
|