merchi_sdk_ts 0.0.1-a

package/src/entities/variation_field.test.ts

@@ -0,0 +1,76 @@
+import { Merchi } from '../merchi';
+
+test('can make VariationField', () => {
+  const merchi = new Merchi();
+  const variationField = new merchi.VariationField();
+  expect(variationField).toBeTruthy();
+});
+
+test('isSelectable', () => {
+  const merchi = new Merchi();
+  const vf = new merchi.VariationField();
+  expect(vf.isSelectable).toThrow();
+  vf.fieldType = 1;
+  expect(vf.isSelectable()).toBe(false);
+  vf.fieldType = 11;
+  expect(vf.isSelectable()).toBe(true);
+});
+
+test('buildEmptyVariation cost', () => {
+  const merchi = new Merchi();
+  const vf = new merchi.VariationField();
+  expect(vf.buildEmptyVariation).toThrow();
+  vf.defaultValue = 'a';
+  vf.fieldType = 11;
+  expect(vf.buildEmptyVariation).toThrow();
+  vf.variationCost = 2;
+  expect(vf.buildEmptyVariation).toThrow();
+  const o1 = new merchi.VariationFieldsOption();
+  const o2 = new merchi.VariationFieldsOption();
+  o1.default = true;
+  vf.options = [o1, o2];
+  expect(vf.buildEmptyVariation).toThrow();
+  o1.variationCost = 3;
+  expect(vf.buildEmptyVariation().onceOffCost).toEqual(3);
+  vf.fieldType = 1;
+  expect(vf.buildEmptyVariation().onceOffCost).toEqual(2);
+});
+
+test('buildEmptyVariation seller editable options', () => {
+  const merchi = new Merchi();
+  const vf = new merchi.VariationField();
+  expect(vf.buildEmptyVariation).toThrow();
+  vf.defaultValue = 'a';
+  vf.fieldType = 11;
+  vf.sellerProductEditable = true;
+  vf.variationCost = 2;
+  expect(vf.buildEmptyVariation).toThrow();
+  const o1 = new merchi.VariationFieldsOption();
+  const o2 = new merchi.VariationFieldsOption();
+  o1.include = true;
+  o1.id = 1;
+  o1.variationCost = 1;
+  o2.default = true;
+  o2.id = 2;
+  o2.variationCost = 1;
+  vf.options = [o1, o2];
+  expect(vf.buildEmptyVariation().value).toEqual('1');
+});
+
+test('buildEmptyVariation selectable options', () => {
+  const merchi = new Merchi();
+  const vf = new merchi.VariationField();
+  const o1 = new merchi.VariationFieldsOption();
+  const o2 = new merchi.VariationFieldsOption();
+
+  o1.value = 'test 1';
+  o2.value = 'test 2';
+  vf.options = [o1, o2];
+  vf.variationCost = 2;
+  vf.defaultValue = 'a';
+  vf.fieldType = 11;
+
+  const v = vf.buildEmptyVariation();
+  expect(v.selectableOptions![0].value).toEqual('test 1');
+  expect(v.selectableOptions![1].value).toEqual('test 2');
+});

package/src/entities/variation_field.ts

