merchi_sdk_js 0.0.1

package/src/variation.js

@@ -0,0 +1,257 @@
+import { generateUUID } from './uuid.js';
+import { fieldTypes } from './field_types.js';
+import { addPropertyTo } from './model.js';
+import { isUndefined } from './helpers.js';
+import { VariationOption } from './variation_option.js';
+import { VariationField } from './variation_field.js';
+import { MerchiFile } from './merchi_file.js';
+
+export function Variation() {
+    this.resource = '/variation';
+    this.json = 'variation';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'value');
+    addPropertyTo(this, 'quantity');
+    addPropertyTo(this, 'cost');
+    addPropertyTo(this, 'onceOffCost');
+    addPropertyTo(this, 'unitCost');
+    addPropertyTo(this, 'unitCostTotal');
+    addPropertyTo(this, 'selectableOptions', VariationOption);
+    addPropertyTo(this, 'selectedOptions', VariationOption);
+    addPropertyTo(this, 'variationField', VariationField);
+    addPropertyTo(this, 'variationFiles', MerchiFile);
+
+    this.unitCostAndOnceOffCost = function () {
+        var unitCost = this.unitCost() ? this.unitCost() : 0,
+            onceOffCost = this.onceOffCost() ? this.onceOffCost() : 0;
+        return unitCost + onceOffCost;
+    }
+
+    this.unitCostTotalAndOnceOffCost = function () {
+        var unitCostTotal = this.unitCostTotal() ? this.unitCostTotal() : 0,
+            onceOffCost = this.onceOffCost() ? this.onceOffCost() : 0;
+        return unitCostTotal + onceOffCost;
+    }
+
+    this.isTextField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isTextType();
+    };
+    this.isNumberField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isNumberType();
+    };
+
+    this.isSelectField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isSelectType();
+    };
+
+    this.isCheckBoxField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isCheckboxType();
+    };
+
+    this.isRadioField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isRadioType();
+    };
+
+    this.isColourSelectField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isColourSelectType();
+    };
+
+    this.isImageSelectField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isImageSelectType();
+    };
+
+    this.isCheckboxOrRadioField = function () {
+        return this.isRadioField() || this.isCheckBoxField();
+    };
+
+    this.isSelectableField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isSelectable();
+    };
+
+    this.canHaveMultipleSelected = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isDefaultMultiSelect();
+    };
+
+    this.isTextAreaField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isTextAreaType();
+    };
+
+    this.isInstructionsField = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isInstructionsType();
+    };
+
+    this.isFileUpload = function () {
+        var field = this.variationField();
+        return Boolean(field) && field.isFileInput();
+    };
+
+     this.valueArray = function (updateValueArray) {
+        var valuesArray = [], i;
+        if (!isUndefined(updateValueArray)) {
+            this.value(updateValueArray.join(','));
+            return updateValueArray;
+         }
+        if (this.value() === "") {
+            return [];
+        }
+        valuesArray = String(this.value()).split(',');
+        for (i = 0; i < valuesArray.length; i++) {
+            valuesArray[i] = parseInt(valuesArray[i], 10);
+        }
+        return valuesArray;
+    };
+
+    this.textValue = function () {
+        var field = this.variationField(),
+            text = "", i;
+        if (field) {
+            if (this.isTextField() || this.isNumberField() ||
+                this.isTextAreaField()) {
+                return this.value();
+            }
+            if (this.isSelectableField() && this.selectedOptions()) {
+                for (i = 0; i < this.selectedOptions().length; i++) {
+                    text += this.selectedOptions()[i].value() + " ";
+                }
+                return text;
+            }
+        }
+        return null;
+    };
+    this.optionIsSelected = function(id) {
+        const selectedIds = this.valueArray();
+        return -1 < selectedIds.findIndex(
+            (_id) => String(_id) === String(id));
+    };
+
+    this.selectedSelectableOptions = function () {
+        var self = this,
+            options = this.selectableOptions() ?
+              this.selectableOptions() : [];
+        return options.filter((o) =>
+            self.optionIsSelected(o.optionId()));
+    };
+
+    this.selectedFieldOptions = function () {
+        var field = this.variationField(),
+            options = field.options() ? field.options() : [],
+            valueArray = this.valueArray(),
+            optionsArray = [], selectedId, option, i, z;
+        for (i = 0; i < valueArray.length; i++) {
+            selectedId = valueArray[i];
+            for (z = 0; z < options.length; z++) {
+                option = options[z];
+                if (selectedId === option.id()) {
+                    optionsArray.push(option);
+                }
+            }
+        }
+        return optionsArray;
+    };
+
+    this.findOptionValueIndex = function (optionId) {
+        return this.valueArray().indexOf(parseInt(optionId, 10));
+    };
+
+    this.optionIsChecked = function (optionId) {
+        return this.findOptionValueIndex(optionId) > -1;
+    };
+
+    this.addOptionToValueArray = function (optionId) {
+        var newValueArray = this.valueArray();
+        if (!this.optionIsChecked(optionId)) {
+            newValueArray.push(optionId);
+            this.valueArray(newValueArray);
+        }
+    };
+
+    this.removeOptionFromValueArray = function (optionId) {
+        var index = this.findOptionValueIndex(optionId),
+            newValueArray = this.valueArray();
+        newValueArray.splice(index, 1);
+        this.valueArray(newValueArray);
+    };
+
+    this.fieldName = function () {
+        return this.variationField().name();
+    };
+
+    this.fieldType = function () {
+        return this.variationField().fieldType();
+    };
+
+    this.hasOptions = function () {
+        return Boolean(this.selectedOptions());
+    };
+    this.hasMultipleOptions = function () {
+        return parseInt(this.fieldType(), 10) ===
+            fieldTypes.get("CHECKBOX");
+    };
+
+    this.isFileUpload = function () {
+        return parseInt(this.fieldType(), 10) ===
+            fieldTypes.get("FILE_UPLOAD");
+    };
+
+    this.isColourPicker = function () {
+        return parseInt(this.fieldType(), 10) ===
+            fieldTypes.get("COLOUR_PICKER");
+    };
+
+    this.clone = function () {
+        var cloneVariation = new Variation();
+        cloneVariation.value(this.value());
+        cloneVariation.cost(this.cost());
+        cloneVariation.variationField(this.variationField());
+        cloneVariation.variationFiles(this.variationFiles());
+        return cloneVariation;
+    };
+
+    this.valueIdArray = function () {
+        var value = this.value();
+        return value ? value.split(',') : [];
+    }
+    this.concatinatedSelectedOptionValues = function () {
+        var optionIds = this.valueIdArray(),
+            optionIdsLength = optionIds.length - 1,
+            field = this.variationField(),
+            value = '',
+            option,
+            i;
+        for (i = 0; i < optionIds.length; i++) {
+            option = field.findOptionById(optionIds[i]);
+            value += option.value();
+            if (optionIdsLength > i) {
+                value += ', ';
+            }
+        }
+        return value;
+    }
+
+    this.valueString = function () {
+        var field = this.variationField();
+        if (field.isSelectable()) {
+            return this.concatinatedSelectedOptionValues();
+        } else if (this.isFileUpload() && this.variationFiles()) {
+            if (this.variationFiles().length > 1) {
+                return 'uploaded files';
+            }
+            return 'uploaded file';
+        }
+        return this.value();
+    };
+
+}

