interblue.pl/modules/x13allegro/classes/php5/Sync/XAllegroSyncTasks.php

<?php

use x13allegro\Api\DataProvider\OfferProvider;
use x13allegro\Api\Exception\InvalidArgumentException;
use x13allegro\Api\Model\Offers\OfferTags;
use x13allegro\Json\JsonMapBuilder;

final class XAllegroSyncTasks extends XAllegroSync
{
    public static function checkTasks()
    {
        foreach (XAllegroTask::getTasks() as $task)
        {
            if (!self::changeAccount($task['id_xallegro_account'])) {
                continue;
            }

            switch ($task['type'])
            {
                case XAllegroTask::TYPE_PUBLICATION:
                    self::checkPublicationTask($task);
                    break;

                case XAllegroTask::TYPE_QUANTITY:
                    self::checkQuantityTask($task);
                    break;

                case XAllegroTask::TYPE_PRICE:
                    self::checkPriceTask($task);
                    break;

                default:
                    throw new InvalidArgumentException('Invalid Task type');
            }
        }
    }

    /**
     * @param $task
     */
    private static function checkPublicationTask($task)
    {
        $code = $task['method'] . '-publication-command';

        try {
            $result = self::$api
                ->sale()
                ->commands()
                ->offerPublication()
                ->tasks($task['id_command']);

            foreach ($result->tasks as $taskResult)
            {
                if ($taskResult->status == XAllegroTask::STATUS_SUCCESS)
                {
                    $type = 'SUCCESS';

                    if ($task['value'] == 'ACTIVATE')
                    {
                        XAllegroAuction::activeAuctions(array($task['id_auction']), $code);

                        $tags = json_decode($task['tags']);
                        if (!empty($tags))
                        {
                            /** @var OfferTags $offerTags */
                            $offerTags = (new JsonMapBuilder('OfferTags'))->map(new OfferTags());

                            foreach ($tags as $tag) {
                                $offerTags->tag($tag);
                            }

                            self::$api->sale()->offers()->tags($task['id_auction'], $offerTags);

                            XAllegroLogger::getInstance()
                                ->setType('POST')
                                ->setCode('ASSIGN_TAGS')
                                ->setAuction($task['id_auction'])
                                ->setAccount($task['id_xallegro_account'])
                                ->setMessage($tags)
                                ->log();
                        }
                    }
                    else {
                        XAllegroAuction::closeAuctions(array($task['id_auction']), $code);
                    }
                }
                else if ($taskResult->status == XAllegroTask::STATUS_FAIL) {
                    $type = 'ERROR';
                }
                else {
                    continue;
                }

                self::clearTask($taskResult, $task['id_xallegro_task'], $type, $code);
            }
        }
        catch (Exception $ex) {
            if ($ex->getCode() == 404 || $ex->getCode() == 409)
            {
                $taskResult = new StdClass();
                $taskResult->message = (string)$ex;

                self::clearTask($taskResult, $task['id_xallegro_task'], 'DELETE', $code);
            }
        }
    }

    /**
     * @param array $task
     */
    private static function checkQuantityTask($task)
    {
        $code = $task['method'] . '-quantity-change-command';

        try {
            $result = self::$api
                ->sale()
                ->commands()
                ->quantityChange()
                ->tasks($task['id_command']);

            foreach ($result->tasks as $taskResult)
            {
                if ($taskResult->status == XAllegroTask::STATUS_SUCCESS)
                {
                    $type = 'SUCCESS';

                    try {
                        $offer = (new OfferProvider(self::$api, true))->getOfferDetails($task['id_auction']);
                        XAllegroAuction::updateAuctionQuantity($offer->stock->available, $task['id_auction']);
                    }
                    catch (Exception $ex) {}
                }
                else if ($taskResult->status == XAllegroTask::STATUS_FAIL) {
                    $type = 'ERROR';
                }
                else {
                    $type = 'DELETE';
                    $now = new DateTime();
                    $expire = new DateTime($taskResult->scheduledAt);
                    $interval = $now->diff($expire);

                    if ($interval->days == 0 && $interval->h <= 2) {
                        continue;
                    }
                }

                self::clearTask($taskResult, $task['id_xallegro_task'], $type, $code);
            }
        }
        catch (Exception $ex) {
            if ($ex->getCode() == 404 || $ex->getCode() == 409)
            {
                $taskResult = new StdClass();
                $taskResult->message = (string)$ex;

                self::clearTask($taskResult, $task['id_xallegro_task'], 'DELETE', $code);
            }
        }
    }

    private static function checkPriceTask($task)
    {
        $code = $task['method'] . '-price-change-command';

        try {
            $result = self::$api
                ->sale()
                ->commands()
                ->priceChange()
                ->tasks($task['id_command']);

            foreach ($result->tasks as $taskResult)
            {
                if ($taskResult->status == XAllegroTask::STATUS_SUCCESS) {
                    $type = 'SUCCESS';
                    XAllegroAuction::updateAuctionPrice($task['value'], $task['id_auction']);
                }
                else if ($taskResult->status == XAllegroTask::STATUS_FAIL) {
                    $type = 'ERROR';
                }
                else {
                    $type = 'DELETE';
                    $now = new DateTime();
                    $expire = new DateTime($taskResult->scheduledAt);
                    $interval = $now->diff($expire);

                    if ($interval->days == 0 && $interval->h <= 2) {
                        continue;
                    }
                }

                self::clearTask($taskResult, $task['id_xallegro_task'], $type, $code);
            }
        }
        catch (Exception $ex) {
            if ($ex->getCode() == 404 || $ex->getCode() == 409)
            {
                $taskResult = new StdClass();
                $taskResult->message = (string)$ex;

                self::clearTask($taskResult, $task['id_xallegro_task'], 'DELETE', $code);
            }
        }
    }

    /**
     * @param StdClass $taskResult
     * @param int $taskId
     * @param string $loggerType
     * @param string $loggerCode
     */
    private static function clearTask(StdClass $taskResult, $taskId, $loggerType, $loggerCode)
    {
        $task = new XAllegroTask($taskId);

        $message = $taskResult->message;
        $code = 'DEFAULT';

        if (isset($taskResult->errors) && !empty($taskResult->errors)) {
            $message = ($taskResult->errors[0]->userMessage ?: $taskResult->errors[0]->message);
            $code = $taskResult->errors[0]->code;
        }

        XAllegroLogger::getInstance()
            ->setType($loggerType)
            ->setCode($loggerCode)
            ->setAuction((float)$task->id_auction)
            ->setAccount($task->id_xallegro_account)
            ->setMessage(array(
                'type' => $task->type,
                'method' => $task->method,
                'value' => $task->value,
                'message' => $message,
                'scheduledAt' => isset($taskResult->scheduledAt) ? $taskResult->scheduledAt : false,
                'code' => $code
            ))
            ->log();

        // aukcji nie znaleziono, zamykamy ją w systemie
        if ($code == 'NotFoundException'
            || $code == 'PublicationValidationException.IllegalChangeInactiveOffer'
            || $code == 'NOT_FOUND'
            || $code == 'OFFER_NOT_FOUND'
            || $code == 'OFFER_DOES_NOT_EXIST'
        ) {
            Db::getInstance()->update('xallegro_auction', ['closed' => 1], 'id_auction = '.(float)$task->id_auction);

            XAllegroLogger::getInstance()
                ->setType('LOCAL_DB')
                ->setCode('not-found-auction')
                ->setAuction((float)$task->id_auction)
                ->setAccount($task->id_xallegro_account)
                ->setMessage('Auction closed due to its unavailability on Allegro')
                ->log();
        }

        $task->delete();
    }
}