@@ -0,0 +1,169 @@
+import { cloneDeepWith } from 'lodash';
+import { DiscountGroup } from './discount_group';
+import { Entity } from '../entity';
+import { Product } from './product';
+import { Variation } from './variation';
+import { VariationFieldsOption } from './variation_fields_option';
+import { FieldType } from '../constants/field_types';
+
+export class VariationField extends Entity {
+  protected static resourceName = 'variation_fields';
+  protected static singularName = 'variationField';
+  protected static pluralName = 'variationFields';
+
+  @VariationField.property({type: Date})
+  public archived?: Date | null;
+
+  @VariationField.property()
+  public id?: number;
+
+  @VariationField.property()
+  public position?: number;
+
+  @VariationField.property()
+  public required?: boolean;
+
+  @VariationField.property()
+  public independent?: boolean;
+
+  @VariationField.property()
+  public name?: string;
+
+  @VariationField.property({type: String})
+  public placeholder?: string | null;
+
+  @VariationField.property()
+  public defaultValue?: string;
+
+  @VariationField.property()
+  public currency?: string;
+
+  @VariationField.property()
+  public fieldType?: FieldType;
+
+  @VariationField.property()
+  public margin?: number;
+
+  @VariationField.property()
+  public variationCost?: number;
+
+  @VariationField.property({type: 'DiscountGroup'})
+  public variationCostDiscountGroup?: DiscountGroup | null;
+
+  @VariationField.property()
+  public variationUnitCost?: number;
+
+  @VariationField.property({embeddedByDefault: false})
+  public buyUnitCost?: number;
+
+  @VariationField.property({embeddedByDefault: false})
+  public buyCost?: number;
+
+  @VariationField.property({type: 'DiscountGroup'})
+  public variationUnitCostDiscountGroup?: DiscountGroup | null;
+
+  @VariationField.property()
+  public rows?: number;
+
+  @VariationField.property({type: Number})
+  public fieldMin?: number | null;
+
+  @VariationField.property({type: Number})
+  public fieldMax?: number | null;
+
+  @VariationField.property()
+  public allowDecimal?: boolean;
+
+  @VariationField.property()
+  public sellerProductEditable?: boolean;
+
+  @VariationField.property()
+  public multipleSelect?: boolean;
+
+  @VariationField.property()
+  public showFilePreview?: boolean;
+
+  @VariationField.property()
+  public allowFileMultiple?: boolean;
+
+  @VariationField.property()
+  public allowFileJpeg?: boolean;
+
+  @VariationField.property()
+  public allowFileGif?: boolean;
+
+  @VariationField.property()
+  public allowFilePdf?: boolean;
+
+  @VariationField.property()
+  public allowFilePng?: boolean;
+
+  @VariationField.property()
+  public allowFileAi?: boolean;
+
+  @VariationField.property()
+  public product?: Product;
+
+  @VariationField.property({arrayType: 'Variation'})
+  public variations?: Variation[];
+
+  @VariationField.property({arrayType: 'VariationFieldsOption'})
+  public options?: VariationFieldsOption[];
+
+  public isSelectable = () => {
+    if (this.fieldType === undefined) {
+      throw new Error('fieldType is undefined, did you forget to embed it?');
+    }
+    const selectable = new Set([FieldType.SELECT,
+      FieldType.CHECKBOX,
+      FieldType.RADIO,
+      FieldType.IMAGE_SELECT,
+      FieldType.COLOUR_SELECT]);
+    return selectable.has(this.fieldType);
+  };
+
+  public buildEmptyVariation = () => {
+    if (this.defaultValue === undefined) {
+      throw new Error('defaultValue is undefined, did you forget to embed it?');
+    }
+    if (this.variationCost === undefined) {
+      const err = 'variationCost is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    if (this.options === undefined) {
+      throw new Error('options is undefined, did you forget to embed it?');
+    }
+    const result = new this.merchi.Variation(this.merchi);
+    result.selectableOptions = [];
+    if (this.isSelectable()) {
+      let onceOffCost = 0;
+      const value = [];
+      for (const option of this.options) {
+        if ((this.sellerProductEditable && option.include) ||
+          (!this.sellerProductEditable && option.default)) {
+          if (option.variationCost === undefined) {
+            throw new Error('option.variationCost is undefined, did you ' +
+                            'forget to embed it?');
+          }
+          value.push(option.id);
+          onceOffCost += option.variationCost;
+        }
+        result.selectableOptions.push(option.buildVariationOption());
+      }
+      result.value = value.join();
+      result.onceOffCost = onceOffCost;
+    } else {
+      result.value = this.defaultValue;
+      result.onceOffCost = this.variationCost;
+    }
+    result.unitCostTotal = 0;
+    result.cost = result.onceOffCost;
+    function customiser(value: any, index: any) {
+      if (index === 'merchi') {
+        return value;
+      }
+    }
+    result.variationField = cloneDeepWith(this, customiser);
+    return result;
+  };
+}

