Item.php

Go to the documentation of this file.

<?php
namespace Magento\Sales\Model\Order;

use Magento\Framework\Api\AttributeValueFactory;
use Magento\Sales\Api\Data\OrderItemInterface;
use Magento\Sales\Model\AbstractModel;

class Item extends AbstractModel implements OrderItemInterface
{
    const STATUS_PENDING = 1;

    // No items shipped, invoiced, canceled, refunded nor backordered
    const STATUS_SHIPPED = 2;

    // When qty ordered - [qty canceled + qty returned] = qty shipped
    const STATUS_INVOICED = 9;

    // When qty ordered - [qty canceled + qty returned] = qty invoiced
    const STATUS_BACKORDERED = 3;

    // When qty ordered - [qty canceled + qty returned] = qty backordered
    const STATUS_CANCELED = 5;

    // When qty ordered = qty canceled
    const STATUS_PARTIAL = 6;

    // If [qty shipped or(max of two) qty invoiced + qty canceled + qty returned]
    // < qty ordered
    const STATUS_MIXED = 7;

    // All other combinations
    const STATUS_REFUNDED = 8;

    // When qty ordered = qty refunded
    const STATUS_RETURNED = 4;

    // When qty ordered = qty returned // not used at the moment

    // When qty ordered = qty returned // not used at the moment
    protected $_eventPrefix = 'sales_order_item';

    protected $_eventObject = 'item';

    protected static $_statuses = null;

    protected $_order = null;

    protected $_children = [];

    protected $_orderFactory;

    protected $productRepository;

    protected $_storeManager;

    private $serializer;

    public function __construct(
        \Magento\Framework\Model\Context $context,
        \Magento\Framework\Registry $registry,
        \Magento\Framework\Api\ExtensionAttributesFactory $extensionFactory,
        AttributeValueFactory $customAttributeFactory,
        \Magento\Sales\Model\OrderFactory $orderFactory,
        \Magento\Store\Model\StoreManagerInterface $storeManager,
        \Magento\Catalog\Api\ProductRepositoryInterface $productRepository,
        \Magento\Framework\Model\ResourceModel\AbstractResource $resource = null,
        \Magento\Framework\Data\Collection\AbstractDb $resourceCollection = null,
        array $data = [],
        \Magento\Framework\Serialize\Serializer\Json $serializer = null
    ) {
        parent::__construct(
            $context,
            $registry,
            $extensionFactory,
            $customAttributeFactory,
            $resource,
            $resourceCollection,
            $data
        );
        $this->serializer = $serializer ?: \Magento\Framework\App\ObjectManager::getInstance()
            ->get(\Magento\Framework\Serialize\Serializer\Json::class);
        $this->_orderFactory = $orderFactory;
        $this->_storeManager = $storeManager;
        $this->productRepository = $productRepository;
    }

    protected function _construct()
    {
        $this->_init(\Magento\Sales\Model\ResourceModel\Order\Item::class);
    }

    public function setParentItem($item)
    {
        if ($item) {
            $this->setData(OrderItemInterface::PARENT_ITEM, $item);
            $item->setHasChildren(true);
            $item->addChildItem($this);
        }
        return $this;
    }

    public function getParentItem()
    {
        return $this->getData(OrderItemInterface::PARENT_ITEM);
    }

    public function canInvoice()
    {
        return $this->getQtyToInvoice() > 0;
    }

    public function canShip()
    {
        return $this->getQtyToShip() > 0;
    }

    public function canRefund()
    {
        return $this->getQtyToRefund() > 0;
    }

    public function getQtyToShip()
    {
        if ($this->isDummy(true)) {
            return 0;
        }

        return $this->getSimpleQtyToShip();
    }

    public function getSimpleQtyToShip()
    {
        $qty = $this->getQtyOrdered() - $this->getQtyShipped() - $this->getQtyRefunded() - $this->getQtyCanceled();
        return max(round($qty, 8), 0);
    }

    public function getQtyToInvoice()
    {
        if ($this->isDummy()) {
            return 0;
        }

        $qty = $this->getQtyOrdered() - $this->getQtyInvoiced() - $this->getQtyCanceled();
        return max(round($qty, 8), 0);
    }

    public function getQtyToRefund()
    {
        if ($this->isDummy()) {
            return 0;
        }

        return max($this->getQtyInvoiced() - $this->getQtyRefunded(), 0);
    }

    public function getQtyToCancel()
    {
        $qtyToCancel = min($this->getQtyToInvoice(), $this->getQtyToShip());
        return max($qtyToCancel, 0);
    }

    public function setOrder(\Magento\Sales\Model\Order $order)
    {
        $this->_order = $order;
        $this->setOrderId($order->getId());
        return $this;
    }

    public function getOrder()
    {
        if ($this->_order === null && ($orderId = $this->getOrderId())) {
            $order = $this->_orderFactory->create();
            $order->load($orderId);
            $this->setOrder($order);
        }
        return $this->_order;
    }

