<h2>Editing File: /usr/local/sitepad/editor/site-data/plugins/kkart-pro/includes/abstracts/abstract-kkart-order.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php
/**
 * Abstract Order
 *
 * Handles generic order data and database interaction which is extended by both
 * KKART_Order (regular orders) and KKART_Order_Refund (refunds are negative orders).
 *
 * @class       KKART_Abstract_Order
 * @version     3.0.0
 * @package     Kkart\Classes
 */

use Automattic\Kkart\Utilities\NumberUtil;

defined( 'ABSPATH' ) || exit;

require_once KKART_ABSPATH . 'includes/legacy/abstract-kkart-legacy-order.php';

/**
 * KKART_Abstract_Order class.
 */
abstract class KKART_Abstract_Order extends KKART_Abstract_Legacy_Order {
	use KKART_Item_Totals;

	/**
	 * Order Data array. This is the core order data exposed in APIs since 3.0.0.
	 *
	 * Notes: cart_tax = cart_tax is the new name for the legacy 'order_tax'
	 * which is the tax for items only, not shipping.
	 *
	 * @since 3.0.0
	 * @var array
	 */
	protected $data = array(
		'parent_id'          =&gt; 0,
		'status'             =&gt; '',
		'currency'           =&gt; '',
		'version'            =&gt; '',
		'prices_include_tax' =&gt; false,
		'date_created'       =&gt; null,
		'date_modified'      =&gt; null,
		'discount_total'     =&gt; 0,
		'discount_tax'       =&gt; 0,
		'shipping_total'     =&gt; 0,
		'shipping_tax'       =&gt; 0,
		'cart_tax'           =&gt; 0,
		'total'              =&gt; 0,
		'total_tax'          =&gt; 0,
	);

	/**
	 * Order items will be stored here, sometimes before they persist in the DB.
	 *
	 * @since 3.0.0
	 * @var array
	 */
	protected $items = array();

	/**
	 * Order items that need deleting are stored here.
	 *
	 * @since 3.0.0
	 * @var array
	 */
	protected $items_to_delete = array();

	/**
	 * Stores meta in cache for future reads.
	 *
	 * A group must be set to to enable caching.
	 *
	 * @var string
	 */
	protected $cache_group = 'orders';

	/**
	 * Which data store to load.
	 *
	 * @var string
	 */
	protected $data_store_name = 'order';

	/**
	 * This is the name of this object type.
	 *
	 * @var string
	 */
	protected $object_type = 'order';

	/**
	 * Get the order if ID is passed, otherwise the order is new and empty.
	 * This class should NOT be instantiated, but the kkart_get_order function or new KKART_Order_Factory
	 * should be used. It is possible, but the aforementioned are preferred and are the only
	 * methods that will be maintained going forward.
	 *
	 * @param  int|object|KKART_Order $order Order to read.
	 */
	public function __construct( $order = 0 ) {
		parent::__construct( $order );

		if ( is_numeric( $order ) &amp;&amp; $order &gt; 0 ) {
			$this-&gt;set_id( $order );
		} elseif ( $order instanceof self ) {
			$this-&gt;set_id( $order-&gt;get_id() );
		} elseif ( ! empty( $order-&gt;ID ) ) {
			$this-&gt;set_id( $order-&gt;ID );
		} else {
			$this-&gt;set_object_read( true );
		}

		$this-&gt;data_store = KKART_Data_Store::load( $this-&gt;data_store_name );

		if ( $this-&gt;get_id() &gt; 0 ) {
			$this-&gt;data_store-&gt;read( $this );
		}
	}

	/**
	 * Get internal type.
	 *
	 * @return string
	 */
	public function get_type() {
		return 'shop_order';
	}

	/**
	 * Get all class data in array format.
	 *
	 * @since 3.0.0
	 * @return array
	 */
	public function get_data() {
		return array_merge(
			array(
				'id' =&gt; $this-&gt;get_id(),
			),
			$this-&gt;data,
			array(
				'meta_data'      =&gt; $this-&gt;get_meta_data(),
				'line_items'     =&gt; $this-&gt;get_items( 'line_item' ),
				'tax_lines'      =&gt; $this-&gt;get_items( 'tax' ),
				'shipping_lines' =&gt; $this-&gt;get_items( 'shipping' ),
				'fee_lines'      =&gt; $this-&gt;get_items( 'fee' ),
				'coupon_lines'   =&gt; $this-&gt;get_items( 'coupon' ),
			)
		);
	}

	/*
	|--------------------------------------------------------------------------
	| CRUD methods
	|--------------------------------------------------------------------------
	|
	| Methods which create, read, update and delete orders from the database.
	| Written in abstract fashion so that the way orders are stored can be
	| changed more easily in the future.
	|
	| A save method is included for convenience (chooses update or create based
	| on if the order exists yet).
	|
	*/

	/**
	 * Save data to the database.
	 *
	 * @since 3.0.0
	 * @return int order ID
	 */
	public function save() {
		if ( ! $this-&gt;data_store ) {
			return $this-&gt;get_id();
		}

		try {
			/**
			 * Trigger action before saving to the DB. Allows you to adjust object props before save.
			 *
			 * @param KKART_Data          $this The object being saved.
			 * @param KKART_Data_Store_WP $data_store THe data store persisting the data.
			 */
			do_action( 'kkart_before_' . $this-&gt;object_type . '_object_save', $this, $this-&gt;data_store );

			if ( $this-&gt;get_id() ) {
				$this-&gt;data_store-&gt;update( $this );
			} else {
				$this-&gt;data_store-&gt;create( $this );
			}

			$this-&gt;save_items();

			/**
			 * Trigger action after saving to the DB.
			 *
			 * @param KKART_Data          $this The object being saved.
			 * @param KKART_Data_Store_WP $data_store THe data store persisting the data.
			 */
			do_action( 'kkart_after_' . $this-&gt;object_type . '_object_save', $this, $this-&gt;data_store );

		} catch ( Exception $e ) {
			$this-&gt;handle_exception( $e, __( 'Error saving order.', 'kkart' ) );
		}

		return $this-&gt;get_id();
	}

	/**
	 * Log an error about this order is exception is encountered.
	 *
	 * @param Exception $e Exception object.
	 * @param string    $message Message regarding exception thrown.
	 * @since 3.7.0
	 */
	protected function handle_exception( $e, $message = 'Error' ) {
		kkart_get_logger()-&gt;error(
			$message,
			array(
				'order' =&gt; $this,
				'error' =&gt; $e,
			)
		);
	}

	/**
	 * Save all order items which are part of this order.
	 */
	protected function save_items() {
		$items_changed = false;

		foreach ( $this-&gt;items_to_delete as $item ) {
			$item-&gt;delete();
			$items_changed = true;
		}
		$this-&gt;items_to_delete = array();

		// Add/save items.
		foreach ( $this-&gt;items as $item_group =&gt; $items ) {
			if ( is_array( $items ) ) {
				$items = array_filter( $items );
				foreach ( $items as $item_key =&gt; $item ) {
					$item-&gt;set_order_id( $this-&gt;get_id() );

					$item_id = $item-&gt;save();

					// If ID changed (new item saved to DB)...
					if ( $item_id !== $item_key ) {
						$this-&gt;items[ $item_group ][ $item_id ] = $item;

						unset( $this-&gt;items[ $item_group ][ $item_key ] );

						$items_changed = true;
					}
				}
			}
		}

		if ( $items_changed ) {
			delete_transient( 'kkart_order_' . $this-&gt;get_id() . '_needs_processing' );
		}
	}

	/*
	|--------------------------------------------------------------------------
	| Getters
	|--------------------------------------------------------------------------
	*/

	/**
	 * Get parent order ID.
	 *
	 * @since 3.0.0
	 * @param  string $context View or edit context.
	 * @return integer
	 */
	public function get_parent_id( $context = 'view' ) {
		return $this-&gt;get_prop( 'parent_id', $context );
	}

	/**
	 * Gets order currency.
	 *
	 * @param  string $context View or edit context.
	 * @return string
	 */
	public function get_currency( $context = 'view' ) {
		return $this-&gt;get_prop( 'currency', $context );
	}

	/**
	 * Get order_version.
	 *
	 * @param  string $context View or edit context.
	 * @return string
	 */
	public function get_version( $context = 'view' ) {
		return $this-&gt;get_prop( 'version', $context );
	}

	/**
	 * Get prices_include_tax.
	 *
	 * @param  string $context View or edit context.
	 * @return bool
	 */
	public function get_prices_include_tax( $context = 'view' ) {
		return $this-&gt;get_prop( 'prices_include_tax', $context );
	}

	/**
	 * Get date_created.
	 *
	 * @param  string $context View or edit context.
	 * @return KKART_DateTime|NULL object if the date is set or null if there is no date.
	 */
	public function get_date_created( $context = 'view' ) {
		return $this-&gt;get_prop( 'date_created', $context );
	}

	/**
	 * Get date_modified.
	 *
	 * @param  string $context View or edit context.
	 * @return KKART_DateTime|NULL object if the date is set or null if there is no date.
	 */
	public function get_date_modified( $context = 'view' ) {
		return $this-&gt;get_prop( 'date_modified', $context );
	}

	/**
	 * Return the order statuses without kkart- internal prefix.
	 *
	 * @param  string $context View or edit context.
	 * @return string
	 */
	public function get_status( $context = 'view' ) {
		$status = $this-&gt;get_prop( 'status', $context );

		if ( empty( $status ) &amp;&amp; 'view' === $context ) {
			// In view context, return the default status if no status has been set.
			$status = apply_filters( 'kkart_default_order_status', 'pending' );
		}
		return $status;
	}