package/src/entities/variation_fields_option.test.ts

@@ -0,0 +1,46 @@
+import { Merchi } from '../merchi';
+
+test('can make VariationFieldsOption', () => {
+  const merchi = new Merchi();
+  const variationFieldsOption = new merchi.VariationFieldsOption();
+  expect(variationFieldsOption).toBeTruthy();
+});
+
+test('totalCost', () => {
+  const merchi = new Merchi();
+  const vfo = new merchi.VariationFieldsOption();
+  expect(() => vfo.totalCost(33)).toThrow();
+  vfo.variationCost = 12.4;
+  expect(() => vfo.totalCost(33)).toThrow();
+  vfo.variationUnitCost = 9.98;
+  expect(vfo.totalCost(33)).toEqual(341.74);
+});
+
+test('buildVariationOption', () => {
+  const merchi = new Merchi();
+  const option = new merchi.VariationFieldsOption();
+  const file = new merchi.MerchiFile();
+  file.id = 1;
+  option.id = 1;
+  option.value = 'aa';
+  option.position = 3;
+  option.default = true;
+  option.colour = '#AAAAAA';
+  option.linkedFile = file;
+  option.currency = 'AUD';
+  option.variationCost = 100;
+  option.variationUnitCost = 1;
+  const variationOption = option.buildVariationOption();
+  expect(variationOption.optionId).toEqual(option.id);
+  expect(variationOption.value).toEqual(option.value);
+  expect(variationOption.position).toEqual(option.position);
+  expect(variationOption.default).toEqual(option.default);
+  expect(variationOption.colour).toEqual(option.colour);
+  expect(variationOption.linkedFile!.id).toEqual(1);
+  expect(variationOption.quantity).toEqual(0);
+  expect(variationOption.currency).toEqual(option.currency);
+  expect(variationOption.onceOffCost).toEqual(option.variationCost);
+  expect(variationOption.unitCost).toEqual(option.variationUnitCost);
+  expect(variationOption.unitCostTotal).toEqual(0);
+  expect(variationOption.totalCost).toEqual(option.variationCost);
+});

package/src/entities/variation_fields_option.ts

@@ -0,0 +1,95 @@
+import { DiscountGroup } from './discount_group';
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+import { InventoryUnitVariation } from './inventory_unit_variation';
+import { Variation } from './variation';
+import { VariationField } from './variation_field';
+
+export class VariationFieldsOption extends Entity {
+  protected static resourceName = 'variation_fields_options';
+  protected static singularName = 'variationFieldsOption';
+  protected static pluralName = 'variationFieldsOptions';
+
+  @VariationFieldsOption.property({type: Date})
+  public archived?: Date | null;
+
+  @VariationFieldsOption.property()
+  public id?: number;
+
+  @VariationFieldsOption.property({type: String})
+  public value?: string | null;
+
+  @VariationFieldsOption.property({type: String})
+  public colour?: string | null;
+
+  @VariationFieldsOption.property()
+  public currency?: string;
+
+  @VariationFieldsOption.property()
+  public default?: boolean;
+
+  @VariationFieldsOption.property()
+  public include?: boolean;
+
+  @VariationFieldsOption.property()
+  public position?: number;
+
+  @VariationFieldsOption.property()
+  public variationCost?: number;
+
+  @VariationFieldsOption.property({type: 'DiscountGroup'})
+  public variationCostDiscountGroup?: DiscountGroup | null;
+
+  @VariationFieldsOption.property()
+  public variationUnitCost?: number;
+
+  @VariationFieldsOption.property({embeddedByDefault: false})
+  public buyUnitCost?: number;
+
+  @VariationFieldsOption.property({embeddedByDefault: false})
+  public buyCost?: number;
+
+  @VariationFieldsOption.property({type: 'DiscountGroup'})
+  public variationUnitCostDiscountGroup?: DiscountGroup | null;
+
+  @VariationFieldsOption.property({type: VariationField})
+  public variationField?: VariationField | null;
+
+  @VariationFieldsOption.property({type: MerchiFile})
+  public linkedFile?: MerchiFile | null;
+
+  @VariationFieldsOption.property({arrayType: 'Variation'})
+  public selectedByVariations?: Variation[];
+
+  @VariationFieldsOption.property({arrayType: 'InventoryUnitVariation'})
+  public inventoryUnitVariations?: InventoryUnitVariation[];
+
+  public totalCost = (quantity: number) => {
+    if (this.variationCost === undefined) {
+      throw new Error('variationCost is unknown');
+    }
+    if (this.variationUnitCost === undefined) {
+      throw new Error('variationUnitCost is unknown');
+    }
+    return this.variationCost + this.variationUnitCost * quantity;
+  };
+
+  public buildVariationOption = () => {
+    const result = new this.merchi.VariationOption(this.merchi);
+    result.optionId = this.id;
+    result.include = this.include;
+    result.value = this.value;
+    result.position = this.position;
+    result.default = this.default;
+    result.colour = this.colour;
+    result.linkedFile = this.linkedFile;
+    result.quantity = 0;
+
+    result.currency = this.currency;
+    result.unitCost = this.variationUnitCost;
+    result.unitCostTotal = 0;
+    result.onceOffCost = this.variationCost;
+    result.totalCost = this.variationCost;
+    return result;
+  };
+}