    public function getStatusId()
    {
        $backordered = (double)$this->getQtyBackordered();
        if (!$backordered && $this->getHasChildren()) {
            $backordered = (double)$this->_getQtyChildrenBackordered();
        }
        $canceled = (double)$this->getQtyCanceled();
        $invoiced = (double)$this->getQtyInvoiced();
        $ordered = (double)$this->getQtyOrdered();
        $refunded = (double)$this->getQtyRefunded();
        $shipped = (double)$this->getQtyShipped();

        $actuallyOrdered = $ordered - $canceled - $refunded;

        if (!$invoiced && !$shipped && !$refunded && !$canceled && !$backordered) {
            return self::STATUS_PENDING;
        }
        if ($shipped && $invoiced && $actuallyOrdered == $shipped) {
            return self::STATUS_SHIPPED;
        }

        if ($invoiced && !$shipped && $actuallyOrdered == $invoiced) {
            return self::STATUS_INVOICED;
        }

        if ($backordered && $actuallyOrdered == $backordered) {
            return self::STATUS_BACKORDERED;
        }

        if ($refunded && $ordered == $refunded) {
            return self::STATUS_REFUNDED;
        }

        if ($canceled && $ordered == $canceled) {
            return self::STATUS_CANCELED;
        }

        if (max($shipped, $invoiced) < $actuallyOrdered) {
            return self::STATUS_PARTIAL;
        }

        return self::STATUS_MIXED;
    }

    protected function _getQtyChildrenBackordered()
    {
        $backordered = null;
        foreach ($this->_children as $childItem) {
            $backordered += (double)$childItem->getQtyBackordered();
        }

        return $backordered;
    }

    public function getStatus()
    {
        return $this->getStatusName($this->getStatusId());
    }

    public static function getStatusName($statusId)
    {
        if (self::$_statuses === null) {
            self::getStatuses();
        }
        if (isset(self::$_statuses[$statusId])) {
            return self::$_statuses[$statusId];
        }
        return __('Unknown Status');
    }

    public function cancel()
    {
        if ($this->getStatusId() !== self::STATUS_CANCELED) {
            $this->_eventManager->dispatch('sales_order_item_cancel', ['item' => $this]);
            $this->setQtyCanceled($this->getQtyToCancel());
            $this->setTaxCanceled(
                $this->getTaxCanceled() + $this->getBaseTaxAmount() * $this->getQtyCanceled() / $this->getQtyOrdered()
            );
            $this->setDiscountTaxCompensationCanceled(
                $this->getDiscountTaxCompensationCanceled() +
                $this->getDiscountTaxCompensationAmount() * $this->getQtyCanceled() / $this->getQtyOrdered()
            );
        }
        return $this;
    }

    public static function getStatuses()
    {
        if (self::$_statuses === null) {
            self::$_statuses = [
                self::STATUS_PENDING => __('Ordered'),
                self::STATUS_SHIPPED => __('Shipped'),
                self::STATUS_INVOICED => __('Invoiced'),
                self::STATUS_BACKORDERED => __('Backordered'),
                self::STATUS_RETURNED => __('Returned'),
                self::STATUS_REFUNDED => __('Refunded'),
                self::STATUS_CANCELED => __('Canceled'),
                self::STATUS_PARTIAL => __('Partial'),
                self::STATUS_MIXED => __('Mixed'),
            ];
        }
        return self::$_statuses;
    }

    public function getOriginalPrice()
    {
        $price = $this->getData(OrderItemInterface::ORIGINAL_PRICE);
        if ($price === null) {
            return $this->getPrice();
        }
        return $price;
    }

    public function setProductOptions(array $options = null)
    {
        $this->setData('product_options', $options);
        return $this;
    }

    public function getProductOptions()
    {
        $data = $this->_getData('product_options');
        if (is_string($data)) {
            $data = $this->serializer->unserialize($data);
        }
        return $data;
    }

    public function getProductOptionByCode($code = null)
    {
        $options = $this->getProductOptions();
        if ($code === null) {
            return $options;
        }
        if (isset($options[$code])) {
            return $options[$code];
        }
        return null;
    }

    public function getRealProductType()
    {
        $productType = $this->getProductOptionByCode('real_product_type');
        if ($productType) {
            return $productType;
        }
        return null;
    }

    public function addChildItem($item)
    {
        if ($item instanceof \Magento\Sales\Model\Order\Item) {
            $this->_children[] = $item;
        } elseif (is_array($item)) {
            $this->_children = array_merge($this->_children, $item);
        }
    }

    public function getChildrenItems()
    {
        return $this->_children;
    }

    public function isChildrenCalculated()
    {
        $parentItem = $this->getParentItem();
        if ($parentItem) {
            $options = $parentItem->getProductOptions();
        } else {
            $options = $this->getProductOptions();
        }

        if (isset(
            $options['product_calculations']
        ) && $options['product_calculations'] == \Magento\Catalog\Model\Product\Type\AbstractType::CALCULATE_CHILD
        ) {
            return true;
        }
        return false;
    }

