merchi_sdk_ts 0.0.1

package/src/entities/internal_tag.test.ts

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

package/src/entities/internal_tag.ts

@@ -0,0 +1,51 @@
+import { Company } from './company';
+import { Domain } from './domain';
+import { Entity } from '../entity';
+import { Invoice } from './invoice';
+import { Job } from './job';
+import { Product } from './product';
+import { Shipment } from './shipment';
+import { Theme } from './theme';
+import { User } from './user';
+
+export class InternalTag extends Entity {
+  protected static resourceName = 'internal_tags';
+  protected static singularName = 'internalTag';
+  protected static pluralName = 'internalTags';
+
+  @InternalTag.property()
+  public id?: number;
+
+  @InternalTag.property()
+  public colour?: number;
+
+  @InternalTag.property()
+  public name?: string;
+
+  @InternalTag.property()
+  public description?: string;
+
+  @InternalTag.property({arrayType: 'Company'})
+  public companies?: Company[];
+
+  @InternalTag.property({arrayType: 'Domain'})
+  public domains?: Domain[];
+
+  @InternalTag.property({arrayType: 'Job'})
+  public jobs?: Job[];
+
+  @InternalTag.property({arrayType: 'Product'})
+  public products?: Product[];
+
+  @InternalTag.property({arrayType: 'Invoice'})
+  public invoices?: Invoice[];
+
+  @InternalTag.property({arrayType: 'Shipment'})
+  public shipments?: Shipment[];
+
+  @InternalTag.property({arrayType: 'Theme'})
+  public themes?: Theme[];
+
+  @InternalTag.property({arrayType: 'User'})
+  public users?: User[];
+}

package/src/entities/inventory.test.ts

@@ -0,0 +1,28 @@
+import { Merchi } from '../merchi';
+
+test('can make Inventory', () => {
+  const merchi = new Merchi();
+  const inventory = new merchi.Inventory();
+  expect(inventory).toBeTruthy();
+});
+
+test('isVariationFieldOptionSelected function', () => {
+  const merchi = new Merchi();
+  const inventory = new merchi.Inventory();
+  const option1 = new merchi.VariationFieldsOption();
+  option1.id = 1;
+  const option2 = new merchi.VariationFieldsOption();
+  option2.id = 2;
+  expect(() => inventory.isVariationFieldOptionSelected(option1)).toThrow();
+
+  const inventoryUnitVariation = new merchi.InventoryUnitVariation();
+  inventory.inventoryUnitVariations = [inventoryUnitVariation];
+
+  expect(() => inventory.isVariationFieldOptionSelected(option1)).toThrow();
+
+  inventoryUnitVariation.variationFieldsOption = option2;
+  expect(inventory.isVariationFieldOptionSelected(option1)).toBe(false);
+
+  inventoryUnitVariation.variationFieldsOption = option1;
+  expect(inventory.isVariationFieldOptionSelected(option1)).toBe(true);
+});

package/src/entities/inventory.ts

@@ -0,0 +1,56 @@
+import { Address } from './address';
+import { Entity } from '../entity';
+import { InventoryUnitVariation } from './inventory_unit_variation';
+import { Job } from './job';
+import { Product } from './product';
+import { VariationsGroup } from './variations_group';
+import { VariationFieldsOption } from './variation_fields_option';
+import { some } from 'lodash';
+
+export class Inventory extends Entity {
+  protected static resourceName = 'inventories';
+  protected static singularName = 'inventory';
+  protected static pluralName = 'inventories';
+
+  @Inventory.property({type: Date})
+  public archived?: Date | null;
+
+  @Inventory.property()
+  public id?: number;
+
+  @Inventory.property()
+  public quantity?: number;
+
+  @Inventory.property()
+  public name?: string;
+
+  @Inventory.property()
+  public notes?: string;
+
+  @Inventory.property()
+  public isOrphan?: boolean;
+
+  @Inventory.property({arrayType: 'Product'})
+  public products?: Product[];
+
+  @Inventory.property({type: Address})
+  public address?: Address | null;
+
+  @Inventory.property({arrayType: 'VariationsGroup'})
+  public variationsGroups?: VariationsGroup[];
+
+  @Inventory.property({arrayType: 'Job'})
+  public jobs?: Job[];
+
+  @Inventory.property({arrayType: 'InventoryUnitVariation'})
+  public inventoryUnitVariations?: InventoryUnitVariation[];
+
+  public isVariationFieldOptionSelected = (option: VariationFieldsOption) => {
+    if (this.inventoryUnitVariations === undefined) {
+      throw new Error(
+        'inventoryUnitVariations is undefined, did you forget to embed it?');
+    }
+    return some(this.inventoryUnitVariations.map(
+      (v: InventoryUnitVariation) => v.optionId() === option.id));
+  };
+}

