Invoice.php

Go to the documentation of this file.

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

use Magento\Framework\Api\AttributeValueFactory;
use Magento\Sales\Api\Data\InvoiceInterface;
use Magento\Sales\Model\AbstractModel;
use Magento\Sales\Model\EntityInterface;

class Invoice extends AbstractModel implements EntityInterface, InvoiceInterface
{
    const STATE_OPEN = 1;

    const STATE_PAID = 2;

    const STATE_CANCELED = 3;
    const CAPTURE_ONLINE = 'online';

    const CAPTURE_OFFLINE = 'offline';

    const NOT_CAPTURE = 'not_capture';

    const REPORT_DATE_TYPE_ORDER_CREATED = 'order_created';

    const REPORT_DATE_TYPE_INVOICE_CREATED = 'invoice_created';

    protected $entityType = 'invoice';

    protected static $_states;

    protected $_order;

    protected $_rounders = [];

    protected $_saveBeforeDestruct = false;

    protected $_eventPrefix = 'sales_order_invoice';

    protected $_eventObject = 'invoice';

    protected $_wasPayCalled = false;

    protected $_invoiceConfig;

    protected $_orderFactory;

    protected $_calculatorFactory;

    protected $_invoiceItemCollectionFactory;

    protected $_invoiceCommentFactory;

    protected $_commentCollectionFactory;

    public function __construct(
        \Magento\Framework\Model\Context $context,
        \Magento\Framework\Registry $registry,
        \Magento\Framework\Api\ExtensionAttributesFactory $extensionFactory,
        AttributeValueFactory $customAttributeFactory,
        \Magento\Sales\Model\Order\Invoice\Config $invoiceConfig,
        \Magento\Sales\Model\OrderFactory $orderFactory,
        \Magento\Framework\Math\CalculatorFactory $calculatorFactory,
        \Magento\Sales\Model\ResourceModel\Order\Invoice\Item\CollectionFactory $invoiceItemCollectionFactory,
        \Magento\Sales\Model\Order\Invoice\CommentFactory $invoiceCommentFactory,
        \Magento\Sales\Model\ResourceModel\Order\Invoice\Comment\CollectionFactory $commentCollectionFactory,
        \Magento\Framework\Model\ResourceModel\AbstractResource $resource = null,
        \Magento\Framework\Data\Collection\AbstractDb $resourceCollection = null,
        array $data = []
    ) {
        $this->_invoiceConfig = $invoiceConfig;
        $this->_orderFactory = $orderFactory;
        $this->_calculatorFactory = $calculatorFactory;
        $this->_invoiceItemCollectionFactory = $invoiceItemCollectionFactory;
        $this->_invoiceCommentFactory = $invoiceCommentFactory;
        $this->_commentCollectionFactory = $commentCollectionFactory;
        parent::__construct(
            $context,
            $registry,
            $extensionFactory,
            $customAttributeFactory,
            $resource,
            $resourceCollection,
            $data
        );
    }

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

    public function loadByIncrementId($incrementId)
    {
        $ids = $this->getCollection()->addAttributeToFilter('increment_id', $incrementId)->getAllIds();

        if (!empty($ids)) {
            reset($ids);
            $this->load(current($ids));
        }
        return $this;
    }

    public function getConfig()
    {
        return $this->_invoiceConfig;
    }

    public function getStore()
    {
        return $this->getOrder()->getStore();
    }

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

    public function getOrder()
    {
        if (!$this->_order instanceof \Magento\Sales\Model\Order) {
            $this->_order = $this->_orderFactory->create()->load($this->getOrderId());
        }
        return $this->_order->setHistoryEntityName($this->entityType);
    }

    public function getEntityType()
    {
        return $this->entityType;
    }

    public function getBillingAddress()
    {
        return $this->getOrder()->getBillingAddress();
    }

    public function getShippingAddress()
    {
        return $this->getOrder()->getShippingAddress();
    }

    public function isCanceled()
    {
        return $this->getState() == self::STATE_CANCELED;
    }

    public function canCapture()
    {
        return $this->getState() != self::STATE_CANCELED &&
            $this->getState() != self::STATE_PAID &&
            $this->getOrder()->getPayment()->canCapture();
    }

    public function canVoid()
    {
        if ($this->getState() == self::STATE_PAID) {
            if ($this->getCanVoidFlag() === null) {
                return (bool)$this->getOrder()->getPayment()->canVoid();
            }
        }
        return (bool)$this->getCanVoidFlag();
    }

