@merchi/sdk 1.40.2

package/src/entities/cart.ts

@@ -0,0 +1,102 @@
+import { Address } from './address.js';
+import { CartItem } from './cart_item.js';
+import { CartShipmentGroup } from './cart_shipment_group.js';
+import { Company } from './company.js';
+import { Domain } from './domain.js';
+import { Entity } from '../entity.js';
+import { Invoice } from './invoice.js';
+import { User } from './user.js';
+import { Item } from './item.js';
+
+export class Cart extends Entity {
+  protected static resourceName = 'carts';
+  protected static singularName = 'cart';
+  protected static pluralName = 'carts';
+
+  @Cart.property({type: Date})
+  public archived?: Date | null;
+
+  @Cart.property()
+  public id?: number;
+
+  @Cart.property()
+  public stripePaymentEngine?: string;
+
+  @Cart.property()
+  public creationDate?: Date;
+
+  @Cart.property()
+  public updated?: Date;
+
+  @Cart.property({type: Date})
+  public ip?: string | null;
+
+  @Cart.property({type: String})
+  public token?: string | null;
+
+  @Cart.property({type: String})
+  public receiverNotes?: string | null;
+
+  @Cart.property()
+  public currency?: string;
+
+  @Cart.property()
+  public cartItemsSubtotalCost?: number;
+
+  @Cart.property()
+  public cartItemsTaxAmount?: number;
+
+  @Cart.property()
+  public cartItemsTotalCost?: number;
+
+  @Cart.property()
+  public shipmentTotalCost?: number;
+
+  @Cart.property()
+  public subtotalCost?: number;
+
+  @Cart.property()
+  public taxAmount?: number;
+
+  @Cart.property()
+  public totalCost?: number;
+
+  @Cart.property()
+  public sendWhatsapp?: boolean;
+
+  @Cart.property({type: 'User'})
+  public client?: User | null;
+
+  @Cart.property({type: Company})
+  public clientCompany?: Company | null;
+
+  @Cart.property()
+  public domain?: Domain;
+
+  @Cart.property({type: 'Invoice'})
+  public invoice?: Invoice | null;
+
+  @Cart.property({type: Address})
+  public receiverAddress?: Address | null;
+
+  @Cart.property({arrayType: 'Item'})
+  public discountItems?: Item[];
+
+  @Cart.property({arrayType: 'CartItem'})
+  public cartItems?: CartItem[];
+
+  @Cart.property({arrayType: 'CartShipmentGroup'})
+  public shipmentGroups?: CartShipmentGroup[];
+
+  public requiresShipment = () => {
+    if (this.cartItems === undefined) {
+      throw 'cartItems is undefined, did you forget to embed it?';
+    }
+    for (const cartItem of this.cartItems) {
+      if (cartItem.requiresShipment()) {
+        return true;
+      }
+    }
+    return false;
+  };
+}

package/src/entities/cart_item.test.ts

@@ -0,0 +1,33 @@
+import { Merchi } from '../merchi.js';
+import { setup, mockFetch } from '../test_util.js';
+
+setup();
+
+test('can make CartItem', () => {
+  const merchi = new Merchi();
+  const cartItem = new merchi.CartItem();
+  expect(cartItem).toBeTruthy();
+});
+
+test('requiresShipment', () => {
+  const merchi = new Merchi();
+  const cartItem = new merchi.CartItem();
+  expect(cartItem.requiresShipment).toThrow(); 
+  cartItem.product = new merchi.Product();
+  expect(cartItem.requiresShipment).toThrow(); 
+  cartItem.product.needsShipping = false;
+  expect(cartItem.requiresShipment()).toBe(false);
+  cartItem.product.needsShipping = true;
+  expect(cartItem.requiresShipment()).toBe(true);
+});
+
+test('Get quote update job cost', () => {
+  const merchi = new Merchi();
+  const cartItem = new merchi.CartItem().fromJson(
+    {'quantity': 10, 'totalCost': 0});
+  mockFetch(true, {'quantity': 10, 'totalCost': 100}, 200);
+  cartItem.calculate().then(item => {
+    expect(item.quantity).toEqual(10);
+    expect(item.totalCost).toEqual(100);
+  });
+});

