merchi_sdk_ts 0.0.1

package/src/entities/quote.ts

@@ -0,0 +1,140 @@
+import { Assignment } from './assignment';
+import { QuoteItem } from './quote_item';
+import { Shipment } from './shipment';
+import { Invoice } from './invoice';
+import { Entity } from '../entity';
+import { kahanSum } from '../util/float';
+
+interface CalculateOptions {
+  strictEmbed?: boolean;
+}
+
+export class Quote extends Entity {
+  protected static resourceName = 'quotes';
+  protected static singularName = 'quote';
+  protected static pluralName = 'quotes';
+
+  @Quote.property({type: Date})
+  public archived?: Date | null;
+
+  @Quote.property()
+  public currency?: string;
+
+  @Quote.property()
+  public id?: number;
+
+  @Quote.property({type: Date})
+  public agreedDeadline?: Date | null;
+
+  @Quote.property({arrayType: 'Shipment'})
+  public shipments?: Shipment[];
+
+  @Quote.property({arrayType: 'QuoteItem'})
+  public quoteItems?: QuoteItem[];
+
+  @Quote.property({arrayType: 'Assignment'})
+  public assignments?: Assignment[];
+
+  @Quote.property({type: Invoice})
+  public invoice?: Invoice | null;
+
+  public quoteTotal = (options?: CalculateOptions) => {
+    const { strictEmbed = true } = options ? options : {};
+    const { quoteItems = [], shipments = [] } = this;
+    if (strictEmbed && this.quoteItems === undefined) {
+      throw new Error('quoteItems is undefined, did you forget to embed it?');
+    }
+    if (strictEmbed && this.shipments === undefined) {
+      throw new Error('shipments is undefined, did you forget to embed it?');
+    }
+    const quoteItemsTotal = kahanSum(quoteItems.map((qI: QuoteItem) =>
+      parseFloat(qI.calculateTotal(options)))).toFixed(3);
+    const shipmentItemsTotal = kahanSum(shipments.map((s: Shipment) =>
+      parseFloat(s.calculateTotal(options)))).toFixed(3);
+    return (
+      parseFloat(quoteItemsTotal) + parseFloat(shipmentItemsTotal)
+    ).toFixed(3);
+  };
+
+  public calculateTotal = this.quoteTotal;
+
+  public calculateSubTotal = (options?: CalculateOptions) => {
+    const { strictEmbed = true } = options ? options : {};
+    const { quoteItems = [], shipments = [] } = this;
+    if (strictEmbed && this.quoteItems === undefined) {
+      throw new Error('quoteItems is undefined, did you forget to embed it?');
+    }
+    if (strictEmbed && this.shipments === undefined) {
+      throw new Error('shipments is undefined, did you forget to embed it?');
+    }
+    const quoteItemsTotal = kahanSum(quoteItems.map((qI: QuoteItem) =>
+      parseFloat(qI.calculateSubTotal(options))));
+    const shipmentItemsTotal = kahanSum(shipments.map((s: Shipment) =>
+      parseFloat(s.calculateSubTotal(options))));
+    return (quoteItemsTotal + shipmentItemsTotal).toFixed(3);
+  };
+
+  public calculateTaxAmount = (options?: CalculateOptions) => {
+    const { strictEmbed = true } = options ? options : {};
+    const { quoteItems = [], shipments = [] } = this;
+    if (strictEmbed && this.quoteItems === undefined) {
+      throw new Error('quoteItems is undefined, did you forget to embed it?');
+    }
+    if (strictEmbed && this.shipments === undefined) {
+      throw new Error('shipments is undefined, did you forget to embed it?');
+    }
+    const quoteItemsTotal = kahanSum(quoteItems.map((qI: QuoteItem) =>
+      parseFloat(qI.calculateTaxAmount(options))));
+    const shipmentItemsTotal = kahanSum(shipments.map((s: Shipment) =>
+      parseFloat(s.calculateTaxAmount(options))));
+    return (quoteItemsTotal + shipmentItemsTotal).toFixed(3);
+  };
+
+  public findQuoteItemIndex = (quoteItemId: number) => {
+    if (this.quoteItems === undefined) {
+      throw new Error('quoteItems is undefined, did you forget to embed it?');
+    }
+    function checkEqualId(quoteItem: QuoteItem) {
+      return quoteItem.id === quoteItemId;
+    }
+    return this.quoteItems.findIndex(checkEqualId);
+  };
+
+  public removeQuoteItem = (quoteItem: QuoteItem) => {
+    if (this.quoteItems === undefined) {
+      throw new Error('quoteItems is undefined, did you forget to embed it?');
+    }
+    if (quoteItem.id === undefined) {
+      throw new Error('quoteItem.id is undefined, did you forget to embed it?');
+    }
+    const index = this.findQuoteItemIndex(quoteItem.id);
+    if (index > -1) {
+      this.quoteItems.splice(index, 1);
+    }
+  };
+
+  public deadlineTimeDifference = () => {
+    if (this.agreedDeadline === undefined) {
+      const err = 'agreedDeadline is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    if (this.assignments === undefined) {
+      const err = 'assignments is undefiend, did you forget to embed it?';
+      throw new Error(err);
+    }
+    if (this.assignments.length < 1) {
+      return null;
+    }
+    if (this.agreedDeadline === null) {
+      return null;
+    }
+    const assignment = this.assignments[0];
+    if (assignment.productionDeadline === undefined) {
+      const err = 'productionDeadline is undefined, did you forget to embed' +
+        'it?';
+      throw new Error(err);
+    }
+    const productionDeadline = assignment.productionDeadline;
+    return productionDeadline.valueOf() - this.agreedDeadline.valueOf();
+  };
+}