    public function canCancel()
    {
        return $this->getState() == self::STATE_OPEN;
    }

    public function canRefund()
    {
        if ($this->getState() != self::STATE_PAID) {
            return false;
        }
        if (abs($this->getBaseGrandTotal() - $this->getBaseTotalRefunded()) < .0001) {
            return false;
        }
        return true;
    }

    public function capture()
    {
        $this->getOrder()->getPayment()->capture($this);
        if ($this->getIsPaid()) {
            $this->pay();
        }
        return $this;
    }

    public function pay()
    {
        if ($this->_wasPayCalled) {
            return $this;
        }
        $this->_wasPayCalled = true;

        $this->setState(self::STATE_PAID);

        $order = $this->getOrder();
        $order->getPayment()->pay($this);
        $totalPaid = $this->getGrandTotal();
        $baseTotalPaid = $this->getBaseGrandTotal();
        $invoiceList = $order->getInvoiceCollection();
        // calculate all totals
        if (count($invoiceList->getItems()) > 1) {
            $totalPaid += $order->getTotalPaid();
            $baseTotalPaid += $order->getBaseTotalPaid();
        }
        $order->setTotalPaid($totalPaid);
        $order->setBaseTotalPaid($baseTotalPaid);
        $this->_eventManager->dispatch('sales_order_invoice_pay', [$this->_eventObject => $this]);
        return $this;
    }

    public function wasPayCalled()
    {
        return $this->_wasPayCalled;
    }

    public function void()
    {
        $this->getOrder()->getPayment()->void($this);
        $this->cancel();
        return $this;
    }

    public function cancel()
    {
        if (!$this->canCancel()) {
            return $this;
        }
        $order = $this->getOrder();
        $order->getPayment()->cancelInvoice($this);
        foreach ($this->getAllItems() as $item) {
            $item->cancel();
        }

        $order->setTotalInvoiced($order->getTotalInvoiced() - $this->getGrandTotal());
        $order->setBaseTotalInvoiced($order->getBaseTotalInvoiced() - $this->getBaseGrandTotal());

        $order->setSubtotalInvoiced($order->getSubtotalInvoiced() - $this->getSubtotal());
        $order->setBaseSubtotalInvoiced($order->getBaseSubtotalInvoiced() - $this->getBaseSubtotal());

        $order->setTaxInvoiced($order->getTaxInvoiced() - $this->getTaxAmount());
        $order->setBaseTaxInvoiced($order->getBaseTaxInvoiced() - $this->getBaseTaxAmount());

        $order->setDiscountTaxCompensationInvoiced(
            $order->getDiscountTaxCompensationInvoiced() - $this->getDiscountTaxCompensationAmount()
        );
        $order->setBaseDiscountTaxCompensationInvoiced(
            $order->getBaseDiscountTaxCompensationInvoiced() - $this->getBaseDiscountTaxCompensationAmount()
        );

        $order->setShippingTaxInvoiced($order->getShippingTaxInvoiced() - $this->getShippingTaxAmount());
        $order->setBaseShippingTaxInvoiced($order->getBaseShippingTaxInvoiced() - $this->getBaseShippingTaxAmount());

        $order->setShippingInvoiced($order->getShippingInvoiced() - $this->getShippingAmount());
        $order->setBaseShippingInvoiced($order->getBaseShippingInvoiced() - $this->getBaseShippingAmount());

        $order->setDiscountInvoiced($order->getDiscountInvoiced() - $this->getDiscountAmount());
        $order->setBaseDiscountInvoiced($order->getBaseDiscountInvoiced() - $this->getBaseDiscountAmount());
        $order->setBaseTotalInvoicedCost($order->getBaseTotalInvoicedCost() - $this->getBaseCost());

        if ($this->getState() == self::STATE_PAID) {
            $order->setTotalPaid($order->getTotalPaid() - $this->getGrandTotal());
            $order->setBaseTotalPaid($order->getBaseTotalPaid() - $this->getBaseGrandTotal());
        }
        $this->setState(self::STATE_CANCELED);
        $order->setState(\Magento\Sales\Model\Order::STATE_PROCESSING)
            ->setStatus($order->getConfig()->getStateDefaultStatus(\Magento\Sales\Model\Order::STATE_PROCESSING));
        $this->_eventManager->dispatch('sales_order_invoice_cancel', [$this->_eventObject => $this]);
        return $this;
    }

    public function collectTotals()
    {
        foreach ($this->getConfig()->getTotalModels() as $model) {
            $model->collect($this);
        }
        return $this;
    }