package/src/entities/inventory_unit_variation.test.ts

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

package/src/entities/inventory_unit_variation.ts

@@ -0,0 +1,29 @@
+import { Entity } from '../entity';
+import { Inventory } from './inventory';
+import { VariationFieldsOption } from './variation_fields_option';
+
+export class InventoryUnitVariation extends Entity {
+  protected static resourceName = 'inventory_unit_variations';
+  protected static singularName = 'inventoryUnitVariation';
+  protected static pluralName = 'inventoryUnitVariations';
+
+  @InventoryUnitVariation.property({type: Date})
+  public archived?: Date | null;
+
+  @InventoryUnitVariation.property()
+  public id?: number;
+
+  @InventoryUnitVariation.property()
+  public inventory?: Inventory;
+
+  @InventoryUnitVariation.property()
+  public variationFieldsOption?: VariationFieldsOption;
+
+  public optionId = () => {
+    if (this.variationFieldsOption === undefined) {
+      throw new Error(
+        'variationFieldsOption is undefined, did you forget to embed it?');
+    }
+    return this.variationFieldsOption.id;
+  };
+}

package/src/entities/invoice.test.ts

@@ -0,0 +1,43 @@
+import { setup, mockFetch } from '../test_util';
+import { Merchi } from '../merchi';
+
+setup();
+
+test('can make Invoice', () => {
+  const merchi = new Merchi();
+  const invoice = new merchi.Invoice();
+  expect(invoice).toBeTruthy();
+});
+
+test('pass cookie tokens to query string', () => {
+  const cookie = 'session_token=s; client_token=c; invoice_token=i';
+  Object.defineProperty(document, 'cookie', {
+    get: jest.fn().mockImplementation(() => { return cookie; }),
+    set: jest.fn().mockImplementation(() => {}),
+  });
+  const correct = [
+    ['skip_rights', 'y'],
+    ['session_token', 's'],
+    ['client_token', 'c'],
+    ['invoice_token', 'i'],
+  ];
+  const fetch = mockFetch(true, {'invoice': {'id': 1}}, 200);
+  const merchi = new Merchi();
+  const invocation = merchi.Invoice.get(1);
+  expect(fetch.mock.calls[0][1]['query']).toEqual(correct);
+  return invocation;
+});
+
+test('client and invoice tokens supported by merchi', () => {
+  const merchi = new Merchi('s', 'c', 'i');
+  const correct = [
+    ['skip_rights', 'y'],
+    ['session_token', 's'],
+    ['client_token', 'c'],
+    ['invoice_token', 'i'],
+  ];
+  const fetch = mockFetch(true, {'invoice': {'id': 1}}, 200);
+  const invocation = merchi.Invoice.get(1);
+  expect(fetch.mock.calls[0][1]['query']).toEqual(correct);
+  return invocation;
+});

package/src/entities/invoice.ts