package/src/entities/quote_item.test.ts

@@ -0,0 +1,50 @@
+import { Merchi } from '../merchi';
+
+test('can make QuoteItem', () => {
+  const merchi = new Merchi();
+  const quoteItem = new merchi.QuoteItem();
+  expect(quoteItem).toBeTruthy();
+});
+
+test('total calculation', () => {
+  const merchi = new Merchi();
+  const quoteItem = new merchi.QuoteItem();
+
+  const gst = new merchi.CountryTax();
+  gst.taxName = 'GST';
+  gst.taxPercent = 10;
+  const noTax = merchi.CountryTax.getNoTax();
+
+  quoteItem.unitPrice = 10;
+  quoteItem.quantity = 1;
+
+  // tax type not provided yet should be a embed issue
+  expect(quoteItem.calculateTotal()).toEqual('10.000');
+  expect(quoteItem.calculateTotal({strictEmbed: false})).toEqual('10.000');
+
+  // quote total include tax type properly
+  quoteItem.taxType = gst;
+  expect(quoteItem.calculateTotal()).toEqual('11.000');
+  quoteItem.taxType = noTax;
+  expect(quoteItem.calculateTotal()).toEqual('10.000');
+
+  // null and undefined price and quantity will throw error unless not strictly
+  // require embed
+  quoteItem.unitPrice = null;
+  expect(quoteItem.calculateTotal({strictEmbed: false})).toEqual('0.000');
+
+  quoteItem.unitPrice = 1;
+  quoteItem.quantity = undefined;
+  expect(() => quoteItem.calculateTotal()).toThrow();
+  expect(quoteItem.calculateTotal({strictEmbed: false})).toEqual('0.000');
+
+  quoteItem.unitPrice = undefined;
+  quoteItem.quantity = 1;
+  expect(() => quoteItem.calculateTotal()).toThrow();
+  expect(quoteItem.calculateTotal({strictEmbed: false})).toEqual('0.000');
+
+  // make sure float number recorded correctly
+  quoteItem.quantity = 3.55;
+  quoteItem.unitPrice = 87.12;
+  expect(quoteItem.calculateTotal()).toEqual('309.276');
+});

package/src/entities/quote_item.ts