    public function roundPrice($price, $type = 'regular', $negative = false)
    {
        if ($price) {
            if (!isset($this->_rounders[$type])) {
                $this->_rounders[$type] = $this->_calculatorFactory->create(['scope' => $this->getStore()]);
            }
            $price = $this->_rounders[$type]->deltaRound($price, $negative);
        }
        return $price;
    }

    public function getItemsCollection()
    {
        if (!$this->hasData(InvoiceInterface::ITEMS)) {
            $this->setItems($this->_invoiceItemCollectionFactory->create()->setInvoiceFilter($this->getId()));

            if ($this->getId()) {
                foreach ($this->getItems() as $item) {
                    $item->setInvoice($this);
                }
            }
        }
        return $this->getItems();
    }

    public function getAllItems()
    {
        $items = [];
        foreach ($this->getItemsCollection() as $item) {
            if (!$item->isDeleted()) {
                $items[] = $item;
            }
        }
        return $items;
    }

    public function getItemById($itemId)
    {
        foreach ($this->getItemsCollection() as $item) {
            if ($item->getId() == $itemId) {
                return $item;
            }
        }
        return false;
    }

    public function addItem(\Magento\Sales\Model\Order\Invoice\Item $item)
    {
        $item->setInvoice($this)->setParentId($this->getId())->setStoreId($this->getStoreId());

        if (!$item->getId()) {
            $this->getItemsCollection()->addItem($item);
        }
        return $this;
    }

    public static function getStates()
    {
        if (null === static::$_states) {
            static::$_states = [
                self::STATE_OPEN => __('Pending'),
                self::STATE_PAID => __('Paid'),
                self::STATE_CANCELED => __('Canceled'),
            ];
        }
        return static::$_states;
    }

    public function getStateName($stateId = null)
    {
        if ($stateId === null) {
            $stateId = $this->getState();
        }

        if (null === static::$_states) {
            static::getStates();
        }
        if (isset(static::$_states[$stateId])) {
            return static::$_states[$stateId];
        }
        return __('Unknown State');
    }

    public function register()
    {
        if ($this->getId()) {
            throw new \Magento\Framework\Exception\LocalizedException(__('We cannot register an existing invoice'));
        }

        foreach ($this->getAllItems() as $item) {
            if ($item->getQty() > 0) {
                $item->register();
            } else {
                $item->isDeleted(true);
            }
        }

        $order = $this->getOrder();
        $captureCase = $this->getRequestedCaptureCase();
        if ($this->canCapture()) {
            if ($captureCase) {
                if ($captureCase == self::CAPTURE_ONLINE) {
                    $this->capture();
                } elseif ($captureCase == self::CAPTURE_OFFLINE) {
                    $this->setCanVoidFlag(false);
                    $this->pay();
                }
            }
        } elseif (!$order->getPayment()->getMethodInstance()->isGateway() || $captureCase == self::CAPTURE_OFFLINE) {
            if (!$order->getPayment()->getIsTransactionPending()) {
                $this->setCanVoidFlag(false);
                $this->pay();
            }
        }

        $order->setTotalInvoiced($order->getTotalInvoiced() + $this->getGrandTotal());
        $order->setBaseTotalInvoiced($order->getBaseTotalInvoiced() + $this->getBaseGrandTotal());

        $order->setSubtotalInvoiced($order->getSubtotalInvoiced() + $this->getSubtotal());
        $order->setBaseSubtotalInvoiced($order->getBaseSubtotalInvoiced() + $this->getBaseSubtotal());

        $order->setTaxInvoiced($order->getTaxInvoiced() + $this->getTaxAmount());
        $order->setBaseTaxInvoiced($order->getBaseTaxInvoiced() + $this->getBaseTaxAmount());

        $order->setDiscountTaxCompensationInvoiced(
            $order->getDiscountTaxCompensationInvoiced() + $this->getDiscountTaxCompensationAmount()
        );
        $order->setBaseDiscountTaxCompensationInvoiced(
            $order->getBaseDiscountTaxCompensationInvoiced() + $this->getBaseDiscountTaxCompensationAmount()
        );

        $order->setShippingTaxInvoiced($order->getShippingTaxInvoiced() + $this->getShippingTaxAmount());
        $order->setBaseShippingTaxInvoiced($order->getBaseShippingTaxInvoiced() + $this->getBaseShippingTaxAmount());

        $order->setShippingInvoiced($order->getShippingInvoiced() + $this->getShippingAmount());
        $order->setBaseShippingInvoiced($order->getBaseShippingInvoiced() + $this->getBaseShippingAmount());

        $order->setDiscountInvoiced($order->getDiscountInvoiced() + $this->getDiscountAmount());
        $order->setBaseDiscountInvoiced($order->getBaseDiscountInvoiced() + $this->getBaseDiscountAmount());
        $order->setBaseTotalInvoicedCost($order->getBaseTotalInvoicedCost() + $this->getBaseCost());

        $state = $this->getState();
        if (null === $state) {
            $this->setState(self::STATE_OPEN);
        }

        $this->_eventManager->dispatch(
            'sales_order_invoice_register',
            [$this->_eventObject => $this, 'order' => $order]
        );
        return $this;
    }