package/src/entities/variation_option.test.ts

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

package/src/entities/variation_option.ts

@@ -0,0 +1,52 @@
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+
+export class VariationOption extends Entity {
+  protected static singularName = 'variationOption';
+  protected static pluralName = 'variationOptions';
+
+  @VariationOption.property()
+  public optionId?: number;
+
+  @VariationOption.property({type: String})
+  public value?: string | null;
+
+  @VariationOption.property({type: String})
+  public colour?: string | null;
+
+  @VariationOption.property()
+  public position?: number;
+
+  @VariationOption.property()
+  public available?: boolean;
+
+  @VariationOption.property()
+  public default?: boolean;
+
+  @VariationOption.property()
+  public include?: boolean;
+
+  @VariationOption.property({type: MerchiFile})
+  public linkedFile?: MerchiFile | null;
+
+  @VariationOption.property()
+  public fieldName?: string;
+
+  @VariationOption.property()
+  public quantity?: number;
+
+  @VariationOption.property()
+  public currency?: string;
+
+  @VariationOption.property()
+  public onceOffCost?: number;
+
+  @VariationOption.property()
+  public unitCost?: number;
+
+  @VariationOption.property()
+  public unitCostTotal?: number;
+
+  @VariationOption.property()
+  public totalCost?: number;
+}

package/src/entities/variations_group.test.ts

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

package/src/entities/variations_group.ts

@@ -0,0 +1,41 @@
+import { CartItem } from './cart_item';
+import { Entity } from '../entity';
+import { Job } from './job';
+import { Variation } from './variation';
+import { MatchingInventory } from './matching_inventory';
+
+export class VariationsGroup extends Entity {
+  protected static resourceName = 'variations_groups';
+  protected static singularName = 'variationsGroup';
+  protected static pluralName = 'variationsGroups';
+
+  @VariationsGroup.property({type: Date})
+  public archived?: Date | null;
+
+  @VariationsGroup.property()
+  public id?: number;
+
+  @VariationsGroup.property()
+  public quantity?: number;
+
+  @VariationsGroup.property({type: Number})
+  public groupCost?: number | null;
+
+  @VariationsGroup.property({type: Job})
+  public job?: Job | null;
+
+  @VariationsGroup.property({type: CartItem})
+  public cartItem?: CartItem | null;
+
+  @VariationsGroup.property({type: MatchingInventory})
+  public matchingInventory?: MatchingInventory | null;
+
+  @VariationsGroup.property({arrayType: 'Variation'})
+  public variations?: Variation[];
+
+  @VariationsGroup.property({embeddedByDefault: false})
+  public inventoryCount?: number;
+
+  @VariationsGroup.property({embeddedByDefault: false})
+  public inventorySufficient?: boolean;
+}