	/**
	 * Get discount_total.
	 *
	 * @param  string $context View or edit context.
	 * @return string
	 */
	public function get_discount_total( $context = 'view' ) {
		return $this-&gt;get_prop( 'discount_total', $context );
	}

	/**
	 * Get discount_tax.
	 *
	 * @param  string $context View or edit context.
	 * @return string
	 */
	public function get_discount_tax( $context = 'view' ) {
		return $this-&gt;get_prop( 'discount_tax', $context );
	}

	/**
	 * Get shipping_total.
	 *
	 * @param  string $context View or edit context.
	 * @return string
	 */
	public function get_shipping_total( $context = 'view' ) {
		return $this-&gt;get_prop( 'shipping_total', $context );
	}

	/**
	 * Get shipping_tax.
	 *
	 * @param  string $context View or edit context.
	 * @return string
	 */
	public function get_shipping_tax( $context = 'view' ) {
		return $this-&gt;get_prop( 'shipping_tax', $context );
	}

	/**
	 * Gets cart tax amount.
	 *
	 * @param  string $context View or edit context.
	 * @return float
	 */
	public function get_cart_tax( $context = 'view' ) {
		return $this-&gt;get_prop( 'cart_tax', $context );
	}

	/**
	 * Gets order grand total. incl. taxes. Used in gateways.
	 *
	 * @param  string $context View or edit context.
	 * @return float
	 */
	public function get_total( $context = 'view' ) {
		return $this-&gt;get_prop( 'total', $context );
	}

	/**
	 * Get total tax amount. Alias for get_order_tax().
	 *
	 * @param  string $context View or edit context.
	 * @return float
	 */
	public function get_total_tax( $context = 'view' ) {
		return $this-&gt;get_prop( 'total_tax', $context );
	}

	/*
	|--------------------------------------------------------------------------
	| Non-CRUD Getters
	|--------------------------------------------------------------------------
	*/

	/**
	 * Gets the total discount amount.
	 *
	 * @param  bool $ex_tax Show discount excl any tax.
	 * @return float
	 */
	public function get_total_discount( $ex_tax = true ) {
		if ( $ex_tax ) {
			$total_discount = $this-&gt;get_discount_total();
		} else {
			$total_discount = $this-&gt;get_discount_total() + $this-&gt;get_discount_tax();
		}
		return apply_filters( 'kkart_order_get_total_discount', NumberUtil::round( $total_discount, KKART_ROUNDING_PRECISION ), $this );
	}

	/**
	 * Gets order subtotal.
	 *
	 * @return float
	 */
	public function get_subtotal() {
		$subtotal = NumberUtil::round( $this-&gt;get_cart_subtotal_for_order(), kkart_get_price_decimals() );
		return apply_filters( 'kkart_order_get_subtotal', (float) $subtotal, $this );
	}

	/**
	 * Get taxes, merged by code, formatted ready for output.
	 *
	 * @return array
	 */
	public function get_tax_totals() {
		$tax_totals = array();

		foreach ( $this-&gt;get_items( 'tax' ) as $key =&gt; $tax ) {
			$code = $tax-&gt;get_rate_code();

			if ( ! isset( $tax_totals[ $code ] ) ) {
				$tax_totals[ $code ]         = new stdClass();
				$tax_totals[ $code ]-&gt;amount = 0;
			}

			$tax_totals[ $code ]-&gt;id               = $key;
			$tax_totals[ $code ]-&gt;rate_id          = $tax-&gt;get_rate_id();
			$tax_totals[ $code ]-&gt;is_compound      = $tax-&gt;is_compound();
			$tax_totals[ $code ]-&gt;label            = $tax-&gt;get_label();
			$tax_totals[ $code ]-&gt;amount          += (float) $tax-&gt;get_tax_total() + (float) $tax-&gt;get_shipping_tax_total();
			$tax_totals[ $code ]-&gt;formatted_amount = kkart_price( $tax_totals[ $code ]-&gt;amount, array( 'currency' =&gt; $this-&gt;get_currency() ) );
		}

		if ( apply_filters( 'kkart_order_hide_zero_taxes', true ) ) {
			$amounts    = array_filter( wp_list_pluck( $tax_totals, 'amount' ) );
			$tax_totals = array_intersect_key( $tax_totals, $amounts );
		}

		return apply_filters( 'kkart_order_get_tax_totals', $tax_totals, $this );
	}

	/**
	 * Get all valid statuses for this order
	 *
	 * @since 3.0.0
	 * @return array Internal status keys e.g. 'kkart-processing'
	 */
	protected function get_valid_statuses() {
		return array_keys( kkart_get_order_statuses() );
	}

	/**
	 * Get user ID. Used by orders, not other order types like refunds.
	 *
	 * @param  string $context View or edit context.
	 * @return int
	 */
	public function get_user_id( $context = 'view' ) {
		return 0;
	}

	/**
	 * Get user. Used by orders, not other order types like refunds.
	 *
	 * @return WP_User|false
	 */
	public function get_user() {
		return false;
	}

	/*
	|--------------------------------------------------------------------------
	| Setters
	|--------------------------------------------------------------------------
	|
	| Functions for setting order data. These should not update anything in the
	| database itself and should only change what is stored in the class
	| object. However, for backwards compatibility pre 3.0.0 some of these
	| setters may handle both.
	*/

	/**
	 * Set parent order ID.
	 *
	 * @since 3.0.0
	 * @param int $value Value to set.
	 * @throws KKART_Data_Exception Exception thrown if parent ID does not exist or is invalid.
	 */
	public function set_parent_id( $value ) {
		if ( $value &amp;&amp; ( $value === $this-&gt;get_id() || ! kkart_get_order( $value ) ) ) {
			$this-&gt;error( 'order_invalid_parent_id', __( 'Invalid parent ID', 'kkart' ) );
		}
		$this-&gt;set_prop( 'parent_id', absint( $value ) );
	}

	/**
	 * Set order status.
	 *
	 * @since 3.0.0
	 * @param string $new_status Status to change the order to. No internal kkart- prefix is required.
	 * @return array details of change
	 */
	public function set_status( $new_status ) {
		$old_status = $this-&gt;get_status();
		$new_status = 'kkart-' === substr( $new_status, 0, 6 ) ? substr( $new_status, 6 ) : $new_status;

		// If setting the status, ensure it's set to a valid status.
		if ( true === $this-&gt;object_read ) {
			// Only allow valid new status.
			if ( ! in_array( 'kkart-' . $new_status, $this-&gt;get_valid_statuses(), true ) &amp;&amp; 'trash' !== $new_status ) {
				$new_status = 'pending';
			}

			// If the old status is set but unknown (e.g. draft) assume its pending for action usage.
			if ( $old_status &amp;&amp; ! in_array( 'kkart-' . $old_status, $this-&gt;get_valid_statuses(), true ) &amp;&amp; 'trash' !== $old_status ) {
				$old_status = 'pending';
			}
		}

		$this-&gt;set_prop( 'status', $new_status );

		return array(
			'from' =&gt; $old_status,
			'to'   =&gt; $new_status,
		);
	}

	/**
	 * Set order_version.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_version( $value ) {
		$this-&gt;set_prop( 'version', $value );
	}

	/**
	 * Set order_currency.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_currency( $value ) {
		if ( $value &amp;&amp; ! in_array( $value, array_keys( get_kkart_currencies() ), true ) ) {
			$this-&gt;error( 'order_invalid_currency', __( 'Invalid currency code', 'kkart' ) );
		}
		$this-&gt;set_prop( 'currency', $value ? $value : get_kkart_currency() );
	}

	/**
	 * Set prices_include_tax.
	 *
	 * @param bool $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_prices_include_tax( $value ) {
		$this-&gt;set_prop( 'prices_include_tax', (bool) $value );
	}

	/**
	 * Set date_created.
	 *
	 * @param  string|integer|null $date UTC timestamp, or ISO 8601 DateTime. If the DateTime string has no timezone or offset, WordPress site timezone will be assumed. Null if there is no date.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_date_created( $date = null ) {
		$this-&gt;set_date_prop( 'date_created', $date );
	}

	/**
	 * Set date_modified.
	 *
	 * @param  string|integer|null $date UTC timestamp, or ISO 8601 DateTime. If the DateTime string has no timezone or offset, WordPress site timezone will be assumed. Null if there is no date.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_date_modified( $date = null ) {
		$this-&gt;set_date_prop( 'date_modified', $date );
	}

	/**
	 * Set discount_total.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_discount_total( $value ) {
		$this-&gt;set_prop( 'discount_total', kkart_format_decimal( $value ) );
	}

	/**
	 * Set discount_tax.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_discount_tax( $value ) {
		$this-&gt;set_prop( 'discount_tax', kkart_format_decimal( $value ) );
	}

	/**
	 * Set shipping_total.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_shipping_total( $value ) {
		$this-&gt;set_prop( 'shipping_total', kkart_format_decimal( $value ) );
	}

	/**
	 * Set shipping_tax.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_shipping_tax( $value ) {
		$this-&gt;set_prop( 'shipping_tax', kkart_format_decimal( $value ) );
		$this-&gt;set_total_tax( (float) $this-&gt;get_cart_tax() + (float) $this-&gt;get_shipping_tax() );
	}

	/**
	 * Set cart tax.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_cart_tax( $value ) {
		$this-&gt;set_prop( 'cart_tax', kkart_format_decimal( $value ) );
		$this-&gt;set_total_tax( (float) $this-&gt;get_cart_tax() + (float) $this-&gt;get_shipping_tax() );
	}

	/**
	 * Sets order tax (sum of cart and shipping tax). Used internally only.
	 *
	 * @param string $value Value to set.
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	protected function set_total_tax( $value ) {
		// We round here because this is a total entry, as opposed to line items in other setters.
		$this-&gt;set_prop( 'total_tax', kkart_format_decimal( NumberUtil::round( $value, kkart_get_price_decimals() ) ) );
	}

	/**
	 * Set total.
	 *
	 * @param string $value Value to set.
	 * @param string $deprecated Function used to set different totals based on this.
	 *
	 * @return bool|void
	 * @throws KKART_Data_Exception Exception may be thrown if value is invalid.
	 */
	public function set_total( $value, $deprecated = '' ) {
		if ( $deprecated ) {
			kkart_deprecated_argument( 'total_type', '3.0', 'Use dedicated total setter methods instead.' );
			return $this-&gt;legacy_set_total( $value, $deprecated );
		}
		$this-&gt;set_prop( 'total', kkart_format_decimal( $value, kkart_get_price_decimals() ) );
	}