@@ -0,0 +1,71 @@
+import { CountryTax } from './country_tax';
+import { Entity } from '../entity';
+import { Quote } from './quote';
+
+interface CalculateOptions {
+  strictEmbed?: boolean;
+}
+
+export class QuoteItem extends Entity {
+  protected static resourceName = 'quote_items';
+  protected static singularName = 'quoteItem';
+  protected static pluralName = 'quoteItems';
+
+  @QuoteItem.property({type: Date})
+  public archived?: Date | null;
+
+  @QuoteItem.property()
+  public id?: number;
+
+  @QuoteItem.property()
+  public type?: number;
+
+  @QuoteItem.property()
+  public quantity?: number;
+
+  @QuoteItem.property({type: String})
+  public description?: string | null;
+
+  @QuoteItem.property({type: Number})
+  public unitPrice?: number | null;
+
+  @QuoteItem.property({type: Number})
+  public taxAmount?: number | null;
+
+  @QuoteItem.property({type: CountryTax})
+  public taxType?: CountryTax;
+
+  @QuoteItem.property()
+  public quote?: Quote;
+
+  public calculateSubTotal = (options?: CalculateOptions) => {
+    const { strictEmbed = true } = options ? options : {};
+    if (strictEmbed){
+      if (this.unitPrice === undefined) {
+        throw new Error('unitPrice is undefined, did you forget to embed it?');
+      }
+      if (this.quantity === undefined) {
+        throw new Error('quantity is undefined, did you forget to embed it?');
+      }
+    }
+    const quant = this.quantity ? this.quantity : 0;
+    const unitPrice = this.unitPrice ? this.unitPrice : 0;
+    return (quant * unitPrice).toFixed(3);
+  };
+
+  public calculateTaxAmount = (options?: CalculateOptions) => {
+    const taxPercent = this.taxType && this.taxType.taxPercent ?
+      this.taxType.taxPercent : 0;
+    const taxRate = taxPercent ? Number(taxPercent) / 100 : 0;
+    return (parseFloat(
+      this.calculateSubTotal(options)) * taxRate).toFixed(3);
+  };
+
+  public calculateTotal = (options?: CalculateOptions) => {
+    return (
+      parseFloat(this.calculateSubTotal(options)) +
+      parseFloat(this.calculateTaxAmount(options))
+    ).toFixed(3);
+  };
+
+}

package/src/entities/seo_domain_page.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi';
+
+test('can make SeoDomainPage', () => {
+  const merchi = new Merchi();
+  const seoDomainPage = new merchi.SeoDomainPage();
+  expect(seoDomainPage).toBeTruthy();
+});

package/src/entities/seo_domain_page.ts

@@ -0,0 +1,33 @@
+import { Domain } from './domain';
+import { Product } from './product';
+import { Entity } from '../entity';
+
+export class SeoDomainPage extends Entity {
+  protected static resourceName = 'seo_domain_pages';
+  protected static singularName = 'seoDomainPage';
+  protected static pluralName = 'seoDomainPages';
+
+  @SeoDomainPage.property({type: Date})
+  public archived?: Date | null;
+
+  @SeoDomainPage.property()
+  public id?: number;
+
+  @SeoDomainPage.property()
+  public domain?: Domain;
+
+  @SeoDomainPage.property()
+  public product?: Product;
+
+  @SeoDomainPage.property()
+  public metaDescription?: string;
+
+  @SeoDomainPage.property()
+  public metaRobots?: string;
+
+  @SeoDomainPage.property()
+  public metaTitle?: string;
+
+  @SeoDomainPage.property()
+  public pageKey?: string;
+}

package/src/entities/session.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi';
+
+test('can make Session', () => {
+  const merchi = new Merchi();
+  const session = new merchi.Session();
+  expect(session).toBeTruthy();
+});

package/src/entities/session.ts