    public function isLast()
    {
        foreach ($this->getAllItems() as $item) {
            if (!$item->isLast()) {
                return false;
            }
        }
        return true;
    }

    public function addComment($comment, $notify = false, $visibleOnFront = false)
    {
        if (!$comment instanceof \Magento\Sales\Model\Order\Invoice\Comment) {
            $comment = $this->_invoiceCommentFactory->create()->setComment(
                $comment
            )->setIsCustomerNotified(
                $notify
            )->setIsVisibleOnFront(
                $visibleOnFront
            );
        }
        $comment->setInvoice($this)->setStoreId($this->getStoreId())->setParentId($this->getId());
        if (!$comment->getId()) {
            $this->getCommentsCollection()->addItem($comment);
        }
        $this->_hasDataChanges = true;
        return $this;
    }

    public function getCommentsCollection($reload = false)
    {
        if (!$this->hasData(InvoiceInterface::COMMENTS) || $reload) {
            $comments = $this->_commentCollectionFactory->create()->setInvoiceFilter($this->getId())
                ->setCreatedAtOrder();

            $this->setComments($comments);
            $this->getComments()->load();

            if ($this->getId()) {
                foreach ($this->getComments() as $comment) {
                    $comment->setInvoice($this);
                }
            }
        }
        return $this->getComments();
    }

    public function reset()
    {
        $this->unsetData();
        $this->_origData = null;
        $this->setItems(null);
        $this->setComments(null);
        $this->_order = null;
        $this->_saveBeforeDestruct = false;
        $this->_wasPayCalled = false;
        return $this;
    }

    protected function _beforeSave()
    {
        return parent::_beforeSave();
    }

    protected function _afterSave()
    {
        return parent::_afterSave();
    }

    public function getItems()
    {
        if ($this->getData(InvoiceInterface::ITEMS) === null && $this->getId()) {
            $collection = $this->_invoiceItemCollectionFactory->create()->setInvoiceFilter($this->getId());
            foreach ($collection as $item) {
                $item->setInvoice($this);
            }
            $this->setData(InvoiceInterface::ITEMS, $collection->getItems());
        }
        return $this->getData(InvoiceInterface::ITEMS);
    }

    public function getComments()
    {
        if ($this->getData(InvoiceInterface::COMMENTS) === null && $this->getId()) {
            $collection = $this->_commentCollectionFactory->create()->setInvoiceFilter($this->getId());
            foreach ($collection as $comment) {
                $comment->setInvoice($this);
            }
            $this->setData(InvoiceInterface::COMMENTS, $collection->getItems());
        }
        return $this->getData(InvoiceInterface::COMMENTS);
    }

    //@codeCoverageIgnoreStart

    public function getIncrementId()
    {
        return $this->getData('increment_id');
    }

    public function getBaseTotalRefunded()
    {
        return $this->getData(InvoiceInterface::BASE_TOTAL_REFUNDED);
    }

    public function getDiscountDescription()
    {
        return $this->getData(InvoiceInterface::DISCOUNT_DESCRIPTION);
    }

    public function setItems($items)
    {
        return $this->setData(InvoiceInterface::ITEMS, $items);
    }

    public function getBaseCurrencyCode()
    {
        return $this->getData(InvoiceInterface::BASE_CURRENCY_CODE);
    }

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

    public function getBaseGrandTotal()
    {
        return $this->getData(InvoiceInterface::BASE_GRAND_TOTAL);
    }

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

    public function getBaseShippingAmount()
    {
        return $this->getData(InvoiceInterface::BASE_SHIPPING_AMOUNT);
    }

    public function getBaseShippingDiscountTaxCompensationAmnt()
    {
        return $this->getData(InvoiceInterface::BASE_SHIPPING_DISCOUNT_TAX_COMPENSATION_AMNT);
    }