	/*
	|--------------------------------------------------------------------------
	| Order Item Handling
	|--------------------------------------------------------------------------
	|
	| Order items are used for products, taxes, shipping, and fees within
	| each order.
	*/

	/**
	 * Remove all line items (products, coupons, shipping, taxes) from the order.
	 *
	 * @param string $type Order item type. Default null.
	 */
	public function remove_order_items( $type = null ) {
		if ( ! empty( $type ) ) {
			$this-&gt;data_store-&gt;delete_items( $this, $type );

			$group = $this-&gt;type_to_group( $type );

			if ( $group ) {
				unset( $this-&gt;items[ $group ] );
			}
		} else {
			$this-&gt;data_store-&gt;delete_items( $this );
			$this-&gt;items = array();
		}
	}

	/**
	 * Convert a type to a types group.
	 *
	 * @param string $type type to lookup.
	 * @return string
	 */
	protected function type_to_group( $type ) {
		$type_to_group = apply_filters(
			'kkart_order_type_to_group',
			array(
				'line_item' =&gt; 'line_items',
				'tax'       =&gt; 'tax_lines',
				'shipping'  =&gt; 'shipping_lines',
				'fee'       =&gt; 'fee_lines',
				'coupon'    =&gt; 'coupon_lines',
			)
		);
		return isset( $type_to_group[ $type ] ) ? $type_to_group[ $type ] : '';
	}

	/**
	 * Return an array of items/products within this order.
	 *
	 * @param string|array $types Types of line items to get (array or string).
	 * @return KKART_Order_Item[]
	 */
	public function get_items( $types = 'line_item' ) {
		$items = array();
		$types = array_filter( (array) $types );

		foreach ( $types as $type ) {
			$group = $this-&gt;type_to_group( $type );

			if ( $group ) {
				if ( ! isset( $this-&gt;items[ $group ] ) ) {
					$this-&gt;items[ $group ] = array_filter( $this-&gt;data_store-&gt;read_items( $this, $type ) );
				}
				// Don't use array_merge here because keys are numeric.
				$items = $items + $this-&gt;items[ $group ];
			}
		}

		return apply_filters( 'kkart_order_get_items', $items, $this, $types );
	}

	/**
	 * Return array of values for calculations.
	 *
	 * @param string $field Field name to return.
	 *
	 * @return array Array of values.
	 */
	protected function get_values_for_total( $field ) {
		$items = array_map(
			function ( $item ) use ( $field ) {
				return kkart_add_number_precision( $item[ $field ], false );
			},
			array_values( $this-&gt;get_items() )
		);
		return $items;
	}

	/**
	 * Return an array of coupons within this order.
	 *
	 * @since  3.7.0
	 * @return KKART_Order_Item_Coupon[]
	 */
	public function get_coupons() {
		return $this-&gt;get_items( 'coupon' );
	}

	/**
	 * Return an array of fees within this order.
	 *
	 * @return KKART_Order_item_Fee[]
	 */
	public function get_fees() {
		return $this-&gt;get_items( 'fee' );
	}

	/**
	 * Return an array of taxes within this order.
	 *
	 * @return KKART_Order_Item_Tax[]
	 */
	public function get_taxes() {
		return $this-&gt;get_items( 'tax' );
	}

	/**
	 * Return an array of shipping costs within this order.
	 *
	 * @return KKART_Order_Item_Shipping[]
	 */
	public function get_shipping_methods() {
		return $this-&gt;get_items( 'shipping' );
	}

	/**
	 * Gets formatted shipping method title.
	 *
	 * @return string
	 */
	public function get_shipping_method() {
		$names = array();
		foreach ( $this-&gt;get_shipping_methods() as $shipping_method ) {
			$names[] = $shipping_method-&gt;get_name();
		}
		return apply_filters( 'kkart_order_shipping_method', implode( ', ', $names ), $this );
	}

	/**
	 * Get used coupon codes only.
	 *
	 * @since 3.7.0
	 * @return array
	 */
	public function get_coupon_codes() {
		$coupon_codes = array();
		$coupons      = $this-&gt;get_items( 'coupon' );

		if ( $coupons ) {
			foreach ( $coupons as $coupon ) {
				$coupon_codes[] = $coupon-&gt;get_code();
			}
		}
		return $coupon_codes;
	}

	/**
	 * Gets the count of order items of a certain type.
	 *
	 * @param string $item_type Item type to lookup.
	 * @return int|string
	 */
	public function get_item_count( $item_type = '' ) {
		$items = $this-&gt;get_items( empty( $item_type ) ? 'line_item' : $item_type );
		$count = 0;

		foreach ( $items as $item ) {
			$count += $item-&gt;get_quantity();
		}

		return apply_filters( 'kkart_get_item_count', $count, $item_type, $this );
	}

	/**
	 * Get an order item object, based on its type.
	 *
	 * @since  3.0.0
	 * @param  int  $item_id ID of item to get.
	 * @param  bool $load_from_db Prior to 3.2 this item was loaded direct from KKART_Order_Factory, not this object. This param is here for backwards compatility with that. If false, uses the local items variable instead.
	 * @return KKART_Order_Item|false
	 */
	public function get_item( $item_id, $load_from_db = true ) {
		if ( $load_from_db ) {
			return KKART_Order_Factory::get_order_item( $item_id );
		}

		// Search for item id.
		if ( $this-&gt;items ) {
			foreach ( $this-&gt;items as $group =&gt; $items ) {
				if ( isset( $items[ $item_id ] ) ) {
					return $items[ $item_id ];
				}
			}
		}

		// Load all items of type and cache.
		$type = $this-&gt;data_store-&gt;get_order_item_type( $this, $item_id );

		if ( ! $type ) {
			return false;
		}

		$items = $this-&gt;get_items( $type );

		return ! empty( $items[ $item_id ] ) ? $items[ $item_id ] : false;
	}

	/**
	 * Get key for where a certain item type is stored in _items.
	 *
	 * @since  3.0.0
	 * @param  string $item object Order item (product, shipping, fee, coupon, tax).
	 * @return string
	 */
	protected function get_items_key( $item ) {
		if ( is_a( $item, 'KKART_Order_Item_Product' ) ) {
			return 'line_items';
		} elseif ( is_a( $item, 'KKART_Order_Item_Fee' ) ) {
			return 'fee_lines';
		} elseif ( is_a( $item, 'KKART_Order_Item_Shipping' ) ) {
			return 'shipping_lines';
		} elseif ( is_a( $item, 'KKART_Order_Item_Tax' ) ) {
			return 'tax_lines';
		} elseif ( is_a( $item, 'KKART_Order_Item_Coupon' ) ) {
			return 'coupon_lines';
		}
		return apply_filters( 'kkart_get_items_key', '', $item );
	}

	/**
	 * Remove item from the order.
	 *
	 * @param int $item_id Item ID to delete.
	 * @return false|void
	 */
	public function remove_item( $item_id ) {
		$item      = $this-&gt;get_item( $item_id, false );
		$items_key = $item ? $this-&gt;get_items_key( $item ) : false;

		if ( ! $items_key ) {
			return false;
		}

		// Unset and remove later.
		$this-&gt;items_to_delete[] = $item;
		unset( $this-&gt;items[ $items_key ][ $item-&gt;get_id() ] );
	}

	/**
	 * Adds an order item to this order. The order item will not persist until save.
	 *
	 * @since 3.0.0
	 * @param KKART_Order_Item $item Order item object (product, shipping, fee, coupon, tax).
	 * @return false|void
	 */
	public function add_item( $item ) {
		$items_key = $this-&gt;get_items_key( $item );

		if ( ! $items_key ) {
			return false;
		}

		// Make sure existing items are loaded so we can append this new one.
		if ( ! isset( $this-&gt;items[ $items_key ] ) ) {
			$this-&gt;items[ $items_key ] = $this-&gt;get_items( $item-&gt;get_type() );
		}

		// Set parent.
		$item-&gt;set_order_id( $this-&gt;get_id() );

		// Append new row with generated temporary ID.
		$item_id = $item-&gt;get_id();

		if ( $item_id ) {
			$this-&gt;items[ $items_key ][ $item_id ] = $item;
		} else {
			$this-&gt;items[ $items_key ][ 'new:' . $items_key . count( $this-&gt;items[ $items_key ] ) ] = $item;
		}
	}