@@ -0,0 +1,179 @@
+import { Address } from './address';
+import { Cart } from './cart';
+import { Company } from './company';
+import { Domain } from './domain';
+import { DomainTag } from './domain_tag';
+import { EmailAddress } from './email_address';
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+import { InternalTag } from './internal_tag';
+import { Item } from './item';
+import { Job } from './job';
+import { Quote } from './quote';
+import { Notification } from './notification';
+import { Payment } from './payment';
+import { PhoneNumber } from './phone_number';
+import { Shipment } from './shipment';
+import { User } from './user';
+
+export class Invoice extends Entity {
+  protected static resourceName = 'invoices';
+  protected static singularName = 'invoice';
+  protected static pluralName = 'invoices';
+
+  @Invoice.property({type: Date})
+  public archived?: Date | null;
+
+  @Invoice.property()
+  public id?: number;
+
+  @Invoice.property({type: Date})
+  public creationDate?: Date | null;
+
+  @Invoice.property({type: Date})
+  public paymentDeadline?: Date | null;
+
+  @Invoice.property({type: Date})
+  public reminded?: Date | null;
+
+  @Invoice.property()
+  public reminderMessage?: string;
+
+  @Invoice.property()
+  public shopifyOrderId?: string;
+
+  @Invoice.property()
+  public forceReminders?: boolean;
+
+  @Invoice.property()
+  public buySide?: boolean;
+
+  @Invoice.property()
+  public canAutoPay?: boolean;
+
+  @Invoice.property({type: String})
+  public note?: string | null;
+
+  @Invoice.property({type: Date})
+  public terms?: Date | null;
+
+  @Invoice.property({type: Number})
+  public subtotalCost?: number | null;
+
+  @Invoice.property({type: Number})
+  public taxAmount?: number | null;
+
+  @Invoice.property({type: Number})
+  public totalCost?: number | null;
+
+  @Invoice.property({type: Boolean})
+  public sendSms?: boolean | null;
+
+  @Invoice.property({type: Boolean})
+  public sendEmail?: boolean | null;
+
+  @Invoice.property({type: Boolean})
+  public unpaid?: boolean | null;
+
+  @Invoice.property()
+  public currency?: string;
+
+  @Invoice.property()
+  public acceptSquare?: boolean;
+
+  @Invoice.property()
+  public acceptStripe?: boolean;
+
+  @Invoice.property()
+  public acceptPaypal?: boolean;
+
+  @Invoice.property()
+  public acceptUtrust?: boolean;
+
+  @Invoice.property()
+  public acceptBankTransfer?: boolean;
+
+  @Invoice.property()
+  public acceptPhonePayment?: boolean;
+
+  @Invoice.property({type: String})
+  public invoiceToken?: string | null;
+
+  @Invoice.property()
+  public isRemindable?: boolean;
+
+  @Invoice.property({embeddedByDefault: false})
+  public owedMoney?: number;
+
+  @Invoice.property({embeddedByDefault: false})
+  public paidMoney?: number;
+
+  @Invoice.property({embeddedByDefault: false})
+  public isCompletelyPaid?: boolean;
+
+  @Invoice.property({type: User})
+  public responsibleManager?: User | null;
+
+  @Invoice.property({type: User})
+  public creator?: User | null;
+
+  @Invoice.property()
+  public client?: User;
+
+  @Invoice.property({type: Company})
+  public clientCompany?: Company | null;
+
+  @Company.property({arrayType: 'Company'})
+  public subscriptionCompanies?: Company[];
+
+  @Invoice.property({type: Address})
+  public shipping?: Address | null;
+
+  @Invoice.property()
+  public domain?: Domain;
+
+  @Invoice.property({arrayType: 'Item'})
+  public items?: Item[];
+
+  @Invoice.property({type: MerchiFile})
+  public pdf?: MerchiFile | null;
+
+  @Invoice.property({type: MerchiFile})
+  public receipt?: MerchiFile | null;
+
+  @Invoice.property({type: PhoneNumber})
+  public clientPhone?: PhoneNumber | null;
+
+  @Invoice.property({type: EmailAddress})
+  public clientEmail?: EmailAddress | null;
+
+  @Invoice.property({type: PhoneNumber})
+  public clientCompanyPhone?: PhoneNumber | null;
+
+  @Invoice.property({type: EmailAddress})
+  public clientCompanyEmail?: EmailAddress | null;
+
+  @Invoice.property({arrayType: 'InternalTag'})
+  public internalTags?: InternalTag[];
+
+  @Invoice.property({arrayType: 'DomainTag'})
+  public tags?: DomainTag[];
+
+  @Invoice.property({arrayType: 'Shipment'})
+  public shipments?: Shipment[];
+
+  @Invoice.property({arrayType: 'Notification'})
+  public notifications?: Notification[];
+
+  @Invoice.property({arrayType: 'Job'})
+  public jobs?: Job[];
+
+  @Invoice.property({arrayType: 'Quote'})
+  public quotes?: Quote[];
+
+  @Invoice.property()
+  public cart?: Cart;
+
+  @Invoice.property({arrayType: 'Payment'})
+  public payments?: Payment[];
+}

package/src/entities/item.test.ts

@@ -0,0 +1,19 @@
+import { Merchi } from '../merchi';
+
+test('can make Item', () => {
+  const merchi = new Merchi();
+  const item = new merchi.Item();
+  expect(item).toBeTruthy();
+});
+
+test('totalCost', () => {
+  const merchi = new Merchi();
+  const item = new merchi.Item();
+  expect(item.totalCost).toThrow();
+  item.quantity = 2.3;
+  expect(item.totalCost).toThrow();
+  item.cost = 4.9;
+  expect(item.totalCost()).toEqual(11.27);
+  item.quantity = null;
+  expect(item.totalCost()).toEqual(0);
+});

package/src/entities/item.ts

@@ -0,0 +1,44 @@
+import { CountryTax } from './country_tax';
+import { Entity } from '../entity';
+import { Invoice } from './invoice';
+
+export class Item extends Entity {
+  protected static resourceName = 'items';
+  protected static singularName = 'item';
+  protected static pluralName = 'items';
+
+  @Item.property({type: Date})
+  public archived?: Date | null;
+
+  @Item.property()
+  public id?: number;
+
+  @Item.property({type: Number})
+  public quantity?: number | null;
+
+  @Item.property()
+  public description?: string;
+
+  @Item.property()
+  public cost?: number;
+
+  @Item.property({type: Number})
+  public taxAmount?: number | null;
+
+  @Item.property({type: CountryTax})
+  public taxType?: CountryTax | null;
+
+  @Item.property({type: Invoice})
+  public invoice?: Invoice | null;
+
+  public totalCost = () => {
+    if (this.quantity === undefined) {
+      throw 'quantity is undefined, did you forget to embed it?';
+    }
+    if (this.cost === undefined) {
+      throw 'cost is undefined, did you forget to embed it?';
+    }
+    const quantity = this.quantity === null ? 0 : this.quantity;
+    return quantity * this.cost;
+  };
+}