package/src/variation_field.js

@@ -0,0 +1,261 @@
+import { generateUUID } from './uuid.js';
+import { fieldTypes } from './field_types.js';
+import { addPropertyTo } from './model.js';
+import { isUndefinedOrNull, clone } from './helpers.js';
+import { DiscountGroup } from './discount_group.js';
+import { VariationFieldsOption } from './variation_fields_option.js';
+import { Variation } from './variation.js';
+import { VariationOption } from './variation_option.js';
+
+export function VariationField() {
+    this.resource = '/variationFields';
+    this.json = 'variationField';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'fieldType');
+    addPropertyTo(this, 'name');
+    addPropertyTo(this, 'position');
+    addPropertyTo(this, 'placeholder');
+    addPropertyTo(this, 'defaultValue');
+    addPropertyTo(this, 'required');
+    addPropertyTo(this, 'independent');
+    addPropertyTo(this, 'variationCost');
+    addPropertyTo(this, 'variationCostDiscountGroup', DiscountGroup);
+    addPropertyTo(this, 'variationUnitCost');
+    addPropertyTo(this, 'variationUnitCostDiscountGroup', DiscountGroup);
+    addPropertyTo(this, 'options', VariationFieldsOption);
+    addPropertyTo(this, 'defaultOptions', VariationFieldsOption);
+    addPropertyTo(this, 'multipleSelect');
+    addPropertyTo(this, 'rows');
+    addPropertyTo(this, 'fieldMin');
+    addPropertyTo(this, 'fieldMax');
+    addPropertyTo(this, 'showFilePreview');
+    addPropertyTo(this, 'allowDecimal');
+    addPropertyTo(this, 'allowFileMultiple');
+    addPropertyTo(this, 'allowFileJpeg');
+    addPropertyTo(this, 'allowFileGif');
+    addPropertyTo(this, 'allowFilePdf');
+    addPropertyTo(this, 'allowFilePng');
+    addPropertyTo(this, 'allowFileAi');
+    addPropertyTo(this, 'sellerProductEditable');
+
+    this.isType = function (typeString) {
+        return parseInt(this.fieldType(), 10) ===
+            fieldTypes.get(typeString);
+    };
+
+    this.isTextType = function () {
+        return this.isType('TEXT_INPUT');
+    };
+
+    this.isNumberType = function () {
+       return this.isType('NUMBER_INPUT');
+    };
+
+    this.isSelectType = function () {
+        return this.isType('SELECT');
+    };
+
+    this.isDefaultMultiSelect = function () {
+        return this.isType('CHECKBOX') || this.isType('IMAGE_SELECT') &&
+            this.multipleSelect();
+    };
+
+    this.isCheckboxType = function () {
+        return this.isType('CHECKBOX');
+    };
+
+    this.isRadioType = function () {
+        return this.isType('RADIO');
+    };
+    this.hasOptions = function () {
+        return Boolean(this.options());
+    };
+
+    this.isCheckboxOrRadio = function () {
+        return this.isCheckboxType() || this.isRadioType();
+    };
+
+    this.isTextAreaType = function () {
+       return this.isType('TEXT_AREA');
+    };
+
+    this.isInstructionsType = function () {
+        return this.isType('FIELD_INSTRUCTIONS');
+     };
+
+    this.isFileInput = function () {
+        return this.isType('FILE_UPLOAD');
+    };
+
+    this.isColourPickerType = function () {
+        return this.isType('COLOUR_PICKER');
+    };
+
+    this.isColourSelectType = function () {
+        return this.isType('COLOUR_SELECT');
+    };
+
+    this.isImageSelectType = function () {
+        return this.isType('IMAGE_SELECT');
+    };
+   this.isSelectable = function () {
+        return this.isSelectType() || this.isCheckboxOrRadio() ||
+            this.isImageSelectType() || this.isColourSelectType();
+    };
+
+    this.canMultiSelect = function () {
+        return this.isImageSelectType() || this.isColourSelectType();
+    }
+
+    this.fieldInputTypeAttributeValue = function () {
+        var inputType = this.fieldType(),
+            inputTypeString = null;
+        if (inputType === fieldTypes.get("TEXT_INPUT")) {
+            inputTypeString = 'text';
+         } else if (inputType === fieldTypes.get('FILE_UPLOAD')) {
+            inputTypeString = 'file';
+        } else if (inputType === fieldTypes.get('NUMBER_INPUT')) {
+            inputTypeString = 'number';
+        } else if (inputType === fieldTypes.get('RADIO')) {
+            inputTypeString = 'radio';
+        } else if (inputType === fieldTypes.get('IMAGE_SELECT')) {
+            if (this.multipleSelect()) {
+                inputTypeString = 'checkbox';
+            } else {
+                inputTypeString = 'radio';
+            }
+        } else if (inputType === fieldTypes.get('CHECKBOX')) {
+            inputTypeString = 'checkbox';
+        } else if (inputType === fieldTypes.get('COLOUR_PICKER')) {
+            inputTypeString = 'color';
+        }
+        return inputTypeString;
+    };
+
+    this.hasMultipleDefaults = function () {
+        return this.optionsDefaults().length > 1;
+    };
+
+    this.setSingleOptionDefault = function (index) {
+        var i, options = this.options();
+        for (i = 0; i < options.length; i++) {
+            options[i].default(false);
+        }
+        options[index].default(true);
+    }
+
+    this.optionsDefaults = function () {
+        var i, defaultsArray = [],
+            options = this.options();
+        for (i = 0; i < options.length; i++) {
+            if (options[i].default()) {
+                defaultsArray.push(options[i]);
+            }
+        }
+         return defaultsArray;
+    };
+
+    this.findOptionById = function (id) {
+        var i = 0, options;
+        options = this.options();
+        for (i = 0; i < options.length; i++) {
+            if (parseInt(options[i].id(), 10) === parseInt(id, 10)) {
+                return options[i];
+            }
+        }
+      return null;
+    };
+
+
+    this.allowFileJpegString = function () {
+        return Boolean(this.allowFileJpeg()) ? ".jpeg, .jpg" : "";
+    };
+
+    this.allowFileGifString = function () {
+        return Boolean(this.allowFileGif()) ? ".gif" : "";
+    };
+
+    this.allowFilePdfString = function () {
+        return Boolean(this.allowFilePdf()) ? ".pdf" : "";
+    };
+
+    this.allowFilePngString = function () {
+        return Boolean(this.allowFilePng()) ? ".png" : "";
+    };
+
+    this.allowFileAiString = function () {
+        return Boolean(this.allowFileAi()) ? ".ai" : "";
+    };
+
+    this.allowedFileTypesString = function () {
+        function appendType(fileTypeString) {
+            if (fileTypeString !== "") {
+                return fileTypeString + ", ";
+            }
+            return "";
+        }
+        return appendType(this.allowFileJpegString()) +
+            appendType(this.allowFileGifString()) +
+            appendType(this.allowFilePdfString()) +
+            appendType(this.allowFilePngString()) +
+            appendType(this.allowFileAiString());
+    };
+   this.allowFileMultipleString = function () {
+        if (this.allowFileMultiple()) {
+            return "multiple";
+        }
+        return "";
+    };
+   this.buildEmptyVariation = function () {
+        var variationBuilt = new Variation(),
+            value, options, i,
+            onceOffCost = 0,
+            selectableOptions = [],
+            sellerProductEditable = this.sellerProductEditable();
+        if (this.isSelectable()) {
+            options = this.options();
+            value = [];
+            for (i = 0; i < options.length; i++) {
+                const selectableOption = new VariationOption();
+                selectableOption.copyFieldOption(options[i]);
+                selectableOptions.push(selectableOption);
+                if ((!sellerProductEditable && options[i].default()) ||
+                    (sellerProductEditable && options[i].include())) {
+                    value.push(options[i].id());
+                    onceOffCost += options[i].variationCost();
+                }
+            }
+            variationBuilt.value(value.join());
+            variationBuilt.onceOffCost(onceOffCost);
+        } else {
+            variationBuilt.value(this.defaultValue());
+            variationBuilt.unitCost(this.variationUnitCost());
+            variationBuilt.onceOffCost(this.variationCost());
+        }
+        variationBuilt.unitCostTotal('0');
+        variationBuilt.cost(variationBuilt.onceOffCost());
+        variationBuilt.variationField(clone(this));
+        variationBuilt.selectableOptions(selectableOptions);
+        return variationBuilt;
+    };
+
+    this.optionsHaveCost = function () {
+        var i, options, o;
+        function hasCost(cost) {
+            return !isUndefinedOrNull(cost);
+        }
+        if (this.isSelectable()) {
+            options = this.options();
+            for (i = 0; i < options.length; i++) {
+                o = options[i];
+                if (hasCost(o.variationCost()) ||
+                    hasCost(o.variationUnitCost())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

package/src/variation_fields_option.js

@@ -0,0 +1,41 @@
+import { generateUUID } from './uuid.js';
+import { addPropertyTo } from './model.js';
+import { DiscountGroup } from './discount_group.js';
+import { MerchiFile } from './merchi_file.js';
+import { VariationField } from './variation_field.js';
+
+export function VariationFieldsOption() {
+    this.resource = '/variationFieldOptions';
+    this.json = 'variationFieldOption';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'value');
+    addPropertyTo(this, 'position');
+    addPropertyTo(this, 'default');
+    addPropertyTo(this, 'include');
+    addPropertyTo(this, 'colour');
+    addPropertyTo(this, 'variationCost');
+    addPropertyTo(this, 'variationCostDiscountGroup', DiscountGroup);
+    addPropertyTo(this, 'variationUnitCost');
+    addPropertyTo(this, 'variationUnitCostDiscountGroup', DiscountGroup);
+    addPropertyTo(this, 'linkedFile', MerchiFile);
+    addPropertyTo(this, 'variationField', VariationField)
+
+    this.totalCost = function (quantity) {
+        var total = this.variationCost() ?
+            this.variationCost() : 0;
+        if (this.variationUnitCost() && quantity) {
+            total += (quantity * this.variationUnitCost());
+        }
+        return total;
+    };
+
+    this.onceOffCost = function () {
+        return this.variationCost();
+    };
+
+    this.unitCost = function () {
+        return this.variationUnitCost();
+    };
+}

package/src/variation_option.js

@@ -0,0 +1,59 @@
+import { generateUUID } from './uuid.js';
+import { addPropertyTo } from './model.js';
+import { MerchiFile } from './merchi_file.js';
+import { Variation } from './variation.js';
+
+export function VariationOption() {
+    this.json = 'variation_option';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'optionId');
+    addPropertyTo(this, 'value');
+    addPropertyTo(this, 'available');
+    addPropertyTo(this, 'position');
+    addPropertyTo(this, 'default');
+    addPropertyTo(this, 'include');
+    addPropertyTo(this, 'colour');
+    addPropertyTo(this, 'quantity');
+    addPropertyTo(this, 'onceOffCost');
+    addPropertyTo(this, 'unitCost');
+    addPropertyTo(this, 'unitCostTotal');
+    addPropertyTo(this, 'totalCost');
+    addPropertyTo(this, 'fieldName');
+    addPropertyTo(this, 'linkedFile', MerchiFile);
+
+    this.copyFieldOption = function (option) {
+        this.optionId(option.id());
+        this.value(option.value());
+        this.colour(option.colour());
+        this.position(option.position());
+        this.default(option.default());
+        this.onceOffCost(option.variationCost());
+        this.unitCost(option.variationUnitCost());
+        this.linkedFile(option.linkedFile());
+    }
+
+    // a hack around function for job cloneable renderering
+    this.covertToVariation = function () {
+        var variationConverted = new Variation(),
+            unitCost = this.unitCost(),
+            fieldName = this.fieldName(),
+            optionValue = this.value();
+        variationConverted.value(this.optionId());
+        variationConverted.quantity(this.quantity());
+        variationConverted.onceOffCost(this.onceOffCost());
+        variationConverted.unitCostTotal(this.unitCostTotal());
+
+        // hack around for variation unit cost
+        variationConverted.unitCost = function () {
+            return unitCost;
+        };
+        variationConverted.valueString = function () {
+            return optionValue;
+        };
+        variationConverted.fieldName = function () {
+            return fieldName;
+        };
+        return variationConverted;
+    };
+}

package/src/variations_group.js

@@ -0,0 +1,43 @@
+import { generateUUID } from './uuid.js';
+import { addPropertyTo } from './model.js';
+import { Variation } from './variation.js';
+
+export function VariationsGroup() {
+    this.resource = '/variationsGroups';
+    this.json = 'variationsGroup';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'inventoryCount');
+    addPropertyTo(this, 'inventorySufficient');
+    addPropertyTo(this, 'quantity');
+    addPropertyTo(this, 'groupCost');
+    addPropertyTo(this, 'variations', Variation);
+
+    this.clone = function () {
+        var groupClone = new VariationsGroup(),
+            variationsClone = [], i;
+        groupClone.groupCost(this.groupCost());
+        groupClone.quantity(this.quantity());
+        for (i = 0; i < this.variations().length; i++) {
+            variationsClone.push(this.variations()[i].clone());
+        }
+        return groupClone.variations(variationsClone);
+    };
+
+    this.loopVariationsAndReturnAttributeTotal = function (attribute) {
+        var variations = this.variations() ?
+                this.variations() : [],
+            total = 0,
+            i;
+        for (i = 0; i < variations.length; i++) {
+            total += variations[i][attribute]();
+        }
+        return parseFloat(total).toFixed(2);
+    };
+
+    this.variationsUnitCostAndOnceOffCost = function () {
+        return this.loopVariationsAndReturnAttributeTotal(
+            'unitCostAndOnceOffCost');
+    };
+}

package/src/white_label_accessibilities.js

@@ -0,0 +1,6 @@
+import { Dictionary } from './dictionary.js';
+
+export const whiteLabelAccessibilities = new Dictionary();
+whiteLabelAccessibilities.add("NOT_REACHABLE", 0);
+whiteLabelAccessibilities.add("NO_CERITICATE", 1);
+whiteLabelAccessibilities.add("FULLY_REACHABLE", 2);