package/src/entities/cart_item.ts

@@ -0,0 +1,85 @@
+import { Cart } from './cart.js';
+import { CountryTax } from './country_tax.js';
+import { Entity } from '../entity.js';
+import { Product } from './product.js';
+import { RequestOptions } from '../request.js';
+import { Variation } from './variation.js';
+import { VariationsGroup } from './variations_group.js';
+import { DomainTag } from './domain_tag.js';
+import { Draft } from './draft.js';
+
+export class CartItem extends Entity {
+  protected static resourceName = 'cart_items';
+  protected static singularName = 'cartItem';
+  protected static pluralName = 'cartItems';
+
+  @CartItem.property({type: Date})
+  public archived?: Date | null;
+
+  @CartItem.property()
+  public id?: number;
+
+  @CartItem.property()
+  public quantity?: number;
+
+  @CartItem.property({type: String})
+  public notes?: string | null;
+
+  @CartItem.property()
+  public creationDate?: Date;
+
+  @CartItem.property()
+  public currency?: string;
+
+  @CartItem.property()
+  public subtotalCost?: number;
+
+  @CartItem.property()
+  public taxAmount?: number;
+
+  @CartItem.property()
+  public totalCost?: number;
+
+  @CartItem.property()
+  public product?: Product;
+
+  @CartItem.property()
+  public cart?: Cart;
+
+  @CartItem.property({embeddedByDefault: false})
+  public taxType?: CountryTax;
+
+  @CartItem.property({arrayType: 'VariationsGroup'})
+  public variationsGroups?: VariationsGroup[];
+
+  @CartItem.property({arrayType: 'Variation'})
+  public variations?: Variation[];
+
+  @CartItem.property({arrayType: 'DomainTag'})
+  public tags?: DomainTag[];
+
+  @CartItem.property({arrayType: 'Draft'})
+  public ownDrafts?: Draft[];
+
+  public requiresShipment = () => {
+    if (this.product === undefined) {
+      throw 'product is undefined, did you forget to embed it?';
+    }
+    if (this.product.needsShipping === undefined) {
+      throw 'needsShipping is undefined, did you forget to embed it?';
+    }
+    return this.product.needsShipping;
+  };
+
+  public calculate = () => {
+    const resource = '/cart-item-cost-estimate/';
+    const data = this.toFormData({excludeOld: false});
+    const fetchOptions: RequestOptions = {method: 'POST', body: data};
+    fetchOptions.query = [];
+    fetchOptions.query.push(['skip_rights', 'y']);
+
+    return this.merchi.authenticatedFetch(resource, fetchOptions).
+      then((data: any) => { this.fromJson(data, {makeDirty: true});
+        return this;});
+  };
+}

package/src/entities/cart_shipment_group.ts

@@ -0,0 +1,21 @@
+import { CartItem } from './cart_item.js';
+import { CartShipmentQuote } from './cart_shipment_quote.js';
+import { Entity } from '../entity.js';
+
+export class CartShipmentGroup extends Entity {
+  protected static resourceName = 'cart_shipment_groups';
+  protected static singularName = 'cartShipmentGroup';
+  protected static pluralName = 'cartShipmentGroups';
+
+  @CartShipmentGroup.property()
+  public id?: number;
+
+  @CartShipmentGroup.property({arrayType: 'CartItem'})
+  public cartItems?: CartItem[];
+
+  @CartShipmentGroup.property({arrayType: 'CartShipmentQuote'})
+  public quotes?: CartShipmentQuote[];
+
+  @CartShipmentGroup.property({type: 'CartShipmentQuote'})
+  public selectedQuote?: CartShipmentQuote;
+}

package/src/entities/cart_shipment_quote.ts