	/**
	 * Check and records coupon usage tentatively so that counts validation is correct. Display an error if coupon usage limit has been reached.
	 *
	 * If you are using this method, make sure to `release_held_coupons` in case an Exception is thrown.
	 *
	 * @throws Exception When not able to apply coupon.
	 *
	 * @param string $billing_email Billing email of order.
	 */
	public function hold_applied_coupons( $billing_email ) {
		$held_keys          = array();
		$held_keys_for_user = array();
		$error              = null;

		try {
			foreach ( KKART()-&gt;cart-&gt;get_applied_coupons() as $code ) {
				$coupon = new KKART_Coupon( $code );
				if ( ! $coupon-&gt;get_data_store() ) {
					continue;
				}

				// Hold coupon for when global coupon usage limit is present.
				if ( 0 &lt; $coupon-&gt;get_usage_limit() ) {
					$held_key = $this-&gt;hold_coupon( $coupon );
					if ( $held_key ) {
						$held_keys[ $coupon-&gt;get_id() ] = $held_key;
					}
				}

				// Hold coupon for when usage limit per customer is enabled.
				if ( 0 &lt; $coupon-&gt;get_usage_limit_per_user() ) {

					if ( ! isset( $user_ids_and_emails ) ) {
						$user_alias          = get_current_user_id() ? wp_get_current_user()-&gt;ID : sanitize_email( $billing_email );
						$user_ids_and_emails = $this-&gt;get_billing_and_current_user_aliases( $billing_email );
					}

					$held_key_for_user = $this-&gt;hold_coupon_for_users( $coupon, $user_ids_and_emails, $user_alias );

					if ( $held_key_for_user ) {
						$held_keys_for_user[ $coupon-&gt;get_id() ] = $held_key_for_user;
					}
				}
			}
		} catch ( Exception $e ) {
			$error = $e;
		} finally {
			// Even in case of error, we will save keys for whatever coupons that were held so our data remains accurate.
			// We save them in bulk instead of one by one for performance reasons.
			if ( 0 &lt; count( $held_keys_for_user ) || 0 &lt; count( $held_keys ) ) {
				$this-&gt;get_data_store()-&gt;set_coupon_held_keys( $this, $held_keys, $held_keys_for_user );
			}
			if ( $error instanceof Exception ) {
				throw $error;
			}
		}
	}


	/**
	 * Hold coupon if a global usage limit is defined.
	 *
	 * @param KKART_Coupon $coupon Coupon object.
	 *
	 * @return string    Meta key which indicates held coupon.
	 * @throws Exception When can't be held.
	 */
	private function hold_coupon( $coupon ) {
		$result = $coupon-&gt;get_data_store()-&gt;check_and_hold_coupon( $coupon );
		if ( false === $result ) {
			// translators: Actual coupon code.
			throw new Exception( sprintf( __( 'An unexpected error happened while applying the Coupon %s.', 'kkart' ), esc_html( $coupon-&gt;get_code() ) ) );
		} elseif ( 0 === $result ) {
			// translators: Actual coupon code.
			throw new Exception( sprintf( __( 'Coupon %s was used in another transaction during this checkout, and coupon usage limit is reached. Please remove the coupon and try again.', 'kkart' ), esc_html( $coupon-&gt;get_code() ) ) );
		}
		return $result;
	}

	/**
	 * Hold coupon if usage limit per customer is defined.
	 *
	 * @param KKART_Coupon $coupon              Coupon object.
	 * @param array     $user_ids_and_emails Array of user Id and emails to check for usage limit.
	 * @param string    $user_alias          User ID or email to use to record current usage.
	 *
	 * @return string    Meta key which indicates held coupon.
	 * @throws Exception When coupon can't be held.
	 */
	private function hold_coupon_for_users( $coupon, $user_ids_and_emails, $user_alias ) {
		$result = $coupon-&gt;get_data_store()-&gt;check_and_hold_coupon_for_user( $coupon, $user_ids_and_emails, $user_alias );
		if ( false === $result ) {
			// translators: Actual coupon code.
			throw new Exception( sprintf( __( 'An unexpected error happened while applying the Coupon %s.', 'kkart' ), esc_html( $coupon-&gt;get_code() ) ) );
		} elseif ( 0 === $result ) {
			// translators: Actual coupon code.
			throw new Exception( sprintf( __( 'You have used this coupon %s in another transaction during this checkout, and coupon usage limit is reached. Please remove the coupon and try again.', 'kkart' ), esc_html( $coupon-&gt;get_code() ) ) );
		}
		return $result;
	}

	/**
	 * Helper method to get all aliases for current user and provide billing email.
	 *
	 * @param string $billing_email Billing email provided in form.
	 *
	 * @return array     Array of all aliases.
	 * @throws Exception When validation fails.
	 */
	private function get_billing_and_current_user_aliases( $billing_email ) {
		$emails = array( $billing_email );
		if ( get_current_user_id() ) {
			$emails[] = wp_get_current_user()-&gt;user_email;
		}
		$emails              = array_unique(
			array_map( 'strtolower', array_map( 'sanitize_email', $emails ) )
		);
		$customer_data_store = KKART_Data_Store::load( 'customer' );
		$user_ids            = $customer_data_store-&gt;get_user_ids_for_billing_email( $emails );
		return array_merge( $user_ids, $emails );
	}

	/**
	 * Apply a coupon to the order and recalculate totals.
	 *
	 * @since 3.2.0
	 * @param string|KKART_Coupon $raw_coupon Coupon code or object.
	 * @return true|WP_Error True if applied, error if not.
	 */
	public function apply_coupon( $raw_coupon ) {
		if ( is_a( $raw_coupon, 'KKART_Coupon' ) ) {
			$coupon = $raw_coupon;
		} elseif ( is_string( $raw_coupon ) ) {
			$code   = kkart_format_coupon_code( $raw_coupon );
			$coupon = new KKART_Coupon( $code );

			if ( $coupon-&gt;get_code() !== $code ) {
				return new WP_Error( 'invalid_coupon', __( 'Invalid coupon code', 'kkart' ) );
			}
		} else {
			return new WP_Error( 'invalid_coupon', __( 'Invalid coupon', 'kkart' ) );
		}

		// Check to make sure coupon is not already applied.
		$applied_coupons = $this-&gt;get_items( 'coupon' );
		foreach ( $applied_coupons as $applied_coupon ) {
			if ( $applied_coupon-&gt;get_code() === $coupon-&gt;get_code() ) {
				return new WP_Error( 'invalid_coupon', __( 'Coupon code already applied!', 'kkart' ) );
			}
		}

		$discounts = new KKART_Discounts( $this );
		$applied   = $discounts-&gt;apply_coupon( $coupon );

		if ( is_wp_error( $applied ) ) {
			return $applied;
		}

		$data_store = $coupon-&gt;get_data_store();

		// Check specific for guest checkouts here as well since KKART_Cart handles that seperately in check_customer_coupons.
		if ( $data_store &amp;&amp; 0 === $this-&gt;get_customer_id() ) {
			$usage_count = $data_store-&gt;get_usage_by_email( $coupon, $this-&gt;get_billing_email() );
			if ( 0 &lt; $coupon-&gt;get_usage_limit_per_user() &amp;&amp; $usage_count &gt;= $coupon-&gt;get_usage_limit_per_user() ) {
				return new WP_Error(
					'invalid_coupon',
					$coupon-&gt;get_coupon_error( 106 ),
					array(
						'status' =&gt; 400,
					)
				);
			}
		}

		$this-&gt;set_coupon_discount_amounts( $discounts );
		$this-&gt;save();

		// Recalculate totals and taxes.
		$this-&gt;recalculate_coupons();

		// Record usage so counts and validation is correct.
		$used_by = $this-&gt;get_user_id();

		if ( ! $used_by ) {
			$used_by = $this-&gt;get_billing_email();
		}

		$coupon-&gt;increase_usage_count( $used_by );

		return true;
	}

	/**
	 * Remove a coupon from the order and recalculate totals.
	 *
	 * Coupons affect line item totals, but there is no relationship between
	 * coupon and line total, so to remove a coupon we need to work from the
	 * line subtotal (price before discount) and re-apply all coupons in this
	 * order.
	 *
	 * Manual discounts are not affected; those are separate and do not affect
	 * stored line totals.
	 *
	 * @since  3.2.0
	 * @param  string $code Coupon code.
	 * @return void
	 */
	public function remove_coupon( $code ) {
		$coupons = $this-&gt;get_items( 'coupon' );

		// Remove the coupon line.
		foreach ( $coupons as $item_id =&gt; $coupon ) {
			if ( $coupon-&gt;get_code() === $code ) {
				$this-&gt;remove_item( $item_id );
				$coupon_object = new KKART_Coupon( $code );
				$coupon_object-&gt;decrease_usage_count( $this-&gt;get_user_id() );
				$this-&gt;recalculate_coupons();
				break;
			}
		}
	}

