@apicart/store-sdk/src/Entity/Order/OrderItem.ts

Apicart SDK for integrating store into any web application

import Apicart from '@apicart/core-sdk';
import Item from '../Item/Item';
import OrderItemParameter from './OrderItemParameter';

export default class OrderItem
{

	private _quantity: number;

	private _externalId: string;

	private _name: string

	private _price: number;

	private _totalPrice: number;

	private _parameters: OrderItemParameter[] = [];

	private _item: Item;


	constructor(
		quantity: number,
		externalId: string,
		name: string,
		price: number,
		totalPrice: number,
		item: Item,
		parameters: OrderItemParameter[] = []
	) {
		this._quantity = quantity;
		this._externalId = externalId;
		this._name = name;
		this._price = price;
		this._totalPrice = totalPrice;
		this._item = item;

		Apicart.Utils.Loops.forEach(parameters, (orderItemParameter: OrderItemParameter): void => {
			this.addParameter(orderItemParameter);
		});
	}

	public getQuantity(): number
	{
		return this._quantity;
	}

	public getExternalId(): string
	{
		return this._externalId;
	}

	public getName(): string
	{
		return this._name;
	}

	public getPrice(): number
	{
		return this._price;
	}

	public getTotalPrice(): number
	{
		return this._totalPrice;
	}

	public getItem(): Item {
		return this._item;
	}

	public getParameters(): OrderItemParameter[]
	{
		return this._parameters;
	}

	public addParameter(orderItemParameter: OrderItemParameter): void
	{
		let parameterUpdated = false;
		Apicart.Utils.Loops.forEach(this.getParameters(), (parameter: OrderItemParameter): void | boolean => {
			if (parameter.getKey() === orderItemParameter.getKey()) {
				parameter.setValue(orderItemParameter.getValue());
				parameterUpdated = true;
				return false;
			}
		});

		if (!parameterUpdated) {
			this._parameters.push(orderItemParameter);
		}
	}

	public removeParameter(key: string): void
	{
		Apicart.Utils.Loops.forEach(
			this.getParameters(),
			(parameter: OrderItemParameter, index: number): void | boolean => {
				if (parameter.getKey() === key) {
					delete this._parameters[index];
					return false;
				}
			}
		);
	}

	public getParameterValue(key: string, defaultValue: any = null): any
	{
		let parameterValue: any = defaultValue;

		Apicart.Utils.Loops.forEach(this.getParameters(), (parameter: OrderItemParameter): void | boolean => {
			if (parameter.getKey() === key) {
				parameterValue = parameter.getValue();
				return false;
			}
		});

		return parameterValue;
	}

	public static deserialize(data: any): OrderItem
	{
		Apicart.Utils.Loops.forEach(
			['quantity', 'externalId', 'name', 'price', 'totalPrice', 'item'],
			function (keyPath: string) {
				if (!Apicart.Utils.Objects.keyExists(data, keyPath)) {
					throw 'Orderitem: Missing required parameter: "' + keyPath + '".';
				}
			}
		);

		const item = Item.deserialize(data.item);
		const orderItem = new OrderItem(
			data.quantity, data.externalId, data.name, data.price, data.totalPrice, item
		);

		if ('parameters' in data && Array.isArray(data.parameters)) {
			Apicart.Utils.Loops.forEach(data.parameters, (parameter: any) => {
				if ('key' in parameter) {
					orderItem.addParameter(new OrderItemParameter(parameter.key, parameter.value || null));
				}
			});
		}

		return orderItem;
	}

}