@@ -0,0 +1,28 @@
+import { Domain } from './domain';
+import { Entity } from '../entity';
+import { User } from './user';
+
+export class Session extends Entity {
+  protected static resourceName = 'sessions';
+  protected static singularName = 'session';
+  protected static pluralName = 'sessions';
+  protected static primaryKey = 'token';
+
+  @Session.property({type: Date})
+  public archived?: Date | null;
+
+  @Session.property({type: String})
+  public ip?: string | null;
+
+  @Session.property()
+  public token?: string;
+
+  @Session.property({type: Boolean})
+  public remember?: boolean | null;
+
+  @Session.property()
+  public user?: User;
+
+  @Session.property({type: Domain})
+  public domain?: Domain | null;
+}

package/src/entities/shipment.test.ts

@@ -0,0 +1,24 @@
+import { Merchi } from '../merchi';
+
+test('can make Shipment', () => {
+  const merchi = new Merchi();
+  const shipment = new merchi.Shipment();
+  expect(shipment).toBeTruthy();
+});
+
+test('can calculation undefined handling', () => {
+  const merchi = new Merchi();
+  const shipment = new merchi.Shipment();
+  expect(() => shipment.calculateSubTotal()).toThrow();
+  expect(shipment.calculateSubTotal({strictEmbed: false})).toEqual('0.000');
+
+  expect(() => shipment.calculateTaxAmount()).toThrow();
+  expect(shipment.calculateTaxAmount({strictEmbed: false})).toEqual('0.000');
+});
+
+test('can calculation tax with tax type undefined', () => {
+  const merchi = new Merchi();
+  const shipment = new merchi.Shipment();
+  shipment.cost = 0;
+  expect(shipment.calculateTaxAmount()).toEqual('0.000');
+});

package/src/entities/shipment.ts