	/**
	 * Apply all coupons in this order again to all line items.
	 * This method is public since Kkart 3.8.0.
	 *
	 * @since 3.2.0
	 */
	public function recalculate_coupons() {
		// Reset line item totals.
		foreach ( $this-&gt;get_items() as $item ) {
			$item-&gt;set_total( $item-&gt;get_subtotal() );
			$item-&gt;set_total_tax( $item-&gt;get_subtotal_tax() );
		}

		$discounts = new KKART_Discounts( $this );

		foreach ( $this-&gt;get_items( 'coupon' ) as $coupon_item ) {
			$coupon_code = $coupon_item-&gt;get_code();
			$coupon_id   = kkart_get_coupon_id_by_code( $coupon_code );

			// If we have a coupon ID (loaded via kkart_get_coupon_id_by_code) we can simply load the new coupon object using the ID.
			if ( $coupon_id ) {
				$coupon_object = new KKART_Coupon( $coupon_id );

			} else {

				// If we do not have a coupon ID (was it virtual? has it been deleted?) we must create a temporary coupon using what data we have stored during checkout.
				$coupon_object = new KKART_Coupon();
				$coupon_object-&gt;set_props( (array) $coupon_item-&gt;get_meta( 'coupon_data', true ) );
				$coupon_object-&gt;set_code( $coupon_code );
				$coupon_object-&gt;set_virtual( true );

				// If there is no coupon amount (maybe dynamic?), set it to the given **discount** amount so the coupon's same value is applied.
				if ( ! $coupon_object-&gt;get_amount() ) {

					// If the order originally had prices including tax, remove the discount + discount tax.
					if ( $this-&gt;get_prices_include_tax() ) {
						$coupon_object-&gt;set_amount( $coupon_item-&gt;get_discount() + $coupon_item-&gt;get_discount_tax() );
					} else {
						$coupon_object-&gt;set_amount( $coupon_item-&gt;get_discount() );
					}
					$coupon_object-&gt;set_discount_type( 'fixed_cart' );
				}
			}

			/**
			 * Allow developers to filter this coupon before it get's re-applied to the order.
			 *
			 * @since 3.2.0
			 */
			$coupon_object = apply_filters( 'kkart_order_recalculate_coupons_coupon_object', $coupon_object, $coupon_code, $coupon_item, $this );

			if ( $coupon_object ) {
				$discounts-&gt;apply_coupon( $coupon_object, false );
			}
		}

		$this-&gt;set_coupon_discount_amounts( $discounts );
		$this-&gt;set_item_discount_amounts( $discounts );

		// Recalculate totals and taxes.
		$this-&gt;calculate_totals( true );
	}

	/**
	 * After applying coupons via the KKART_Discounts class, update line items.
	 *
	 * @since 3.2.0
	 * @param KKART_Discounts $discounts Discounts class.
	 */
	protected function set_item_discount_amounts( $discounts ) {
		$item_discounts = $discounts-&gt;get_discounts_by_item();

		if ( $item_discounts ) {
			foreach ( $item_discounts as $item_id =&gt; $amount ) {
				$item = $this-&gt;get_item( $item_id, false );

				// If the prices include tax, discounts should be taken off the tax inclusive prices like in the cart.
				if ( $this-&gt;get_prices_include_tax() &amp;&amp; kkart_tax_enabled() &amp;&amp; 'taxable' === $item-&gt;get_tax_status() ) {
					$taxes = KKART_Tax::calc_tax( $amount, KKART_Tax::get_rates( $item-&gt;get_tax_class() ), true );

					// Use unrounded taxes so totals will be re-calculated accurately, like in cart.
					$amount = $amount - array_sum( $taxes );
				}

				$item-&gt;set_total( max( 0, $item-&gt;get_total() - $amount ) );
			}
		}
	}

	/**
	 * After applying coupons via the KKART_Discounts class, update or create coupon items.
	 *
	 * @since 3.2.0
	 * @param KKART_Discounts $discounts Discounts class.
	 */
	protected function set_coupon_discount_amounts( $discounts ) {
		$coupons           = $this-&gt;get_items( 'coupon' );
		$coupon_code_to_id = kkart_list_pluck( $coupons, 'get_id', 'get_code' );
		$all_discounts     = $discounts-&gt;get_discounts();
		$coupon_discounts  = $discounts-&gt;get_discounts_by_coupon();

		if ( $coupon_discounts ) {
			foreach ( $coupon_discounts as $coupon_code =&gt; $amount ) {
				$item_id = isset( $coupon_code_to_id[ $coupon_code ] ) ? $coupon_code_to_id[ $coupon_code ] : 0;

				if ( ! $item_id ) {
					$coupon_item = new KKART_Order_Item_Coupon();
					$coupon_item-&gt;set_code( $coupon_code );
				} else {
					$coupon_item = $this-&gt;get_item( $item_id, false );
				}

				$discount_tax = 0;

				// Work out how much tax has been removed as a result of the discount from this coupon.
				foreach ( $all_discounts[ $coupon_code ] as $item_id =&gt; $item_discount_amount ) {
					$item = $this-&gt;get_item( $item_id, false );

					if ( 'taxable' !== $item-&gt;get_tax_status() || ! kkart_tax_enabled() ) {
						continue;
					}

					$taxes = array_sum( KKART_Tax::calc_tax( $item_discount_amount, KKART_Tax::get_rates( $item-&gt;get_tax_class() ), $this-&gt;get_prices_include_tax() ) );
					if ( 'yes' !== get_option( 'kkart_tax_round_at_subtotal' ) ) {
						$taxes = kkart_round_tax_total( $taxes );
					}

					$discount_tax += $taxes;

					if ( $this-&gt;get_prices_include_tax() ) {
						$amount = $amount - $taxes;
					}
				}

				$coupon_item-&gt;set_discount( $amount );
				$coupon_item-&gt;set_discount_tax( $discount_tax );

				$this-&gt;add_item( $coupon_item );
			}
		}
	}

	/**
	 * Add a product line item to the order. This is the only line item type with
	 * its own method because it saves looking up order amounts (costs are added up for you).
	 *
	 * @param  KKART_Product $product Product object.
	 * @param  int        $qty Quantity to add.
	 * @param  array      $args Args for the added product.
	 * @return int
	 * @throws KKART_Data_Exception Exception thrown if the item cannot be added to the cart.
	 */
	public function add_product( $product, $qty = 1, $args = array() ) {
		if ( $product ) {
			$default_args = array(
				'name'         =&gt; $product-&gt;get_name(),
				'tax_class'    =&gt; $product-&gt;get_tax_class(),
				'product_id'   =&gt; $product-&gt;is_type( 'variation' ) ? $product-&gt;get_parent_id() : $product-&gt;get_id(),
				'variation_id' =&gt; $product-&gt;is_type( 'variation' ) ? $product-&gt;get_id() : 0,
				'variation'    =&gt; $product-&gt;is_type( 'variation' ) ? $product-&gt;get_attributes() : array(),
				'subtotal'     =&gt; kkart_get_price_excluding_tax( $product, array( 'qty' =&gt; $qty ) ),
				'total'        =&gt; kkart_get_price_excluding_tax( $product, array( 'qty' =&gt; $qty ) ),
				'quantity'     =&gt; $qty,
			);
		} else {
			$default_args = array(
				'quantity' =&gt; $qty,
			);
		}

		$args = wp_parse_args( $args, $default_args );

		// BW compatibility with old args.
		if ( isset( $args['totals'] ) ) {
			foreach ( $args['totals'] as $key =&gt; $value ) {
				if ( 'tax' === $key ) {
					$args['total_tax'] = $value;
				} elseif ( 'tax_data' === $key ) {
					$args['taxes'] = $value;
				} else {
					$args[ $key ] = $value;
				}
			}
		}

		$item = new KKART_Order_Item_Product();
		$item-&gt;set_props( $args );
		$item-&gt;set_backorder_meta();
		$item-&gt;set_order_id( $this-&gt;get_id() );
		$item-&gt;save();
		$this-&gt;add_item( $item );
		delete_transient( 'kkart_order_' . $this-&gt;get_id() . '_needs_processing' );
		return $item-&gt;get_id();
	}

	/*
	|--------------------------------------------------------------------------
	| Payment Token Handling
	|--------------------------------------------------------------------------
	|
	| Payment tokens are hashes used to take payments by certain gateways.
	|
	*/

	/**
	 * Add a payment token to an order
	 *
	 * @since 2.6
	 * @param KKART_Payment_Token $token Payment token object.
	 * @return boolean|int The new token ID or false if it failed.
	 */
	public function add_payment_token( $token ) {
		if ( empty( $token ) || ! ( $token instanceof KKART_Payment_Token ) ) {
			return false;
		}

		$token_ids   = $this-&gt;data_store-&gt;get_payment_token_ids( $this );
		$token_ids[] = $token-&gt;get_id();
		$this-&gt;data_store-&gt;update_payment_token_ids( $this, $token_ids );

		do_action( 'kkart_payment_token_added_to_order', $this-&gt;get_id(), $token-&gt;get_id(), $token, $token_ids );
		return $token-&gt;get_id();
	}

	/**
	 * Returns a list of all payment tokens associated with the current order
	 *
	 * @since 2.6
	 * @return array An array of payment token objects
	 */
	public function get_payment_tokens() {
		return $this-&gt;data_store-&gt;get_payment_token_ids( $this );
	}

	/*
	|--------------------------------------------------------------------------
	| Calculations.
	|--------------------------------------------------------------------------
	|
	| These methods calculate order totals and taxes based on the current data.
	|
	*/

	/**
	 * Calculate shipping total.
	 *
	 * @since 2.2
	 * @return float
	 */
	public function calculate_shipping() {
		$shipping_total = 0;

		foreach ( $this-&gt;get_shipping_methods() as $shipping ) {
			$shipping_total += $shipping-&gt;get_total();
		}

		$this-&gt;set_shipping_total( $shipping_total );
		$this-&gt;save();

		return $this-&gt;get_shipping_total();
	}

	/**
	 * Get all tax classes for items in the order.
	 *
	 * @since 2.6.3
	 * @return array
	 */
	public function get_items_tax_classes() {
		$found_tax_classes = array();

		foreach ( $this-&gt;get_items() as $item ) {
			if ( is_callable( array( $item, 'get_tax_status' ) ) &amp;&amp; in_array( $item-&gt;get_tax_status(), array( 'taxable', 'shipping' ), true ) ) {
				$found_tax_classes[] = $item-&gt;get_tax_class();
			}
		}

		return array_unique( $found_tax_classes );
	}