@@ -0,0 +1,33 @@
+import { ShipmentMethod } from './shipment_method.js';
+import { Entity } from '../entity.js';
+import { ShipmentService } from '../constants/shipment_services.js';
+
+export class CartShipmentQuote extends Entity {
+  protected static resourceName = 'cart_shipment_quotes';
+  protected static singularName = 'cartShipmentQuote';
+  protected static pluralName = 'cartShipmentQuotes';
+
+  @CartShipmentQuote.property()
+  public id?: number;
+
+  @CartShipmentQuote.property()
+  public name?: string;
+
+  @CartShipmentQuote.property()
+  public subtotalCost?: number;
+
+  @CartShipmentQuote.property()
+  public taxAmount?: number;
+
+  @CartShipmentQuote.property()
+  public totalCost?: number;
+
+  @CartShipmentQuote.property({type: ShipmentService})
+  public shipmentService?: ShipmentService | null;
+
+  @CartShipmentQuote.property()
+  public shipmentServiceQuote?: string;
+
+  @CartShipmentQuote.property({type: 'ShipmentMethod'})
+  public shipmentMethod?: ShipmentMethod;
+}

package/src/entities/category.test.ts

@@ -0,0 +1,57 @@
+import { Merchi } from '../merchi.js';
+
+test('can make category', () => {
+  const merchi = new Merchi();
+  const category = new merchi.Category();
+  expect(category).toBeTruthy();
+});
+
+test('can get and set id', () => {
+  const merchi = new Merchi();
+  const category = new merchi.Category();
+  category.id = 2;
+  expect(category.id).toBe(2);
+});
+
+test('can get and set name', () => {
+  const merchi = new Merchi();
+  const category = new merchi.Category();
+  category.name = 'example';
+  expect(category.name).toBe('example');
+});
+
+test('can get and set product', () => {
+  const merchi = new Merchi();
+  const c1 = new merchi.Category();
+  const c2 = new merchi.Category();
+  const p1 = new merchi.Product();
+  const p2 = new merchi.Product();
+  const cs = [c1, c2];
+  const ps = [p1, p2];
+  c1.products = ps;
+  expect(c1.products).toBe(ps);
+  expect(c2.products).toBe(undefined);
+  expect(p1.categories).toBe(undefined);
+  p1.categories = cs;
+  expect(p1.categories).toBe(cs);
+  p1.categories = undefined;
+  expect(p1.categories).toBe(undefined);
+});
+
+test('independence of entities', () => {
+  const merchi = new Merchi();
+  const c1 = new merchi.Category();
+  const c2 = new merchi.Category();
+  const p = new merchi.Product();
+  const name = 'vMjssEhwpHtMT';
+  const products = [p];
+  c1.name = name;
+  c1.products = products;
+  expect(c1.name).toBe(name);
+  expect(c1.products).toBe(products);
+  expect(c1.isDirty).toBe(true);
+  // c2 is a different object, and therefore totally unnaffected
+  expect(c2.name).toBe(undefined);
+  expect(c2.products).toBe(undefined);
+  expect(c2.isDirty).toBe(false);
+});

package/src/entities/category.ts

@@ -0,0 +1,59 @@
+import { Domain } from './domain.js';
+import { Entity } from '../entity.js';
+import { MerchiFile } from './file.js';
+import { Product } from './product.js';
+import { User } from './user.js';
+
+export class Category extends Entity {
+  protected static resourceName = 'categories';
+  protected static singularName = 'category';
+  protected static pluralName = 'categories';
+
+  @Category.property({type: Date})
+  public archived?: Date | null;
+
+  @Category.property()
+  public id?: number;
+
+  @Category.property()
+  public name?: string;
+
+  @Category.property()
+  public position?: number;
+
+  @Category.property({type: String})
+  public description?: string | null;
+
+  @Category.property({type: String})
+  public descriptionShort?: string | null;
+
+  @Category.property()
+  public showDashboard?: boolean;
+
+  @Category.property()
+  public showPublic?: boolean;
+
+  @Category.property()
+  public showPublicSupplierResell?: boolean;
+
+  @Category.property()
+  public descendant?: number;
+
+  @Category.property()
+  public domain?: Domain;
+
+  @Category.property({arrayType: 'Product'})
+  public products?: Product[];
+
+  @Category.property({arrayType: 'User'})
+  public users?: User[];
+
+  @Category.property({arrayType: 'Category'})
+  public subcategories?: Category[];
+
+  @Category.property({type: 'Category'})
+  public parent?: Category;
+
+  @Category.property({type: 'MerchiFile'})
+  public image?: MerchiFile | null;
+}

package/src/entities/company.test.ts

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