@@ -0,0 +1,185 @@
+import { Address } from './address';
+import { Assignment } from './assignment';
+import { Company } from './company';
+import { CountryTax } from './country_tax';
+import { DomainTag } from './domain_tag';
+import { Entity } from '../entity';
+import { InternalTag } from './internal_tag';
+import { Invoice } from './invoice';
+import { Quote } from './quote';
+import { Job } from './job';
+import { MerchiFile } from './file';
+import { User } from './user';
+import { ShipmentItem } from './shipment_item';
+import { ShipmentMethod } from './shipment_method';
+
+interface CalculateOptions {
+  strictEmbed?: boolean;
+}
+
+export class Shipment extends Entity {
+  protected static resourceName = 'shipments';
+  protected static singularName = 'shipment';
+  protected static pluralName = 'shipments';
+
+  @Shipment.property({type: Date})
+  public archived?: Date | null;
+
+  @Shipment.property()
+  public id?: number;
+
+  @Shipment.property()
+  public name?: string;
+
+  @Shipment.property()
+  public shipmentServiceBookingInfo?: string;
+
+  @Shipment.property()
+  public shipmentServiceQuote?: string;
+
+  @Shipment.property()
+  public pickUp?: boolean;
+
+  @Shipment.property({arrayType: 'InternalTag'})
+  public internalTags?: InternalTag[];
+
+  @Shipment.property({type: MerchiFile})
+  public shipmentLabel?: MerchiFile | null;
+
+  @Shipment.property({type: Date})
+  public creationDate?: Date | null;
+
+  @Shipment.property({type: Date})
+  public dispatchedDate?: Date | null;
+
+  @Shipment.property({type: Date})
+  public dispatchDate?: Date | null;
+
+  @Shipment.property({type: Date})
+  public expectedReceiveDate?: Date | null;
+
+  @Shipment.property({type: Date})
+  public receivedDate?: Date | null;
+
+  @Shipment.property()
+  public senderResponsible?: boolean;
+
+  @Shipment.property({type: String})
+  public senderNotes?: string | null;
+
+  @Shipment.property({type: String})
+  public receiverNotes?: string | null;
+
+  @Shipment.property({type: Number})
+  public transportCompany?: number | null;
+
+  @Shipment.property({type: String})
+  public transportCompanyName?: string | null;
+
+  @Shipment.property({type: String})
+  public trackingNumber?: string | null;
+
+  @Shipment.property({type: Number})
+  public buyCost?: number | null;
+
+  @Shipment.property({type: String})
+  public buyCurrency?: string | null;
+
+  @Shipment.property({type: Number})
+  public cost?: number | null;
+
+  @Shipment.property({type: Number})
+  public taxAmount?: number | null;
+
+  @Shipment.property({type: Number})
+  public maxWeight?: number | null;
+
+  @Shipment.property({type: Number})
+  public maxVolume?: number | null;
+
+  @Shipment.property()
+  public sendSms?: boolean;
+
+  @Shipment.property()
+  public sendEmail?: boolean;
+
+  @Shipment.property({type: CountryTax})
+  public taxType?: CountryTax | null;
+
+  @Shipment.property()
+  public isOnBehalfOf?: boolean;
+
+  @Shipment.property({type: User})
+  public onBehalfOf?: User | null;
+
+  @Shipment.property({type: Company})
+  public onBehalfOfCompany?: Company | null;
+
+  @Shipment.property({type: User})
+  public sender?: User | null;
+
+  @Shipment.property({type: Company})
+  public senderCompany?: Company | null;
+
+  @Shipment.property({type: Address})
+  public senderAddress?: Address | null;
+
+  @Shipment.property({type: String})
+  public blindShipTo?: string | null;
+
+  @Shipment.property({type: User})
+  public receiver?: User | null;
+
+  @Shipment.property({type: Company})
+  public receiverCompany?: Company | null;
+
+  @Shipment.property({type: Address})
+  public receiverAddress?: Address | null;
+
+  @Shipment.property({arrayType: 'Invoice'})
+  public invoices?: Invoice[];
+
+  @Shipment.property({type: Quote})
+  public quote?: Quote | null;
+
+  @Shipment.property({type: ShipmentMethod})
+  public shipmentMethod?: ShipmentMethod | null;
+
+  @Shipment.property({arrayType: 'DomainTag'})
+  public tags?: DomainTag[];
+
+  @Shipment.property({arrayType: 'Assignment'})
+  public assignments?: Assignment[];
+
+  @Shipment.property({arrayType: 'ShipmentItem'})
+  public items?: ShipmentItem[];
+
+  @Shipment.property({arrayType: 'Job'})
+  public jobs?: Job[];
+
+  public calculateSubTotal = (options?: CalculateOptions) => {
+    const { strictEmbed = true } = options ? options : {};
+    if (strictEmbed){
+      if (this.cost === undefined) {
+        throw new Error('cost is undefined, did you forget to embed it?');
+      }
+    }
+    const cost = this.cost ? this.cost : 0;
+    return parseFloat(String(cost)).toFixed(3);
+  };
+
+  public calculateTaxAmount = (options?: CalculateOptions) => {
+    const taxPercent = this.taxType && this.taxType.taxPercent ?
+      this.taxType.taxPercent : 0;
+    const taxRate = taxPercent ? Number(taxPercent) / 100 : 0;
+    return (parseFloat(
+      this.calculateSubTotal(options)) * taxRate).toFixed(3);
+  };
+
+  public calculateTotal = (options?: CalculateOptions) => {
+    return (
+      parseFloat(this.calculateSubTotal(options)) +
+      parseFloat(this.calculateTaxAmount(options))
+    ).toFixed(3);
+  };
+}

package/src/entities/shipment_item.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi';
+
+test('can make ShipmentItem', () => {
+  const merchi = new Merchi();
+  const shipmentItem = new merchi.ShipmentItem();
+  expect(shipmentItem).toBeTruthy();
+});

package/src/entities/shipment_item.ts

@@ -0,0 +1,15 @@
+import { Entity } from '../entity';
+import { Job } from './job';
+import { ShipmentItemFulfillment } from './shipment_item_fulfillment';
+
+export class ShipmentItem extends Entity {
+  protected static resourceName = 'shipment_items';
+  protected static singularName = 'shipmentItem';
+  protected static pluralName = 'shipmentItems';
+
+  @ShipmentItem.property({type: Job})
+  public job?: Job;
+
+  @ShipmentItem.property({arrayType: 'ShipmentItemFulfillment'})
+  public fulfillments?: ShipmentItemFulfillment[];
+}