	/**
	 * Get tax location for this order.
	 *
	 * @since 3.2.0
	 * @param array $args array Override the location.
	 * @return array
	 */
	protected function get_tax_location( $args = array() ) {
		$tax_based_on = get_option( 'kkart_tax_based_on' );

		if ( 'shipping' === $tax_based_on &amp;&amp; ! $this-&gt;get_shipping_country() ) {
			$tax_based_on = 'billing';
		}

		$args = wp_parse_args(
			$args,
			array(
				'country'  =&gt; 'billing' === $tax_based_on ? $this-&gt;get_billing_country() : $this-&gt;get_shipping_country(),
				'state'    =&gt; 'billing' === $tax_based_on ? $this-&gt;get_billing_state() : $this-&gt;get_shipping_state(),
				'postcode' =&gt; 'billing' === $tax_based_on ? $this-&gt;get_billing_postcode() : $this-&gt;get_shipping_postcode(),
				'city'     =&gt; 'billing' === $tax_based_on ? $this-&gt;get_billing_city() : $this-&gt;get_shipping_city(),
			)
		);

		// Default to base.
		if ( 'base' === $tax_based_on || empty( $args['country'] ) ) {
			$args['country']  = KKART()-&gt;countries-&gt;get_base_country();
			$args['state']    = KKART()-&gt;countries-&gt;get_base_state();
			$args['postcode'] = KKART()-&gt;countries-&gt;get_base_postcode();
			$args['city']     = KKART()-&gt;countries-&gt;get_base_city();
		}

		return apply_filters( 'kkart_order_get_tax_location', $args, $this );
	}

	/**
	 * Calculate taxes for all line items and shipping, and store the totals and tax rows.
	 *
	 * If by default the taxes are based on the shipping address and the current order doesn't
	 * have any, it would use the billing address rather than using the Shopping base location.
	 *
	 * Will use the base country unless customer addresses are set.
	 *
	 * @param array $args Added in 3.0.0 to pass things like location.
	 */
	public function calculate_taxes( $args = array() ) {
		do_action( 'kkart_order_before_calculate_taxes', $args, $this );

		$calculate_tax_for  = $this-&gt;get_tax_location( $args );
		$shipping_tax_class = get_option( 'kkart_shipping_tax_class' );

		if ( 'inherit' === $shipping_tax_class ) {
			$found_classes      = array_intersect( array_merge( array( '' ), KKART_Tax::get_tax_class_slugs() ), $this-&gt;get_items_tax_classes() );
			$shipping_tax_class = count( $found_classes ) ? current( $found_classes ) : false;
		}

		$is_vat_exempt = apply_filters( 'kkart_order_is_vat_exempt', 'yes' === $this-&gt;get_meta( 'is_vat_exempt' ), $this );

		// Trigger tax recalculation for all items.
		foreach ( $this-&gt;get_items( array( 'line_item', 'fee' ) ) as $item_id =&gt; $item ) {
			if ( ! $is_vat_exempt ) {
				$item-&gt;calculate_taxes( $calculate_tax_for );
			} else {
				$item-&gt;set_taxes( false );
			}
		}

		foreach ( $this-&gt;get_shipping_methods() as $item_id =&gt; $item ) {
			if ( false !== $shipping_tax_class &amp;&amp; ! $is_vat_exempt ) {
				$item-&gt;calculate_taxes( array_merge( $calculate_tax_for, array( 'tax_class' =&gt; $shipping_tax_class ) ) );
			} else {
				$item-&gt;set_taxes( false );
			}
		}

		$this-&gt;update_taxes();
	}

	/**
	 * Calculate fees for all line items.
	 *
	 * @return float Fee total.
	 */
	public function get_total_fees() {
		return array_reduce(
			$this-&gt;get_fees(),
			function( $carry, $item ) {
				return $carry + $item-&gt;get_total();
			}
		);
	}

	/**
	 * Update tax lines for the order based on the line item taxes themselves.
	 */
	public function update_taxes() {
		$cart_taxes     = array();
		$shipping_taxes = array();
		$existing_taxes = $this-&gt;get_taxes();
		$saved_rate_ids = array();

		foreach ( $this-&gt;get_items( array( 'line_item', 'fee' ) ) as $item_id =&gt; $item ) {
			$taxes = $item-&gt;get_taxes();
			foreach ( $taxes['total'] as $tax_rate_id =&gt; $tax ) {
				$tax_amount = $this-&gt;round_line_tax( $tax, false );

				$cart_taxes[ $tax_rate_id ] = isset( $cart_taxes[ $tax_rate_id ] ) ? $cart_taxes[ $tax_rate_id ] + $tax_amount : $tax_amount;
			}
		}

		foreach ( $this-&gt;get_shipping_methods() as $item_id =&gt; $item ) {
			$taxes = $item-&gt;get_taxes();
			foreach ( $taxes['total'] as $tax_rate_id =&gt; $tax ) {
				$tax_amount = (float) $tax;

				if ( 'yes' !== get_option( 'kkart_tax_round_at_subtotal' ) ) {
					$tax_amount = kkart_round_tax_total( $tax_amount );
				}

				$shipping_taxes[ $tax_rate_id ] = isset( $shipping_taxes[ $tax_rate_id ] ) ? $shipping_taxes[ $tax_rate_id ] + $tax_amount : $tax_amount;
			}
		}

		foreach ( $existing_taxes as $tax ) {
			// Remove taxes which no longer exist for cart/shipping.
			if ( ( ! array_key_exists( $tax-&gt;get_rate_id(), $cart_taxes ) &amp;&amp; ! array_key_exists( $tax-&gt;get_rate_id(), $shipping_taxes ) ) || in_array( $tax-&gt;get_rate_id(), $saved_rate_ids, true ) ) {
				$this-&gt;remove_item( $tax-&gt;get_id() );
				continue;
			}
			$saved_rate_ids[] = $tax-&gt;get_rate_id();
			$tax-&gt;set_tax_total( isset( $cart_taxes[ $tax-&gt;get_rate_id() ] ) ? $cart_taxes[ $tax-&gt;get_rate_id() ] : 0 );
			$tax-&gt;set_shipping_tax_total( ! empty( $shipping_taxes[ $tax-&gt;get_rate_id() ] ) ? $shipping_taxes[ $tax-&gt;get_rate_id() ] : 0 );
			$tax-&gt;save();
		}

		$new_rate_ids = wp_parse_id_list( array_diff( array_keys( $cart_taxes + $shipping_taxes ), $saved_rate_ids ) );

		// New taxes.
		foreach ( $new_rate_ids as $tax_rate_id ) {
			$item = new KKART_Order_Item_Tax();
			$item-&gt;set_rate( $tax_rate_id );
			$item-&gt;set_tax_total( isset( $cart_taxes[ $tax_rate_id ] ) ? $cart_taxes[ $tax_rate_id ] : 0 );
			$item-&gt;set_shipping_tax_total( ! empty( $shipping_taxes[ $tax_rate_id ] ) ? $shipping_taxes[ $tax_rate_id ] : 0 );
			$this-&gt;add_item( $item );
		}

		$this-&gt;set_shipping_tax( array_sum( $shipping_taxes ) );
		$this-&gt;set_cart_tax( array_sum( $cart_taxes ) );
		$this-&gt;save();
	}

	/**
	 * Helper function.
	 * If you add all items in this order in cart again, this would be the cart subtotal (assuming all other settings are same).
	 *
	 * @return float Cart subtotal.
	 */
	protected function get_cart_subtotal_for_order() {
		return kkart_remove_number_precision(
			$this-&gt;get_rounded_items_total(
				$this-&gt;get_values_for_total( 'subtotal' )
			)
		);
	}

	/**
	 * Helper function.
	 * If you add all items in this order in cart again, this would be the cart total (assuming all other settings are same).
	 *
	 * @return float Cart total.
	 */
	protected function get_cart_total_for_order() {
		return kkart_remove_number_precision(
			$this-&gt;get_rounded_items_total(
				$this-&gt;get_values_for_total( 'total' )
			)
		);
	}

	/**
	 * Calculate totals by looking at the contents of the order. Stores the totals and returns the orders final total.
	 *
	 * @since 2.2
	 * @param  bool $and_taxes Calc taxes if true.
	 * @return float calculated grand total.
	 */
	public function calculate_totals( $and_taxes = true ) {
		do_action( 'kkart_order_before_calculate_totals', $and_taxes, $this );

		$fees_total        = 0;
		$shipping_total    = 0;
		$cart_subtotal_tax = 0;
		$cart_total_tax    = 0;

		$cart_subtotal = $this-&gt;get_cart_subtotal_for_order();
		$cart_total    = $this-&gt;get_cart_total_for_order();

		// Sum shipping costs.
		foreach ( $this-&gt;get_shipping_methods() as $shipping ) {
			$shipping_total += NumberUtil::round( $shipping-&gt;get_total(), kkart_get_price_decimals() );
		}

		$this-&gt;set_shipping_total( $shipping_total );

		// Sum fee costs.
		foreach ( $this-&gt;get_fees() as $item ) {
			$fee_total = $item-&gt;get_total();

			if ( 0 &gt; $fee_total ) {
				$max_discount = NumberUtil::round( $cart_total + $fees_total + $shipping_total, kkart_get_price_decimals() ) * -1;

				if ( $fee_total &lt; $max_discount &amp;&amp; 0 &gt; $max_discount ) {
					$item-&gt;set_total( $max_discount );
				}
			}
			$fees_total += $item-&gt;get_total();
		}

		// Calculate taxes for items, shipping, discounts. Note; this also triggers save().
		if ( $and_taxes ) {
			$this-&gt;calculate_taxes();
		}

		// Sum taxes again so we can work out how much tax was discounted. This uses original values, not those possibly rounded to 2dp.
		foreach ( $this-&gt;get_items() as $item ) {
			$taxes = $item-&gt;get_taxes();

			foreach ( $taxes['total'] as $tax_rate_id =&gt; $tax ) {
				$cart_total_tax += (float) $tax;
			}

			foreach ( $taxes['subtotal'] as $tax_rate_id =&gt; $tax ) {
				$cart_subtotal_tax += (float) $tax;
			}
		}

		$this-&gt;set_discount_total( NumberUtil::round( $cart_subtotal - $cart_total, kkart_get_price_decimals() ) );
		$this-&gt;set_discount_tax( kkart_round_tax_total( $cart_subtotal_tax - $cart_total_tax ) );
		$this-&gt;set_total( NumberUtil::round( $cart_total + $fees_total + $this-&gt;get_shipping_total() + $this-&gt;get_cart_tax() + $this-&gt;get_shipping_tax(), kkart_get_price_decimals() ) );

		do_action( 'kkart_order_after_calculate_totals', $and_taxes, $this );

		$this-&gt;save();

		return $this-&gt;get_total();
	}