package/src/entities/job.test.ts

@@ -0,0 +1,95 @@
+import { Merchi } from '../merchi';
+import { setup, mockFetch } from '../test_util';
+import { InventoryStatus } from '../constants/inventory_statuses';
+
+setup();
+
+test('can make Job', () => {
+  const merchi = new Merchi();
+  const job = new merchi.Job();
+  expect(job).toBeTruthy();
+});
+
+test('Job deadline serialised to milliseconds in form data', () => {
+  const merchi = new Merchi();
+  const job = new merchi.Job();
+  job.deadline = new Date('Feb 28 2013 19:00:00 GMT-0500');
+  const correct = [['deadline', '1362096000']];
+  const backData = Array.from((job.toFormData() as any).entries());
+  expect(backData).toEqual(correct);
+});
+
+test('Job deadline serialised to milliseconds in JSON', () => {
+  const merchi = new Merchi();
+  const job = new merchi.Job();
+  job.deadline = new Date('Feb 28 2013 19:00:00 GMT-0500');
+  const jobJson = job.toJson();
+  expect(jobJson.deadline).toEqual(1362096000);
+});
+
+test('Job deadline serialised from milliseconds in JSON', () => {
+  const merchi = new Merchi();
+  const job = new merchi.Job().fromJson({deadline: 1362096000});
+  expect(job.deadline).toEqual(new Date('Feb 28 2013 19:00:00 GMT-0500'));
+});
+
+test('add two files to job', () => {
+  const merchi = new Merchi();
+  const job = new merchi.Job();
+  const f1 = new merchi.MerchiFile();
+  f1.fromFormFile(new File([''], '1'));
+  const f2 = new merchi.MerchiFile();
+  f2.fromFormFile(new File([''], '2'));
+  job.clientFiles = [f1, f2];
+  const fetch = mockFetch(true, {'job': {}}, 200);
+  return job.save().then(() => {
+    const data: any = Array.from(fetch.mock.calls[0][1]['body'].entries());
+    expect(data[1][1]).toEqual('0');
+    expect(data[2][1]).toEqual('1');
+    expect(data[6][1]).toEqual('1');
+    expect(data[10][1]).toEqual('2');
+  });
+});
+
+test('Get quote update job cost', () => {
+  const merchi = new Merchi();
+  const jobWithExistingProduct = new merchi.Job().fromJson(
+    {'quantity': 10, 'cost': 0, product: {'id': 1, 'name': 'test'}});
+  const jobWithNewProduct = new merchi.Job().fromJson(
+    {'quantity': 10, 'cost': 0, product: {'name': 'test'}});
+  mockFetch(true, {'quantity': 10, 'cost': 100}, 200);
+  jobWithExistingProduct.getQuote().then(job => {
+    expect(job.quantity).toEqual(10);
+    expect(job.cost).toEqual(100);
+  });
+  jobWithNewProduct.getQuote().then(job => {
+    expect(job.quantity).toEqual(10);
+    expect(job.cost).toEqual(100);
+  });
+});
+
+test('test deduct job inventory', () => {
+  const merchi = new Merchi();
+  const job = new merchi.Job();
+  const inventory = new merchi.Inventory();
+  inventory.id = 1;
+  job.id = 1;
+  const matchingInventoryOne = new merchi.MatchingInventory();
+  matchingInventoryOne.inventory = inventory;
+  matchingInventoryOne.status = InventoryStatus.CAN_DEDUCT;
+  matchingInventoryOne.deductionDate = null;
+  job.matchingInventories = [matchingInventoryOne];
+  const correct = [['inventories', '[1]']];
+  const fetch = mockFetch(true, {}, 200);
+  job.deduct([matchingInventoryOne]);
+  expect(Array.from(fetch.mock.calls[0][1]['body'].entries())).toEqual(correct);
+
+  job.bulkDeduct();
+  expect(Array.from(fetch.mock.calls[1][1]['body'].entries())).toEqual(correct);
+});
+
+test('test bulk deduct job without inventories will cause error', () => {
+  const merchi = new Merchi();
+  const job = new merchi.Job();
+  expect(job.bulkDeduct).toThrow();
+});