    public function getForceApplyDiscountToParentItem()
    {
        if ($this->getParentItem()) {
            $product = $this->getParentItem()->getProduct();
        } else {
            $product = $this->getProduct();
        }

        return $product->getTypeInstance()->getForceApplyDiscountToParentItem();
    }

    public function isShipSeparately()
    {
        $parentItem = $this->getParentItem();
        if ($parentItem) {
            $options = $parentItem->getProductOptions();
        } else {
            $options = $this->getProductOptions();
        }

        if (isset(
            $options['shipment_type']
        ) && $options['shipment_type'] == \Magento\Catalog\Model\Product\Type\AbstractType::SHIPMENT_SEPARATELY
        ) {
            return true;
        }
        return false;
    }

    public function isDummy($shipment = false)
    {
        if ($shipment) {
            if ($this->getHasChildren() && $this->isShipSeparately()) {
                return true;
            }

            if ($this->getHasChildren() && !$this->isShipSeparately()) {
                return false;
            }

            if ($this->getParentItem() && $this->isShipSeparately()) {
                return false;
            }

            if ($this->getParentItem() && !$this->isShipSeparately()) {
                return true;
            }
        } else {
            if ($this->getHasChildren() && $this->isChildrenCalculated()) {
                return true;
            }

            if ($this->getHasChildren() && !$this->isChildrenCalculated()) {
                return false;
            }

            if ($this->getParentItem() && $this->isChildrenCalculated()) {
                return false;
            }

            if ($this->getParentItem() && !$this->isChildrenCalculated()) {
                return true;
            }
        }
        return false;
    }

    public function getBuyRequest()
    {
        $option = $this->getProductOptionByCode('info_buyRequest');
        if (!$option) {
            $option = [];
        }
        $buyRequest = new \Magento\Framework\DataObject($option);
        $buyRequest->setQty($this->getQtyOrdered() * 1);
        return $buyRequest;
    }

    public function getProduct()
    {
        if (!$this->hasData('product')) {
            try {
                $product = $this->productRepository->getById($this->getProductId());
            } catch (\Magento\Framework\Exception\NoSuchEntityException $noEntityException) {
                $product = null;
            }
            $this->setProduct($product);
        }
        return $this->getData('product');
    }

    public function getStore()
    {
        $storeId = $this->getStoreId();
        if ($storeId) {
            return $this->_storeManager->getStore($storeId);
        }
        return $this->_storeManager->getStore();
    }

    //@codeCoverageIgnoreStart

    public function getAdditionalData()
    {
        return $this->getData(OrderItemInterface::ADDITIONAL_DATA);
    }

    public function getAmountRefunded()
    {
        return $this->getData(OrderItemInterface::AMOUNT_REFUNDED);
    }

    public function getAppliedRuleIds()
    {
        return $this->getData(OrderItemInterface::APPLIED_RULE_IDS);
    }

    public function getBaseAmountRefunded()
    {
        return $this->getData(OrderItemInterface::BASE_AMOUNT_REFUNDED);
    }

    public function getBaseCost()
    {
        return $this->getData(OrderItemInterface::BASE_COST);
    }

    public function getBaseDiscountAmount()
    {
        return $this->getData(OrderItemInterface::BASE_DISCOUNT_AMOUNT);
    }

    public function getBaseDiscountInvoiced()
    {
        return $this->getData(OrderItemInterface::BASE_DISCOUNT_INVOICED);
    }

    public function getBaseDiscountRefunded()
    {
        return $this->getData(OrderItemInterface::BASE_DISCOUNT_REFUNDED);
    }

    public function getBaseDiscountTaxCompensationAmount()
    {
        return $this->getData(OrderItemInterface::BASE_DISCOUNT_TAX_COMPENSATION_AMOUNT);
    }

    public function getBaseDiscountTaxCompensationInvoiced()
    {
        return $this->getData(OrderItemInterface::BASE_DISCOUNT_TAX_COMPENSATION_INVOICED);
    }

    public function getBaseDiscountTaxCompensationRefunded()
    {
        return $this->getData(OrderItemInterface::BASE_DISCOUNT_TAX_COMPENSATION_REFUNDED);
    }

    public function getBaseOriginalPrice()
    {
        return $this->getData(OrderItemInterface::BASE_ORIGINAL_PRICE);
    }

    public function getBasePrice()
    {
        return $this->getData(OrderItemInterface::BASE_PRICE);
    }

    public function getBasePriceInclTax()
    {
        return $this->getData(OrderItemInterface::BASE_PRICE_INCL_TAX);
    }

    public function getBaseRowInvoiced()
    {
        return $this->getData(OrderItemInterface::BASE_ROW_INVOICED);
    }

    public function getBaseRowTotal()
    {
        return $this->getData(OrderItemInterface::BASE_ROW_TOTAL);
    }

    public function getBaseRowTotalInclTax()
    {
        return $this->getData(OrderItemInterface::BASE_ROW_TOTAL_INCL_TAX);
    }

    public function getBaseTaxAmount()
    {
        return $this->getData(OrderItemInterface::BASE_TAX_AMOUNT);
    }