	/**
	 * Get item subtotal - this is the cost before discount.
	 *
	 * @param object $item Item to get total from.
	 * @param bool   $inc_tax (default: false).
	 * @param bool   $round (default: true).
	 * @return float
	 */
	public function get_item_subtotal( $item, $inc_tax = false, $round = true ) {
		$subtotal = 0;

		if ( is_callable( array( $item, 'get_subtotal' ) ) &amp;&amp; $item-&gt;get_quantity() ) {
			if ( $inc_tax ) {
				$subtotal = ( $item-&gt;get_subtotal() + $item-&gt;get_subtotal_tax() ) / $item-&gt;get_quantity();
			} else {
				$subtotal = floatval( $item-&gt;get_subtotal() ) / $item-&gt;get_quantity();
			}

			$subtotal = $round ? number_format( (float) $subtotal, kkart_get_price_decimals(), '.', '' ) : $subtotal;
		}

		return apply_filters( 'kkart_order_amount_item_subtotal', $subtotal, $this, $item, $inc_tax, $round );
	}

	/**
	 * Get line subtotal - this is the cost before discount.
	 *
	 * @param object $item Item to get total from.
	 * @param bool   $inc_tax (default: false).
	 * @param bool   $round (default: true).
	 * @return float
	 */
	public function get_line_subtotal( $item, $inc_tax = false, $round = true ) {
		$subtotal = 0;

		if ( is_callable( array( $item, 'get_subtotal' ) ) ) {
			if ( $inc_tax ) {
				$subtotal = $item-&gt;get_subtotal() + $item-&gt;get_subtotal_tax();
			} else {
				$subtotal = $item-&gt;get_subtotal();
			}

			$subtotal = $round ? NumberUtil::round( $subtotal, kkart_get_price_decimals() ) : $subtotal;
		}

		return apply_filters( 'kkart_order_amount_line_subtotal', $subtotal, $this, $item, $inc_tax, $round );
	}

	/**
	 * Calculate item cost - useful for gateways.
	 *
	 * @param object $item Item to get total from.
	 * @param bool   $inc_tax (default: false).
	 * @param bool   $round (default: true).
	 * @return float
	 */
	public function get_item_total( $item, $inc_tax = false, $round = true ) {
		$total = 0;

		if ( is_callable( array( $item, 'get_total' ) ) &amp;&amp; $item-&gt;get_quantity() ) {
			if ( $inc_tax ) {
				$total = ( $item-&gt;get_total() + $item-&gt;get_total_tax() ) / $item-&gt;get_quantity();
			} else {
				$total = floatval( $item-&gt;get_total() ) / $item-&gt;get_quantity();
			}

			$total = $round ? NumberUtil::round( $total, kkart_get_price_decimals() ) : $total;
		}

		return apply_filters( 'kkart_order_amount_item_total', $total, $this, $item, $inc_tax, $round );
	}

	/**
	 * Calculate line total - useful for gateways.
	 *
	 * @param object $item Item to get total from.
	 * @param bool   $inc_tax (default: false).
	 * @param bool   $round (default: true).
	 * @return float
	 */
	public function get_line_total( $item, $inc_tax = false, $round = true ) {
		$total = 0;

		if ( is_callable( array( $item, 'get_total' ) ) ) {
			// Check if we need to add line tax to the line total.
			$total = $inc_tax ? $item-&gt;get_total() + $item-&gt;get_total_tax() : $item-&gt;get_total();

			// Check if we need to round.
			$total = $round ? NumberUtil::round( $total, kkart_get_price_decimals() ) : $total;
		}

		return apply_filters( 'kkart_order_amount_line_total', $total, $this, $item, $inc_tax, $round );
	}

	/**
	 * Get item tax - useful for gateways.
	 *
	 * @param mixed $item Item to get total from.
	 * @param bool  $round (default: true).
	 * @return float
	 */
	public function get_item_tax( $item, $round = true ) {
		$tax = 0;

		if ( is_callable( array( $item, 'get_total_tax' ) ) &amp;&amp; $item-&gt;get_quantity() ) {
			$tax = $item-&gt;get_total_tax() / $item-&gt;get_quantity();
			$tax = $round ? kkart_round_tax_total( $tax ) : $tax;
		}

		return apply_filters( 'kkart_order_amount_item_tax', $tax, $item, $round, $this );
	}

	/**
	 * Get line tax - useful for gateways.
	 *
	 * @param mixed $item Item to get total from.
	 * @return float
	 */
	public function get_line_tax( $item ) {
		return apply_filters( 'kkart_order_amount_line_tax', is_callable( array( $item, 'get_total_tax' ) ) ? kkart_round_tax_total( $item-&gt;get_total_tax() ) : 0, $item, $this );
	}

	/**
	 * Gets line subtotal - formatted for display.
	 *
	 * @param object $item Item to get total from.
	 * @param string $tax_display Incl or excl tax display mode.
	 * @return string
	 */
	public function get_formatted_line_subtotal( $item, $tax_display = '' ) {
		$tax_display = $tax_display ? $tax_display : get_option( 'kkart_tax_display_cart' );

		if ( 'excl' === $tax_display ) {
			$ex_tax_label = $this-&gt;get_prices_include_tax() ? 1 : 0;

			$subtotal = kkart_price(
				$this-&gt;get_line_subtotal( $item ),
				array(
					'ex_tax_label' =&gt; $ex_tax_label,
					'currency'     =&gt; $this-&gt;get_currency(),
				)
			);
		} else {
			$subtotal = kkart_price( $this-&gt;get_line_subtotal( $item, true ), array( 'currency' =&gt; $this-&gt;get_currency() ) );
		}

		return apply_filters( 'kkart_order_formatted_line_subtotal', $subtotal, $item, $this );
	}

	/**
	 * Gets order total - formatted for display.
	 *
	 * @return string
	 */
	public function get_formatted_order_total() {
		$formatted_total = kkart_price( $this-&gt;get_total(), array( 'currency' =&gt; $this-&gt;get_currency() ) );
		return apply_filters( 'kkart_get_formatted_order_total', $formatted_total, $this );
	}

	/**
	 * Gets subtotal - subtotal is shown before discounts, but with localised taxes.
	 *
	 * @param bool   $compound (default: false).
	 * @param string $tax_display (default: the tax_display_cart value).
	 * @return string
	 */
	public function get_subtotal_to_display( $compound = false, $tax_display = '' ) {
		$tax_display = $tax_display ? $tax_display : get_option( 'kkart_tax_display_cart' );
		$subtotal    = $this-&gt;get_cart_subtotal_for_order();

		if ( ! $compound ) {

			if ( 'incl' === $tax_display ) {
				$subtotal_taxes = 0;
				foreach ( $this-&gt;get_items() as $item ) {
					$subtotal_taxes += self::round_line_tax( $item-&gt;get_subtotal_tax(), false );
				}
				$subtotal += kkart_round_tax_total( $subtotal_taxes );
			}

			$subtotal = kkart_price( $subtotal, array( 'currency' =&gt; $this-&gt;get_currency() ) );

			if ( 'excl' === $tax_display &amp;&amp; $this-&gt;get_prices_include_tax() &amp;&amp; kkart_tax_enabled() ) {
				$subtotal .= ' &lt;small class=&quot;tax_label&quot;&gt;' . KKART()-&gt;countries-&gt;ex_tax_or_vat() . '&lt;/small&gt;';
			}
		} else {
			if ( 'incl' === $tax_display ) {
				return '';
			}

			// Add Shipping Costs.
			$subtotal += $this-&gt;get_shipping_total();

			// Remove non-compound taxes.
			foreach ( $this-&gt;get_taxes() as $tax ) {
				if ( $tax-&gt;is_compound() ) {
					continue;
				}
				$subtotal = $subtotal + $tax-&gt;get_tax_total() + $tax-&gt;get_shipping_tax_total();
			}

			// Remove discounts.
			$subtotal = $subtotal - $this-&gt;get_total_discount();
			$subtotal = kkart_price( $subtotal, array( 'currency' =&gt; $this-&gt;get_currency() ) );
		}

		return apply_filters( 'kkart_order_subtotal_to_display', $subtotal, $compound, $this );
	}