package/src/entities/shipment_item_fulfillment.test.ts

@@ -0,0 +1,8 @@
+import { Merchi } from '../merchi';
+
+test('can make ShipmentItemFulfillment', () => {
+  const merchi = new Merchi();
+  const shipmentItemFulfillment =
+    new merchi.ShipmentItemFulfillment();
+  expect(shipmentItemFulfillment).toBeTruthy();
+});

package/src/entities/shipment_item_fulfillment.ts

@@ -0,0 +1,15 @@
+import { Entity } from '../entity';
+import { Assignment } from './assignment';
+import { Job } from './job';
+
+export class ShipmentItemFulfillment extends Entity {
+  protected static resourceName = 'shipment_item_fulfillments';
+  protected static singularName = 'shipmentItemFulfillment';
+  protected static pluralName = 'shipmentItemFulfillments';
+
+  @ShipmentItemFulfillment.property({type: 'Assignment'})
+  public assignment?: Assignment;
+
+  @ShipmentItemFulfillment.property({type: 'Job'})
+  public job?: Job;
+}

package/src/entities/shipment_method.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi';
+
+test('can make ShipmentMethod', () => {
+  const merchi = new Merchi();
+  const shipmentMethod = new merchi.ShipmentMethod();
+  expect(shipmentMethod).toBeTruthy();
+});

package/src/entities/shipment_method.ts

@@ -0,0 +1,61 @@
+import { ShipmentService } from '../constants/shipment_services';
+import { Entity } from '../entity';
+import { Address } from './address';
+import { Company } from './company';
+import { CountryTax } from './country_tax';
+import { Product } from './product';
+import { ShipmentMethodVariation } from './shipment_method_variation';
+
+export class ShipmentMethod extends Entity {
+  protected static resourceName = 'shipment_methods';
+  protected static singularName = 'shipmentMethod';
+  protected static pluralName = 'shipmentMethods';
+
+  @ShipmentMethod.property()
+  public id?: number;
+
+  @ShipmentMethod.property()
+  public name?: string;
+
+  @ShipmentMethod.property({type: ShipmentService})
+  public shipmentService?: ShipmentService | null;
+
+  @ShipmentMethod.property({type: Address})
+  public originAddress?: Address | null;
+
+  @ShipmentMethod.property()
+  public pickUp?: boolean;
+
+  @ShipmentMethod.property({type: Company})
+  public company?: Company | null;
+
+  @ShipmentMethod.property()
+  public companyDefault?: boolean;
+
+  @ShipmentMethod.property()
+  public defaultCost?: number;
+
+  @ShipmentMethod.property()
+  public currency?: string;
+
+  @ShipmentMethod.property()
+  public buyCost?: number;
+
+  @ShipmentMethod.property()
+  public buyCurrency?: string;
+
+  @ShipmentMethod.property({type: Number})
+  public transportCompany?: number | null;
+
+  @ShipmentMethod.property()
+  public transportCompanyName?: string;
+
+  @ShipmentMethod.property({type: CountryTax})
+  public taxType?: CountryTax | null;
+
+  @ShipmentMethod.property({arrayType: 'ShipmentMethodVariation'})
+  public variations?: ShipmentMethodVariation[];
+
+  @ShipmentMethod.property({arrayType: 'Product'})
+  public products?: Product[];
+}

package/src/entities/shipment_method_variation.test.ts

@@ -0,0 +1,7 @@
+import { Merchi } from '../merchi';
+
+test('can make ShipmentMethodVariation', () => {
+  const merchi = new Merchi();
+  const shipmentMethodVariation = new merchi.ShipmentMethodVariation();
+  expect(shipmentMethodVariation).toBeTruthy();
+});