    public function getBaseTaxBeforeDiscount()
    {
        return $this->getData(OrderItemInterface::BASE_TAX_BEFORE_DISCOUNT);
    }

    public function getBaseTaxInvoiced()
    {
        return $this->getData(OrderItemInterface::BASE_TAX_INVOICED);
    }

    public function getBaseTaxRefunded()
    {
        return $this->getData(OrderItemInterface::BASE_TAX_REFUNDED);
    }

    public function getBaseWeeeTaxAppliedAmount()
    {
        return $this->getData(OrderItemInterface::BASE_WEEE_TAX_APPLIED_AMOUNT);
    }

    public function getBaseWeeeTaxAppliedRowAmnt()
    {
        return $this->getData(OrderItemInterface::BASE_WEEE_TAX_APPLIED_ROW_AMNT);
    }

    public function getBaseWeeeTaxDisposition()
    {
        return $this->getData(OrderItemInterface::BASE_WEEE_TAX_DISPOSITION);
    }

    public function getBaseWeeeTaxRowDisposition()
    {
        return $this->getData(OrderItemInterface::BASE_WEEE_TAX_ROW_DISPOSITION);
    }

    public function getCreatedAt()
    {
        return $this->getData(OrderItemInterface::CREATED_AT);
    }

    public function setCreatedAt($createdAt)
    {
        return $this->setData(OrderItemInterface::CREATED_AT, $createdAt);
    }

    public function getDescription()
    {
        return $this->getData(OrderItemInterface::DESCRIPTION);
    }