    public function getBaseShippingInclTax()
    {
        return $this->getData(InvoiceInterface::BASE_SHIPPING_INCL_TAX);
    }

    public function getBaseShippingTaxAmount()
    {
        return $this->getData(InvoiceInterface::BASE_SHIPPING_TAX_AMOUNT);
    }

    public function getBaseSubtotal()
    {
        return $this->getData(InvoiceInterface::BASE_SUBTOTAL);
    }

    public function getBaseSubtotalInclTax()
    {
        return $this->getData(InvoiceInterface::BASE_SUBTOTAL_INCL_TAX);
    }

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

    public function getBaseToGlobalRate()
    {
        return $this->getData(InvoiceInterface::BASE_TO_GLOBAL_RATE);
    }

    public function getBaseToOrderRate()
    {
        return $this->getData(InvoiceInterface::BASE_TO_ORDER_RATE);
    }

    public function getBillingAddressId()
    {
        return $this->getData(InvoiceInterface::BILLING_ADDRESS_ID);
    }

    public function getCanVoidFlag()
    {
        return $this->getData(InvoiceInterface::CAN_VOID_FLAG);
    }

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

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

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

    public function getEmailSent()
    {
        return $this->getData(InvoiceInterface::EMAIL_SENT);
    }

    public function getGlobalCurrencyCode()
    {
        return $this->getData(InvoiceInterface::GLOBAL_CURRENCY_CODE);
    }

    public function getGrandTotal()
    {
        return $this->getData(InvoiceInterface::GRAND_TOTAL);
    }

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

    public function getIsUsedForRefund()
    {
        return $this->getData(InvoiceInterface::IS_USED_FOR_REFUND);
    }

    public function getOrderCurrencyCode()
    {
        return $this->getData(InvoiceInterface::ORDER_CURRENCY_CODE);
    }

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

    public function getShippingAddressId()
    {
        return $this->getData(InvoiceInterface::SHIPPING_ADDRESS_ID);
    }

    public function getShippingAmount()
    {
        return $this->getData(InvoiceInterface::SHIPPING_AMOUNT);
    }

    public function getShippingDiscountTaxCompensationAmount()
    {
        return $this->getData(InvoiceInterface::SHIPPING_DISCOUNT_TAX_COMPENSATION_AMOUNT);
    }

    public function getShippingInclTax()
    {
        return $this->getData(InvoiceInterface::SHIPPING_INCL_TAX);
    }

    public function getShippingTaxAmount()
    {
        return $this->getData(InvoiceInterface::SHIPPING_TAX_AMOUNT);
    }

    public function getState()
    {
        return $this->getData(InvoiceInterface::STATE);
    }

    public function getStoreCurrencyCode()
    {
        return $this->getData(InvoiceInterface::STORE_CURRENCY_CODE);
    }

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

    public function getStoreToBaseRate()
    {
        return $this->getData(InvoiceInterface::STORE_TO_BASE_RATE);
    }

    public function getStoreToOrderRate()
    {
        return $this->getData(InvoiceInterface::STORE_TO_ORDER_RATE);
    }

    public function getSubtotal()
    {
        return $this->getData(InvoiceInterface::SUBTOTAL);
    }

    public function getSubtotalInclTax()
    {
        return $this->getData(InvoiceInterface::SUBTOTAL_INCL_TAX);
    }

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

    public function getTotalQty()
    {
        return $this->getData(InvoiceInterface::TOTAL_QTY);
    }

    public function getTransactionId()
    {
        return $this->getData(InvoiceInterface::TRANSACTION_ID);
    }

    public function setTransactionId($transactionId)
    {
        return $this->setData(InvoiceInterface::TRANSACTION_ID, $transactionId);
    }

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

    public function setComments($comments)
    {
        return $this->setData(InvoiceInterface::COMMENTS, $comments);
    }

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

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

    public function setBaseGrandTotal($amount)
    {
        return $this->setData(InvoiceInterface::BASE_GRAND_TOTAL, $amount);
    }

    public function setShippingTaxAmount($amount)
    {
        return $this->setData(InvoiceInterface::SHIPPING_TAX_AMOUNT, $amount);
    }

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

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

    public function setStoreToOrderRate($rate)
    {
        return $this->setData(InvoiceInterface::STORE_TO_ORDER_RATE, $rate);
    }

    public function setBaseShippingTaxAmount($amount)
    {
        return $this->setData(InvoiceInterface::BASE_SHIPPING_TAX_AMOUNT, $amount);
    }

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