	/**
	 * Gets shipping (formatted).
	 *
	 * @param string $tax_display Excl or incl tax display mode.
	 * @return string
	 */
	public function get_shipping_to_display( $tax_display = '' ) {
		$tax_display = $tax_display ? $tax_display : get_option( 'kkart_tax_display_cart' );

		if ( 0 &lt; abs( (float) $this-&gt;get_shipping_total() ) ) {

			if ( 'excl' === $tax_display ) {

				// Show shipping excluding tax.
				$shipping = kkart_price( $this-&gt;get_shipping_total(), array( 'currency' =&gt; $this-&gt;get_currency() ) );

				if ( (float) $this-&gt;get_shipping_tax() &gt; 0 &amp;&amp; $this-&gt;get_prices_include_tax() ) {
					$shipping .= apply_filters( 'kkart_order_shipping_to_display_tax_label', '&amp;nbsp;&lt;small class=&quot;tax_label&quot;&gt;' . KKART()-&gt;countries-&gt;ex_tax_or_vat() . '&lt;/small&gt;', $this, $tax_display );
				}
			} else {

				// Show shipping including tax.
				$shipping = kkart_price( $this-&gt;get_shipping_total() + $this-&gt;get_shipping_tax(), array( 'currency' =&gt; $this-&gt;get_currency() ) );

				if ( (float) $this-&gt;get_shipping_tax() &gt; 0 &amp;&amp; ! $this-&gt;get_prices_include_tax() ) {
					$shipping .= apply_filters( 'kkart_order_shipping_to_display_tax_label', '&amp;nbsp;&lt;small class=&quot;tax_label&quot;&gt;' . KKART()-&gt;countries-&gt;inc_tax_or_vat() . '&lt;/small&gt;', $this, $tax_display );
				}
			}

			/* translators: %s: method */
			$shipping .= apply_filters( 'kkart_order_shipping_to_display_shipped_via', '&amp;nbsp;&lt;small class=&quot;shipped_via&quot;&gt;' . sprintf( __( 'via %s', 'kkart' ), $this-&gt;get_shipping_method() ) . '&lt;/small&gt;', $this );

		} elseif ( $this-&gt;get_shipping_method() ) {
			$shipping = $this-&gt;get_shipping_method();
		} else {
			$shipping = __( 'Free!', 'kkart' );
		}

		return apply_filters( 'kkart_order_shipping_to_display', $shipping, $this, $tax_display );
	}

	/**
	 * Get the discount amount (formatted).
	 *
	 * @since  2.3.0
	 * @param string $tax_display Excl or incl tax display mode.
	 * @return string
	 */
	public function get_discount_to_display( $tax_display = '' ) {
		$tax_display = $tax_display ? $tax_display : get_option( 'kkart_tax_display_cart' );
		return apply_filters( 'kkart_order_discount_to_display', kkart_price( $this-&gt;get_total_discount( 'excl' === $tax_display &amp;&amp; 'excl' === get_option( 'kkart_tax_display_cart' ) ), array( 'currency' =&gt; $this-&gt;get_currency() ) ), $this );
	}

	/**
	 * Add total row for subtotal.
	 *
	 * @param array  $total_rows Reference to total rows array.
	 * @param string $tax_display Excl or incl tax display mode.
	 */
	protected function add_order_item_totals_subtotal_row( &amp;$total_rows, $tax_display ) {
		$subtotal = $this-&gt;get_subtotal_to_display( false, $tax_display );

		if ( $subtotal ) {
			$total_rows['cart_subtotal'] = array(
				'label' =&gt; __( 'Subtotal:', 'kkart' ),
				'value' =&gt; $subtotal,
			);
		}
	}

	/**
	 * Add total row for discounts.
	 *
	 * @param array  $total_rows Reference to total rows array.
	 * @param string $tax_display Excl or incl tax display mode.
	 */
	protected function add_order_item_totals_discount_row( &amp;$total_rows, $tax_display ) {
		if ( $this-&gt;get_total_discount() &gt; 0 ) {
			$total_rows['discount'] = array(
				'label' =&gt; __( 'Discount:', 'kkart' ),
				'value' =&gt; '-' . $this-&gt;get_discount_to_display( $tax_display ),
			);
		}
	}

	/**
	 * Add total row for shipping.
	 *
	 * @param array  $total_rows Reference to total rows array.
	 * @param string $tax_display Excl or incl tax display mode.
	 */
	protected function add_order_item_totals_shipping_row( &amp;$total_rows, $tax_display ) {
		if ( $this-&gt;get_shipping_method() ) {
			$total_rows['shipping'] = array(
				'label' =&gt; __( 'Shipping:', 'kkart' ),
				'value' =&gt; $this-&gt;get_shipping_to_display( $tax_display ),
			);
		}
	}

	/**
	 * Add total row for fees.
	 *
	 * @param array  $total_rows Reference to total rows array.
	 * @param string $tax_display Excl or incl tax display mode.
	 */
	protected function add_order_item_totals_fee_rows( &amp;$total_rows, $tax_display ) {
		$fees = $this-&gt;get_fees();

		if ( $fees ) {
			foreach ( $fees as $id =&gt; $fee ) {
				if ( apply_filters( 'kkart_get_order_item_totals_excl_free_fees', empty( $fee['line_total'] ) &amp;&amp; empty( $fee['line_tax'] ), $id ) ) {
					continue;
				}
				$total_rows[ 'fee_' . $fee-&gt;get_id() ] = array(
					'label' =&gt; $fee-&gt;get_name() . ':',
					'value' =&gt; kkart_price( 'excl' === $tax_display ? $fee-&gt;get_total() : $fee-&gt;get_total() + $fee-&gt;get_total_tax(), array( 'currency' =&gt; $this-&gt;get_currency() ) ),
				);
			}
		}
	}

	/**
	 * Add total row for taxes.
	 *
	 * @param array  $total_rows Reference to total rows array.
	 * @param string $tax_display Excl or incl tax display mode.
	 */
	protected function add_order_item_totals_tax_rows( &amp;$total_rows, $tax_display ) {
		// Tax for tax exclusive prices.
		if ( 'excl' === $tax_display &amp;&amp; kkart_tax_enabled() ) {
			if ( 'itemized' === get_option( 'kkart_tax_total_display' ) ) {
				foreach ( $this-&gt;get_tax_totals() as $code =&gt; $tax ) {
					$total_rows[ sanitize_title( $code ) ] = array(
						'label' =&gt; $tax-&gt;label . ':',
						'value' =&gt; $tax-&gt;formatted_amount,
					);
				}
			} else {
				$total_rows['tax'] = array(
					'label' =&gt; KKART()-&gt;countries-&gt;tax_or_vat() . ':',
					'value' =&gt; kkart_price( $this-&gt;get_total_tax(), array( 'currency' =&gt; $this-&gt;get_currency() ) ),
				);
			}
		}
	}

	/**
	 * Add total row for grand total.
	 *
	 * @param array  $total_rows Reference to total rows array.
	 * @param string $tax_display Excl or incl tax display mode.
	 */
	protected function add_order_item_totals_total_row( &amp;$total_rows, $tax_display ) {
		$total_rows['order_total'] = array(
			'label' =&gt; __( 'Total:', 'kkart' ),
			'value' =&gt; $this-&gt;get_formatted_order_total( $tax_display ),
		);
	}

	/**
	 * Get totals for display on pages and in emails.
	 *
	 * @param mixed $tax_display Excl or incl tax display mode.
	 * @return array
	 */
	public function get_order_item_totals( $tax_display = '' ) {
		$tax_display = $tax_display ? $tax_display : get_option( 'kkart_tax_display_cart' );
		$total_rows  = array();

		$this-&gt;add_order_item_totals_subtotal_row( $total_rows, $tax_display );
		$this-&gt;add_order_item_totals_discount_row( $total_rows, $tax_display );
		$this-&gt;add_order_item_totals_shipping_row( $total_rows, $tax_display );
		$this-&gt;add_order_item_totals_fee_rows( $total_rows, $tax_display );
		$this-&gt;add_order_item_totals_tax_rows( $total_rows, $tax_display );
		$this-&gt;add_order_item_totals_total_row( $total_rows, $tax_display );

		return apply_filters( 'kkart_get_order_item_totals', $total_rows, $this, $tax_display );
	}

	/*
	|--------------------------------------------------------------------------
	| Conditionals
	|--------------------------------------------------------------------------
	|
	| Checks if a condition is true or false.
	|
	*/

	/**
	 * Checks the order status against a passed in status.
	 *
	 * @param array|string $status Status to check.
	 * @return bool
	 */
	public function has_status( $status ) {
		return apply_filters( 'kkart_order_has_status', ( is_array( $status ) &amp;&amp; in_array( $this-&gt;get_status(), $status, true ) ) || $this-&gt;get_status() === $status, $this, $status );
	}

	/**
	 * Check whether this order has a specific shipping method or not.
	 *
	 * @param string $method_id Method ID to check.
	 * @return bool
	 */
	public function has_shipping_method( $method_id ) {
		foreach ( $this-&gt;get_shipping_methods() as $shipping_method ) {
			if ( strpos( $shipping_method-&gt;get_method_id(), $method_id ) === 0 ) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Returns true if the order contains a free product.
	 *
	 * @since 2.5.0
	 * @return bool
	 */
	public function has_free_item() {
		foreach ( $this-&gt;get_items() as $item ) {
			if ( ! $item-&gt;get_total() ) {
				return true;
			}
		}
		return false;
	}
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fsitepad%2Feditor%2Fsite-data%2Fplugins%2Fkkart-pro%2Fincludes%2Fabstracts'>Back to Directory</a>