    public function getDiscountAmount()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_AMOUNT);
    }

    public function getDiscountInvoiced()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_INVOICED);
    }

    public function getDiscountPercent()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_PERCENT);
    }

    public function getDiscountRefunded()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_REFUNDED);
    }

    public function getEventId()
    {
        return $this->getData(OrderItemInterface::EVENT_ID);
    }

    public function getExtOrderItemId()
    {
        return $this->getData(OrderItemInterface::EXT_ORDER_ITEM_ID);
    }

    public function getFreeShipping()
    {
        return $this->getData(OrderItemInterface::FREE_SHIPPING);
    }

    public function getGwBasePrice()
    {
        return $this->getData(OrderItemInterface::GW_BASE_PRICE);
    }

    public function getGwBasePriceInvoiced()
    {
        return $this->getData(OrderItemInterface::GW_BASE_PRICE_INVOICED);
    }

    public function getGwBasePriceRefunded()
    {
        return $this->getData(OrderItemInterface::GW_BASE_PRICE_REFUNDED);
    }

    public function getGwBaseTaxAmount()
    {
        return $this->getData(OrderItemInterface::GW_BASE_TAX_AMOUNT);
    }

    public function getGwBaseTaxAmountInvoiced()
    {
        return $this->getData(OrderItemInterface::GW_BASE_TAX_AMOUNT_INVOICED);
    }

    public function getGwBaseTaxAmountRefunded()
    {
        return $this->getData(OrderItemInterface::GW_BASE_TAX_AMOUNT_REFUNDED);
    }

    public function getGwId()
    {
        return $this->getData(OrderItemInterface::GW_ID);
    }

    public function getGwPrice()
    {
        return $this->getData(OrderItemInterface::GW_PRICE);
    }

    public function getGwPriceInvoiced()
    {
        return $this->getData(OrderItemInterface::GW_PRICE_INVOICED);
    }

    public function getGwPriceRefunded()
    {
        return $this->getData(OrderItemInterface::GW_PRICE_REFUNDED);
    }

    public function getGwTaxAmount()
    {
        return $this->getData(OrderItemInterface::GW_TAX_AMOUNT);
    }

    public function getGwTaxAmountInvoiced()
    {
        return $this->getData(OrderItemInterface::GW_TAX_AMOUNT_INVOICED);
    }

    public function getGwTaxAmountRefunded()
    {
        return $this->getData(OrderItemInterface::GW_TAX_AMOUNT_REFUNDED);
    }

    public function getDiscountTaxCompensationAmount()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_AMOUNT);
    }

    public function getDiscountTaxCompensationCanceled()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_CANCELED);
    }

    public function getDiscountTaxCompensationInvoiced()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_INVOICED);
    }

    public function getDiscountTaxCompensationRefunded()
    {
        return $this->getData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_REFUNDED);
    }

    public function getIsQtyDecimal()
    {
        return $this->getData(OrderItemInterface::IS_QTY_DECIMAL);
    }

    public function getIsVirtual()
    {
        return $this->getData(OrderItemInterface::IS_VIRTUAL);
    }

    public function getItemId()
    {
        return $this->getData(OrderItemInterface::ITEM_ID);
    }

    public function getLockedDoInvoice()
    {
        return $this->getData(OrderItemInterface::LOCKED_DO_INVOICE);
    }

    public function getLockedDoShip()
    {
        return $this->getData(OrderItemInterface::LOCKED_DO_SHIP);
    }

    public function getName()
    {
        return $this->getData(OrderItemInterface::NAME);
    }

    public function getNoDiscount()
    {
        return $this->getData(OrderItemInterface::NO_DISCOUNT);
    }

    public function getOrderId()
    {
        return $this->getData(OrderItemInterface::ORDER_ID);
    }

    public function getParentItemId()
    {
        return $this->getData(OrderItemInterface::PARENT_ITEM_ID);
    }

    public function getPrice()
    {
        return $this->getData(OrderItemInterface::PRICE);
    }

    public function getPriceInclTax()
    {
        return $this->getData(OrderItemInterface::PRICE_INCL_TAX);
    }

    public function getProductId()
    {
        return $this->getData(OrderItemInterface::PRODUCT_ID);
    }

    public function getProductType()
    {
        return $this->getData(OrderItemInterface::PRODUCT_TYPE);
    }

    public function getQtyBackordered()
    {
        return $this->getData(OrderItemInterface::QTY_BACKORDERED);
    }

    public function getQtyCanceled()
    {
        return $this->getData(OrderItemInterface::QTY_CANCELED);
    }

    public function getQtyInvoiced()
    {
        return $this->getData(OrderItemInterface::QTY_INVOICED);
    }

    public function getQtyOrdered()
    {
        return $this->getData(OrderItemInterface::QTY_ORDERED);
    }

    public function getQtyRefunded()
    {
        return $this->getData(OrderItemInterface::QTY_REFUNDED);
    }

    public function getQtyReturned()
    {
        return $this->getData(OrderItemInterface::QTY_RETURNED);
    }

    public function getQtyShipped()
    {
        return $this->getData(OrderItemInterface::QTY_SHIPPED);
    }

    public function getQuoteItemId()
    {
        return $this->getData(OrderItemInterface::QUOTE_ITEM_ID);
    }

    public function getRowInvoiced()
    {
        return $this->getData(OrderItemInterface::ROW_INVOICED);
    }

    public function getRowTotal()
    {
        return $this->getData(OrderItemInterface::ROW_TOTAL);
    }

    public function getRowTotalInclTax()
    {
        return $this->getData(OrderItemInterface::ROW_TOTAL_INCL_TAX);
    }

    public function getRowWeight()
    {
        return $this->getData(OrderItemInterface::ROW_WEIGHT);
    }

    public function getSku()
    {
        return $this->getData(OrderItemInterface::SKU);
    }

    public function getStoreId()
    {
        return $this->getData(OrderItemInterface::STORE_ID);
    }

    public function getTaxAmount()
    {
        return $this->getData(OrderItemInterface::TAX_AMOUNT);
    }

    public function getTaxBeforeDiscount()
    {
        return $this->getData(OrderItemInterface::TAX_BEFORE_DISCOUNT);
    }

    public function getTaxCanceled()
    {
        return $this->getData(OrderItemInterface::TAX_CANCELED);
    }

    public function getTaxInvoiced()
    {
        return $this->getData(OrderItemInterface::TAX_INVOICED);
    }

    public function getTaxPercent()
    {
        return $this->getData(OrderItemInterface::TAX_PERCENT);
    }

    public function getTaxRefunded()
    {
        return $this->getData(OrderItemInterface::TAX_REFUNDED);
    }

    public function getUpdatedAt()
    {
        return $this->getData(OrderItemInterface::UPDATED_AT);
    }

    public function getWeeeTaxApplied()
    {
        return $this->getData(OrderItemInterface::WEEE_TAX_APPLIED);
    }

    public function getWeeeTaxAppliedAmount()
    {
        return $this->getData(OrderItemInterface::WEEE_TAX_APPLIED_AMOUNT);
    }

    public function getWeeeTaxAppliedRowAmount()
    {
        return $this->getData(OrderItemInterface::WEEE_TAX_APPLIED_ROW_AMOUNT);
    }

    public function getWeeeTaxDisposition()
    {
        return $this->getData(OrderItemInterface::WEEE_TAX_DISPOSITION);
    }

    public function getWeeeTaxRowDisposition()
    {
        return $this->getData(OrderItemInterface::WEEE_TAX_ROW_DISPOSITION);
    }

    public function getWeight()
    {
        return $this->getData(OrderItemInterface::WEIGHT);
    }

    public function setUpdatedAt($timestamp)
    {
        return $this->setData(OrderItemInterface::UPDATED_AT, $timestamp);
    }

    public function setItemId($id)
    {
        return $this->setData(OrderItemInterface::ITEM_ID, $id);
    }

    public function setOrderId($id)
    {
        return $this->setData(OrderItemInterface::ORDER_ID, $id);
    }

    public function setParentItemId($id)
    {
        return $this->setData(OrderItemInterface::PARENT_ITEM_ID, $id);
    }

    public function setQuoteItemId($id)
    {
        return $this->setData(OrderItemInterface::QUOTE_ITEM_ID, $id);
    }

    public function setStoreId($id)
    {
        return $this->setData(OrderItemInterface::STORE_ID, $id);
    }

    public function setProductId($id)
    {
        return $this->setData(OrderItemInterface::PRODUCT_ID, $id);
    }

    public function setProductType($productType)
    {
        return $this->setData(OrderItemInterface::PRODUCT_TYPE, $productType);
    }

    public function setWeight($weight)
    {
        return $this->setData(OrderItemInterface::WEIGHT, $weight);
    }

    public function setIsVirtual($isVirtual)
    {
        return $this->setData(OrderItemInterface::IS_VIRTUAL, $isVirtual);
    }

    public function setSku($sku)
    {
        return $this->setData(OrderItemInterface::SKU, $sku);
    }

    public function setName($name)
    {
        return $this->setData(OrderItemInterface::NAME, $name);
    }

    public function setDescription($description)
    {
        return $this->setData(OrderItemInterface::DESCRIPTION, $description);
    }

    public function setAppliedRuleIds($appliedRuleIds)
    {
        return $this->setData(OrderItemInterface::APPLIED_RULE_IDS, $appliedRuleIds);
    }

    public function setAdditionalData($additionalData)
    {
        return $this->setData(OrderItemInterface::ADDITIONAL_DATA, $additionalData);
    }

    public function setIsQtyDecimal($isQtyDecimal)
    {
        return $this->setData(OrderItemInterface::IS_QTY_DECIMAL, $isQtyDecimal);
    }

    public function setNoDiscount($noDiscount)
    {
        return $this->setData(OrderItemInterface::NO_DISCOUNT, $noDiscount);
    }

    public function setQtyBackordered($qtyBackordered)
    {
        return $this->setData(OrderItemInterface::QTY_BACKORDERED, $qtyBackordered);
    }

    public function setQtyCanceled($qtyCanceled)
    {
        return $this->setData(OrderItemInterface::QTY_CANCELED, $qtyCanceled);
    }

    public function setQtyInvoiced($qtyInvoiced)
    {
        return $this->setData(OrderItemInterface::QTY_INVOICED, $qtyInvoiced);
    }

    public function setQtyOrdered($qtyOrdered)
    {
        return $this->setData(OrderItemInterface::QTY_ORDERED, $qtyOrdered);
    }

    public function setQtyRefunded($qtyRefunded)
    {
        return $this->setData(OrderItemInterface::QTY_REFUNDED, $qtyRefunded);
    }

    public function setQtyShipped($qtyShipped)
    {
        return $this->setData(OrderItemInterface::QTY_SHIPPED, $qtyShipped);
    }

    public function setBaseCost($baseCost)
    {
        return $this->setData(OrderItemInterface::BASE_COST, $baseCost);
    }

    public function setPrice($price)
    {
        return $this->setData(OrderItemInterface::PRICE, $price);
    }

    public function setBasePrice($price)
    {
        return $this->setData(OrderItemInterface::BASE_PRICE, $price);
    }

    public function setOriginalPrice($price)
    {
        return $this->setData(OrderItemInterface::ORIGINAL_PRICE, $price);
    }

    public function setBaseOriginalPrice($price)
    {
        return $this->setData(OrderItemInterface::BASE_ORIGINAL_PRICE, $price);
    }

    public function setTaxPercent($taxPercent)
    {
        return $this->setData(OrderItemInterface::TAX_PERCENT, $taxPercent);
    }

    public function setTaxAmount($amount)
    {
        return $this->setData(OrderItemInterface::TAX_AMOUNT, $amount);
    }

    public function setBaseTaxAmount($amount)
    {
        return $this->setData(OrderItemInterface::BASE_TAX_AMOUNT, $amount);
    }

    public function setTaxInvoiced($taxInvoiced)
    {
        return $this->setData(OrderItemInterface::TAX_INVOICED, $taxInvoiced);
    }

    public function setBaseTaxInvoiced($baseTaxInvoiced)
    {
        return $this->setData(OrderItemInterface::BASE_TAX_INVOICED, $baseTaxInvoiced);
    }

    public function setDiscountPercent($discountPercent)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_PERCENT, $discountPercent);
    }

    public function setDiscountAmount($amount)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_AMOUNT, $amount);
    }

    public function setBaseDiscountAmount($amount)
    {
        return $this->setData(OrderItemInterface::BASE_DISCOUNT_AMOUNT, $amount);
    }

    public function setDiscountInvoiced($discountInvoiced)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_INVOICED, $discountInvoiced);
    }

    public function setBaseDiscountInvoiced($baseDiscountInvoiced)
    {
        return $this->setData(OrderItemInterface::BASE_DISCOUNT_INVOICED, $baseDiscountInvoiced);
    }

    public function setAmountRefunded($amountRefunded)
    {
        return $this->setData(OrderItemInterface::AMOUNT_REFUNDED, $amountRefunded);
    }

    public function setBaseAmountRefunded($baseAmountRefunded)
    {
        return $this->setData(OrderItemInterface::BASE_AMOUNT_REFUNDED, $baseAmountRefunded);
    }

    public function setRowTotal($amount)
    {
        return $this->setData(OrderItemInterface::ROW_TOTAL, $amount);
    }

    public function setBaseRowTotal($amount)
    {
        return $this->setData(OrderItemInterface::BASE_ROW_TOTAL, $amount);
    }

    public function setRowInvoiced($rowInvoiced)
    {
        return $this->setData(OrderItemInterface::ROW_INVOICED, $rowInvoiced);
    }

    public function setBaseRowInvoiced($baseRowInvoiced)
    {
        return $this->setData(OrderItemInterface::BASE_ROW_INVOICED, $baseRowInvoiced);
    }

    public function setRowWeight($rowWeight)
    {
        return $this->setData(OrderItemInterface::ROW_WEIGHT, $rowWeight);
    }

    public function setBaseTaxBeforeDiscount($baseTaxBeforeDiscount)
    {
        return $this->setData(OrderItemInterface::BASE_TAX_BEFORE_DISCOUNT, $baseTaxBeforeDiscount);
    }

    public function setTaxBeforeDiscount($taxBeforeDiscount)
    {
        return $this->setData(OrderItemInterface::TAX_BEFORE_DISCOUNT, $taxBeforeDiscount);
    }

    public function setExtOrderItemId($id)
    {
        return $this->setData(OrderItemInterface::EXT_ORDER_ITEM_ID, $id);
    }

    public function setLockedDoInvoice($flag)
    {
        return $this->setData(OrderItemInterface::LOCKED_DO_INVOICE, $flag);
    }

    public function setLockedDoShip($flag)
    {
        return $this->setData(OrderItemInterface::LOCKED_DO_SHIP, $flag);
    }

    public function setPriceInclTax($amount)
    {
        return $this->setData(OrderItemInterface::PRICE_INCL_TAX, $amount);
    }

    public function setBasePriceInclTax($amount)
    {
        return $this->setData(OrderItemInterface::BASE_PRICE_INCL_TAX, $amount);
    }

    public function setRowTotalInclTax($amount)
    {
        return $this->setData(OrderItemInterface::ROW_TOTAL_INCL_TAX, $amount);
    }

    public function setBaseRowTotalInclTax($amount)
    {
        return $this->setData(OrderItemInterface::BASE_ROW_TOTAL_INCL_TAX, $amount);
    }

    public function setDiscountTaxCompensationAmount($amount)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_AMOUNT, $amount);
    }

    public function setBaseDiscountTaxCompensationAmount($amount)
    {
        return $this->setData(OrderItemInterface::BASE_DISCOUNT_TAX_COMPENSATION_AMOUNT, $amount);
    }

    public function setDiscountTaxCompensationInvoiced($discountTaxCompensationInvoiced)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_INVOICED, $discountTaxCompensationInvoiced);
    }

    public function setBaseDiscountTaxCompensationInvoiced($baseDiscountTaxCompensationInvoiced)
    {
        return $this->setData(
            OrderItemInterface::BASE_DISCOUNT_TAX_COMPENSATION_INVOICED,
            $baseDiscountTaxCompensationInvoiced
        );
    }

    public function setDiscountTaxCompensationRefunded($discountTaxCompensationRefunded)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_REFUNDED, $discountTaxCompensationRefunded);
    }

    public function setBaseDiscountTaxCompensationRefunded($baseDiscountTaxCompensationRefunded)
    {
        return $this->setData(
            OrderItemInterface::BASE_DISCOUNT_TAX_COMPENSATION_REFUNDED,
            $baseDiscountTaxCompensationRefunded
        );
    }

    public function setTaxCanceled($taxCanceled)
    {
        return $this->setData(OrderItemInterface::TAX_CANCELED, $taxCanceled);
    }

    public function setDiscountTaxCompensationCanceled($discountTaxCompensationCanceled)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_TAX_COMPENSATION_CANCELED, $discountTaxCompensationCanceled);
    }

    public function setTaxRefunded($taxRefunded)
    {
        return $this->setData(OrderItemInterface::TAX_REFUNDED, $taxRefunded);
    }

    public function setBaseTaxRefunded($baseTaxRefunded)
    {
        return $this->setData(OrderItemInterface::BASE_TAX_REFUNDED, $baseTaxRefunded);
    }

    public function setDiscountRefunded($discountRefunded)
    {
        return $this->setData(OrderItemInterface::DISCOUNT_REFUNDED, $discountRefunded);
    }

    public function setBaseDiscountRefunded($baseDiscountRefunded)
    {
        return $this->setData(OrderItemInterface::BASE_DISCOUNT_REFUNDED, $baseDiscountRefunded);
    }

    public function setGwId($id)
    {
        return $this->setData(OrderItemInterface::GW_ID, $id);
    }

    public function setGwBasePrice($price)
    {
        return $this->setData(OrderItemInterface::GW_BASE_PRICE, $price);
    }

    public function setGwPrice($price)
    {
        return $this->setData(OrderItemInterface::GW_PRICE, $price);
    }

    public function setGwBaseTaxAmount($amount)
    {
        return $this->setData(OrderItemInterface::GW_BASE_TAX_AMOUNT, $amount);
    }

    public function setGwTaxAmount($amount)
    {
        return $this->setData(OrderItemInterface::GW_TAX_AMOUNT, $amount);
    }

    public function setGwBasePriceInvoiced($gwBasePriceInvoiced)
    {
        return $this->setData(OrderItemInterface::GW_BASE_PRICE_INVOICED, $gwBasePriceInvoiced);
    }

    public function setGwPriceInvoiced($gwPriceInvoiced)
    {
        return $this->setData(OrderItemInterface::GW_PRICE_INVOICED, $gwPriceInvoiced);
    }

    public function setGwBaseTaxAmountInvoiced($gwBaseTaxAmountInvoiced)
    {
        return $this->setData(OrderItemInterface::GW_BASE_TAX_AMOUNT_INVOICED, $gwBaseTaxAmountInvoiced);
    }

    public function setGwTaxAmountInvoiced($gwTaxAmountInvoiced)
    {
        return $this->setData(OrderItemInterface::GW_TAX_AMOUNT_INVOICED, $gwTaxAmountInvoiced);
    }

    public function setGwBasePriceRefunded($gwBasePriceRefunded)
    {
        return $this->setData(OrderItemInterface::GW_BASE_PRICE_REFUNDED, $gwBasePriceRefunded);
    }

    public function setGwPriceRefunded($gwPriceRefunded)
    {
        return $this->setData(OrderItemInterface::GW_PRICE_REFUNDED, $gwPriceRefunded);
    }

    public function setGwBaseTaxAmountRefunded($gwBaseTaxAmountRefunded)
    {
        return $this->setData(OrderItemInterface::GW_BASE_TAX_AMOUNT_REFUNDED, $gwBaseTaxAmountRefunded);
    }

    public function setGwTaxAmountRefunded($gwTaxAmountRefunded)
    {
        return $this->setData(OrderItemInterface::GW_TAX_AMOUNT_REFUNDED, $gwTaxAmountRefunded);
    }

    public function setFreeShipping($freeShipping)
    {
        return $this->setData(OrderItemInterface::FREE_SHIPPING, $freeShipping);
    }

    public function setQtyReturned($qtyReturned)
    {
        return $this->setData(OrderItemInterface::QTY_RETURNED, $qtyReturned);
    }

    public function setEventId($id)
    {
        return $this->setData(OrderItemInterface::EVENT_ID, $id);
    }

    public function setBaseWeeeTaxAppliedAmount($amount)
    {
        return $this->setData(OrderItemInterface::BASE_WEEE_TAX_APPLIED_AMOUNT, $amount);
    }

    public function setBaseWeeeTaxAppliedRowAmnt($amnt)
    {
        return $this->setData(OrderItemInterface::BASE_WEEE_TAX_APPLIED_ROW_AMNT, $amnt);
    }

    public function setWeeeTaxAppliedAmount($amount)
    {
        return $this->setData(OrderItemInterface::WEEE_TAX_APPLIED_AMOUNT, $amount);
    }

    public function setWeeeTaxAppliedRowAmount($amount)
    {
        return $this->setData(OrderItemInterface::WEEE_TAX_APPLIED_ROW_AMOUNT, $amount);
    }

    public function setWeeeTaxApplied($weeeTaxApplied)
    {
        return $this->setData(OrderItemInterface::WEEE_TAX_APPLIED, $weeeTaxApplied);
    }

    public function setWeeeTaxDisposition($weeeTaxDisposition)
    {
        return $this->setData(OrderItemInterface::WEEE_TAX_DISPOSITION, $weeeTaxDisposition);
    }

    public function setWeeeTaxRowDisposition($weeeTaxRowDisposition)
    {
        return $this->setData(OrderItemInterface::WEEE_TAX_ROW_DISPOSITION, $weeeTaxRowDisposition);
    }

    public function setBaseWeeeTaxDisposition($baseWeeeTaxDisposition)
    {
        return $this->setData(OrderItemInterface::BASE_WEEE_TAX_DISPOSITION, $baseWeeeTaxDisposition);
    }

    public function setBaseWeeeTaxRowDisposition($baseWeeeTaxRowDisposition)
    {
        return $this->setData(OrderItemInterface::BASE_WEEE_TAX_ROW_DISPOSITION, $baseWeeeTaxRowDisposition);
    }

    public function getProductOption()
    {
        return $this->getData(self::KEY_PRODUCT_OPTION);
    }

    public function setProductOption(\Magento\Catalog\Api\Data\ProductOptionInterface $productOption)
    {
        return $this->setData(self::KEY_PRODUCT_OPTION, $productOption);
    }

    public function getExtensionAttributes()
    {
        return $this->_getExtensionAttributes();
    }

    public function setExtensionAttributes(\Magento\Sales\Api\Data\OrderItemExtensionInterface $extensionAttributes)
    {
        return $this->_setExtensionAttributes($extensionAttributes);
    }

    //@codeCoverageIgnoreEnd

    public function isProcessingAvailable()
    {
        return $this->getQtyToShip() > $this->getQtyToCancel();
    }
}