    public function setBaseToOrderRate($rate)
    {
        return $this->setData(InvoiceInterface::BASE_TO_ORDER_RATE, $rate);
    }

    public function setGrandTotal($amount)
    {
        return $this->setData(InvoiceInterface::GRAND_TOTAL, $amount);
    }

    public function setShippingAmount($amount)
    {
        return $this->setData(InvoiceInterface::SHIPPING_AMOUNT, $amount);
    }

    public function setSubtotalInclTax($amount)
    {
        return $this->setData(InvoiceInterface::SUBTOTAL_INCL_TAX, $amount);
    }

    public function setBaseSubtotalInclTax($amount)
    {
        return $this->setData(InvoiceInterface::BASE_SUBTOTAL_INCL_TAX, $amount);
    }

    public function setStoreToBaseRate($rate)
    {
        return $this->setData(InvoiceInterface::STORE_TO_BASE_RATE, $rate);
    }

    public function setBaseShippingAmount($amount)
    {
        return $this->setData(InvoiceInterface::BASE_SHIPPING_AMOUNT, $amount);
    }

    public function setTotalQty($qty)
    {
        return $this->setData(InvoiceInterface::TOTAL_QTY, $qty);
    }

    public function setBaseToGlobalRate($rate)
    {
        return $this->setData(InvoiceInterface::BASE_TO_GLOBAL_RATE, $rate);
    }

    public function setSubtotal($amount)
    {
        return $this->setData(InvoiceInterface::SUBTOTAL, $amount);
    }

    public function setBaseSubtotal($amount)
    {
        return $this->setData(InvoiceInterface::BASE_SUBTOTAL, $amount);
    }

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

    public function setBillingAddressId($id)
    {
        return $this->setData(InvoiceInterface::BILLING_ADDRESS_ID, $id);
    }

    public function setIsUsedForRefund($isUsedForRefund)
    {
        return $this->setData(InvoiceInterface::IS_USED_FOR_REFUND, $isUsedForRefund);
    }

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

    public function setEmailSent($emailSent)
    {
        return $this->setData(InvoiceInterface::EMAIL_SENT, $emailSent);
    }

    public function setCanVoidFlag($canVoidFlag)
    {
        return $this->setData(InvoiceInterface::CAN_VOID_FLAG, $canVoidFlag);
    }

    public function setState($state)
    {
        return $this->setData(InvoiceInterface::STATE, $state);
    }

    public function setShippingAddressId($id)
    {
        return $this->setData(InvoiceInterface::SHIPPING_ADDRESS_ID, $id);
    }

    public function setStoreCurrencyCode($code)
    {
        return $this->setData(InvoiceInterface::STORE_CURRENCY_CODE, $code);
    }

    public function setOrderCurrencyCode($code)
    {
        return $this->setData(InvoiceInterface::ORDER_CURRENCY_CODE, $code);
    }

    public function setBaseCurrencyCode($code)
    {
        return $this->setData(InvoiceInterface::BASE_CURRENCY_CODE, $code);
    }

    public function setGlobalCurrencyCode($code)
    {
        return $this->setData(InvoiceInterface::GLOBAL_CURRENCY_CODE, $code);
    }

    public function setIncrementId($id)
    {
        return $this->setData(InvoiceInterface::INCREMENT_ID, $id);
    }

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

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

    public function setShippingDiscountTaxCompensationAmount($amount)
    {
        return $this->setData(InvoiceInterface::SHIPPING_DISCOUNT_TAX_COMPENSATION_AMOUNT, $amount);
    }

    public function setBaseShippingDiscountTaxCompensationAmnt($amnt)
    {
        return $this->setData(InvoiceInterface::BASE_SHIPPING_DISCOUNT_TAX_COMPENSATION_AMNT, $amnt);
    }

    public function setShippingInclTax($amount)
    {
        return $this->setData(InvoiceInterface::SHIPPING_INCL_TAX, $amount);
    }

    public function setBaseShippingInclTax($amount)
    {
        return $this->setData(InvoiceInterface::BASE_SHIPPING_INCL_TAX, $amount);
    }

    public function setBaseTotalRefunded($amount)
    {
        return $this->setData(InvoiceInterface::BASE_TOTAL_REFUNDED, $amount);
    }

    public function setDiscountDescription($description)
    {
        return $this->setData(InvoiceInterface::DISCOUNT_DESCRIPTION, $description);
    }

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

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

    //@codeCoverageIgnoreEnd
}