merchi_sdk_js 0.0.1

package/src/dictionary.js

@@ -0,0 +1,135 @@
+import NodeFormData from 'form-data';
+import { isBrowser, isJsDom } from "browser-or-node";
+
+export function Dictionary() {
+
+    var store = {},
+        count = 0;
+
+    function noSuchKey(name) {
+        throw 'No such key "' + String(name) + '" in dictionary';
+    }
+
+    this.clone = function () {
+        return new Dictionary(store, count);
+    };
+
+    this.add = function (name, value) {
+        if (!this.has(name)) {
+            ++count;
+        }
+        store[name] = value;
+        return this;
+    };
+
+    this.getArray = function (names) {
+    /** passing a array of keys return the values array
+     * corresponding to the keys **/
+        var i, returnArray = [];
+        for (i = 0; i < names.length; i++) {
+            if (this.has(names[i])) {
+                returnArray.push(store[names[i]]);
+            } else {
+                noSuchKey(names[i]);
+            }
+        }
+        return returnArray;
+    };
+
+   this.get = function (name, default_) {
+        if (this.has(name)) {
+            return store[name];
+        }
+        if (default_ !== undefined) {
+            return default_;
+        }
+        return noSuchKey(name);
+    };
+
+    this.has = function (name) {
+        return Object.prototype.hasOwnProperty.call(store, name) &&
+            Object.prototype.propertyIsEnumerable.call(store, name);
+    };
+
+    this.remove = function (name) {
+        if (this.has(name)) {
+            delete store[name];
+            --count;
+            return this;
+        }
+        return noSuchKey(name);
+    };
+
+    this.merge = function (other) {
+        var _this = this;
+        if (other.__proto__.constructor === Dictionary) {
+            other.each(function (name, value) {
+                _this.add(name, value);
+            });
+        } else {
+            for (var property in other) {
+                if (other.hasOwnProperty(property)) {
+                    _this.add(property, other[property]);
+                }
+            }
+        }
+        return this;
+    };
+
+   this.each = function (procedure) {
+        var name;
+        for (name in store) {
+            if (Object.prototype.hasOwnProperty.call(store, name)) {
+                procedure(name, store[name]);
+            }
+        }
+        return this;
+    };
+
+    this.keys = function () {
+        var result = [];
+        this.each(function (name) { result.push(name); });
+        return result;
+    };
+
+    this.values = function () {
+        var result = [];
+        this.each(function (ignore, value) { result.push(value); });
+        return result;
+    };
+
+    this.count = function () {
+        return count;
+    };
+
+    this.toFormData = function () {
+        var result;
+        if (isJsDom || isBrowser) {
+            result = new FormData();
+        } else {
+            result = new NodeFormData();
+        }
+        this.each(function (key, value) {
+            result.append(key, value);
+        });
+        return result;
+    };
+
+   this.toUriEncoding = function () {
+        var result = '';
+        this.each(function (key, value) {
+            if (typeof key === "object") {
+                throw "cannot URI encode object key";
+            }
+            if (typeof value === "object") {
+                throw "cannot URI encode object name";
+            }
+            result += encodeURIComponent(key);
+            result += '=';
+            result += encodeURIComponent(value);
+            result += '&';
+        });
+        return result.slice(0, -1);
+    };
+
+}

package/src/discount.js

@@ -0,0 +1,19 @@
+import { generateUUID } from './uuid.js';
+import { addPropertyTo } from './model.js';
+
+export function Discount() {
+    this.resource = '/discounts';
+    this.json = 'discount';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'lowerLimit');
+    addPropertyTo(this, 'amount');
+
+    this.discountedUnitCost = function (unitPrice) {
+        var unitCost = unitPrice ? unitPrice : 0,
+            amount = this.amount() ? this.amount() : 0,
+            discount = 100 - amount;
+        return parseFloat((unitCost / 100) * discount).toFixed(3);
+    };
+}

package/src/discount_group.js

@@ -0,0 +1,15 @@
+import { generateUUID } from './uuid.js';
+import { addPropertyTo } from './model.js';
+
+
+export function DiscountGroup() {
+    this.resource = '/discountGroups';
+    this.json = 'discountGroup';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'discountType');
+    addPropertyTo(this, 'discounts');
+    addPropertyTo(this, 'name');
+    addPropertyTo(this, 'product');
+}

package/src/domain.js

@@ -0,0 +1,254 @@
+import { generateUUID } from './uuid.js';
+import { Dictionary } from './dictionary.js';
+import { addPropertyTo, serialise, fromJson, getList, fromJsonList, patchOne,
+    getOne, create, enumerateFiles, Request } from './model.js';
+import { SELLER, SELLER_PLUS, SUPPLIER, RESTRICTED_SUPPLIER } from './roles.js';
+import { domainTypesInts } from './domain_types.js';
+import { Company } from './company.js';
+import { DomainTag } from './domain_tag.js';
+import { DomainInvitation } from './domain_invitation.js';
+import { Theme } from './theme.js';
+import { MerchiFile } from './merchi_file.js';
+import { Menu } from './menu.js';
+import { SupplyDomain } from './supply_domain.js';
+import { SeoDomainPage } from './seo_domain_page.js';
+import { User, Users } from './user.js';
+import { InternalTag } from './internal_tag.js';
+
+export function Domain() {
+    this.resource = '/domains';
+    this.json = 'domain';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'aiContext');
+    addPropertyTo(this, 'apiSecret');
+    addPropertyTo(this, 'webflowApiKey');
+    addPropertyTo(this, 'shopifyShopUrl');
+    addPropertyTo(this, 'shopifyIsActive');
+    addPropertyTo(this, 'country');
+    addPropertyTo(this, 'currency');
+    addPropertyTo(this, 'domain');
+    addPropertyTo(this, 'domainType');
+    addPropertyTo(this, 'activeThemeId');
+    addPropertyTo(this, 'activeTheme', Theme);
+    addPropertyTo(this, 'subDomain');
+    addPropertyTo(this, 'theme');
+    addPropertyTo(this, 'logoUrl');
+    addPropertyTo(this, 'smsName');
+    addPropertyTo(this, 'emailDomain');
+    addPropertyTo(this, 'trackingCodeGoogleConversion');
+    addPropertyTo(this, 'trackingCodeGoogleGlobal');
+    addPropertyTo(this, 'qrShopQrCode');
+    addPropertyTo(this, 'logo', MerchiFile);
+    addPropertyTo(this, 'favicon', MerchiFile);
+    addPropertyTo(this, 'company', Company);
+    addPropertyTo(this, 'ownedBy', Company);
+    addPropertyTo(this, 'accessibleClients', User);
+    addPropertyTo(this, 'accessibleClientCompanies', Company);
+    addPropertyTo(this, 'unltdAiApiOrganizationId');
+    addPropertyTo(this, 'unltdAiApiSecretKey');
+    addPropertyTo(this, 'menus', Menu);
+
+    addPropertyTo(this, 'socialBitchute');
+    addPropertyTo(this, 'socialDiscord');
+    addPropertyTo(this, 'socialFacebook');
+    addPropertyTo(this, 'socialGoogle');
+    addPropertyTo(this, 'socialInstagram');
+    addPropertyTo(this, 'socialLinkedin');
+    addPropertyTo(this, 'socialRumble');
+    addPropertyTo(this, 'socialTelegram');
+    addPropertyTo(this, 'socialTiktok');
+    addPropertyTo(this, 'socialX');
+    addPropertyTo(this, 'socialYoutube');
+
+    addPropertyTo(this, 'internalUseNotes');
+    addPropertyTo(this, 'internalUseAiContext');
+
+    addPropertyTo(this, 'showDomainPublicly');
+    addPropertyTo(this, 'publicAccessRestricted');
+    addPropertyTo(this, 'showDomainToAccessibleEntitiesOnly')
+    addPropertyTo(this, 'enableNotifications');
+    addPropertyTo(this, 'enableEmailNotifications');
+    addPropertyTo(this, 'enableSmsNotifications');
+    addPropertyTo(this, 'seoDomainPages', SeoDomainPage);
+    addPropertyTo(this, 'themes', Theme);
+    addPropertyTo(this, 'supplyProducts', SupplyDomain);
+    addPropertyTo(this, 'domainInvitations', DomainInvitation);
+    addPropertyTo(this, 'jobsAssignees', User);
+    addPropertyTo(this, 'tags', DomainTag);
+    addPropertyTo(this, 'internalTags', InternalTag);
+
+    this.create = function (success, error, embed, as_domain) {
+        var data = serialise(this),
+            self = this;
+        function handleResponse(result) {
+            success(fromJson(self, result[self.json]));
+        }
+        create({resource: this.resource,
+                parameters: data[0],
+                files: enumerateFiles(data[1]),
+                as_domain: as_domain,
+                success: handleResponse,
+                error: error,
+                embed: embed});
+    };
+
+    this.get = function (success, error, embed, withRights) {
+        var self = this;
+        function handleResponse(result) {
+            success(fromJson(self, result[self.json],
+                             {makesDirty: false}));
+        }
+        getOne({resource: this.resource,
+                id: this.id(),
+                success: handleResponse,
+                error: error,
+                embed: embed,
+                withRights: withRights});
+    };
+
+    this.invite = function (invitationData, success, error, embed) {
+        var request = new Request(),
+            data = new Dictionary(),
+            self = this,
+            _id = self.id();
+
+        function handleResponse(status, data) {
+            var newInvitation = new DomainInvitation(),
+                invitation = data,
+                invitations = self.domainInvitations() ?
+                  self.domainInvitations() : [];
+            newInvitation.id(invitation.id);
+            newInvitation.userEmail(invitation.userEmail);
+            newInvitation.userName(invitation.userName);
+            newInvitation.role(invitation.role);
+            invitations.push(newInvitation);
+            self.domainInvitations(invitations);
+            success(self);
+        }
+
+        data.add("inviteUserEmail", invitationData.emailAddress);
+        data.add("inviteUserName", invitationData.userName);
+        data.add("domainId", _id);
+        data.add("domainRole", invitationData.role);
+        request.resource('/domain_invite/').method('POST');
+        request.data().merge(data);
+        request.responseHandler(handleResponse);
+        request.errorHandler(error);
+        request.send();
+    }
+    this.getUsers = function (success, error, offset, limit,
+                              q, embed, tab) {
+        var self = this,
+            users = new Users();
+
+        function handleResponse(result) {
+            success(fromJsonList(users, result));
+        }
+        getList(users.resource, handleResponse, error,
+                {inDomain: self.id(), tab: tab, offset: offset,
+                 limit: limit, q: q, embed: embed});
+    };
+
+    this.getManagers = function (success, error, offset, limit, embed) {
+        var self = this;
+        self.getUsers(success, error, offset, limit,
+                      null, embed, "manager");
+    };
+
+    this.getUsersWithRoles = function (success, error, roles, offset,
+                                       limit, embed) {
+        var self = this,
+            users = new Users();
+
+        function handleResponse(result) {
+            success(fromJsonList(users, result));
+        }
+
+        getList(users.resource, handleResponse, error,
+                {inDomain: self.id(), inDomainRoles: roles,
+                 offset: offset, limit: limit, embed: embed});
+    };
+
+   this.patch = function (success, error, embed, as_domain) {
+        var data = data = serialise(this)[0],
+            self = this;
+        function handleResponse(result) {
+            success(fromJson(self, result[self.json]));
+        }
+        patchOne({resource: this.resource,
+                  id: this.id(),
+                  success: handleResponse,
+                  as_domain: as_domain,
+                  error: error,
+                  data: data,
+                  embed: embed});
+    };
+
+    this.update = function (success, error, embed) {
+        this.patch(success, error,
+                   serialise(this, undefined, undefined,
+                             undefined, {excludeOld: true})[0], embed);
+    };
+
+    this.mainMenu = function () {
+       var menus = this.menus(),
+           i = 0;
+       if (menus === undefined) {
+           return null;
+       }
+       for (i = 0; i < menus.length; ++i) {
+           if (menus[i].menuType() === 0) {
+               return menus[i];
+           }
+       }
+       return null;
+    };
+
+    this.domainLogoUrl = function () {
+        var logo = this.logo();
+        return logo && logo.viewUrl() ? logo.viewUrl() : null;
+    }
+
+    this.faviconLogoUrl = function () {
+        var favicon = this.favicon();
+        return favicon && favicon.viewUrl() ? favicon.viewUrl() : null;
+    }
+
+    this.isDomainType = function (typeName) {
+        return this.domainType() === domainTypesInts.get(typeName);
+    }
+
+    this.isSellerDomain = function () {
+        return this.isDomainType(SELLER);
+    }
+
+    this.isSellerOrSellerPlusDomain = function () {
+        return this.isSellerDomain() || this.isDomainType(SELLER_PLUS);
+    }
+
+    this.isSupplierOrRestrictedSupplierDomain = function () {
+        return this.isDomainType(SUPPLIER) ||
+            this.isDomainType(RESTRICTED_SUPPLIER);
+    }
+
+    this.isUnrestricted = function () {
+        return this.domainType() === domainTypesInts.get('Unrestricted');
+    }
+}
+
+export function Domains() {
+    this.resource = '/domains';
+    this.json = 'domains';
+    this.single = Domain;
+
+    this.get = function (success, error, parameters) {
+        var self = this;
+        function handleResponse(result) {
+            success(fromJsonList(self, result,
+                                 {makesDirty: false}));
+        }
+        getList(this.resource, handleResponse, error, parameters);
+    };
+}

package/src/domain_invitation.js

@@ -0,0 +1,13 @@
+import { generateUUID } from './uuid.js';
+import { addPropertyTo } from './model.js';
+
+export function DomainInvitation() {
+    this.resource = '/domain_invitations';
+    this.json = 'domainInvitation';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'userName');
+    addPropertyTo(this, 'userEmail');
+    addPropertyTo(this, 'role');
+}

package/src/domain_tag.js

@@ -0,0 +1,79 @@
+import { generateUUID } from './uuid.js';
+import { addPropertyTo, serialise, create, fromJson, patchOne, deleteOne,
+    fromJsonList, getList, enumerateFiles, getOne } from './model.js';
+import { Domain } from './domain.js';
+import { Product } from './product.js';
+
+export function DomainTag() {
+    this.resource = '/domain_tags';
+    this.json = 'domainTag';
+    this.temporaryId = generateUUID();
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'name');
+    addPropertyTo(this, 'description');
+    addPropertyTo(this, 'colour');
+    addPropertyTo(this, 'showPublic');
+    addPropertyTo(this, 'domain', Domain);
+    addPropertyTo(this, 'products', Product);
+
+    this.create = function (success, error, embed, domainId) {
+        var data = serialise(this),
+            self = this;
+        function handleResponse(result) {
+            success(fromJson(self, result[self.json]));
+        }
+        create({resource: this.resource,
+                parameters: data[0],
+                files: enumerateFiles(data[1]),
+                success: handleResponse,
+                error: error,
+                embed: embed,
+                as_domain: domainId});
+    };
+
+    this.get = function (success, error) {
+        var self = this;
+        function handleResponse(result) {
+            success(fromJson(self, result[self.json],
+                             {makesDirty: false}));
+        }
+        getOne({resource: this.resource,
+                id: this.id(),
+                success: handleResponse,
+                error: error});
+    };
+
+    this.patch = function (success, error, embed) {
+        var self = this,
+            data = serialise(this)[0];
+        function handleResponse(result) {
+            success(fromJson(self, result[self.json],
+                             {makesDirty: false}));
+        }
+        patchOne({resource: this.resource,
+                  id: this.id(),
+                  success: handleResponse,
+                  error: error,
+                  data: data,
+                  embed: embed});
+    };
+
+    this.destroy = function (success, error) {
+        deleteOne(this.resource + "/" + this.id(), success, error);
+    };
+}
+
+export function DomainTags() {
+    this.resource = '/domain_tags';
+    this.json = 'domainTags';
+    this.single = DomainTag;
+
+    this.get = function (success, error, parameters) {
+        var self = this;
+        function handleResponse(result) {
+            success(fromJsonList(self, result, {makesDirty: false}));
+        }
+        getList(this.resource, handleResponse, error, parameters);
+    };
+}

package/src/domain_types.js

@@ -0,0 +1,18 @@
+import { Dictionary } from './dictionary.js';
+
+export const domainTypes = new Dictionary();
+domainTypes.add(0, 'Unrestricted');
+domainTypes.add(1, 'Seller');
+domainTypes.add(2, 'Seller plus');
+domainTypes.add(3, 'Supplier');
+domainTypes.add(4, 'Restricted supplier');
+domainTypes.add(5, 'Domain supplier');
+domainTypes.add(6, 'Domain client catalogue');
+domainTypes.add(7, 'Domain shopify seller');
+domainTypes.add(8, 'Unrestricted shopify app');
+domainTypes.add(9, 'Reserved');
+
+export const domainTypesInts = new Dictionary();
+domainTypes.each(function (key, value) {
+    domainTypesInts.add(value, parseInt(key, 10));
+});

package/src/draft.js

@@ -0,0 +1,92 @@
+import { addPropertyTo, serialise, fromJsonList, getList, getOne,
+   fromJson, patchOne } from './model.js';
+import { sortArrayByObjectKeyDescending, isUndefined } from './helpers.js';
+import { Job } from './job.js';
+import { User } from './user.js';
+import { DraftComment } from './draft_comment.js';
+import { MerchiFile } from './merchi_file.js';
+
+export function Draft() {
+    this.resource = '/drafts';
+    this.json = 'draft';
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'job', Job);
+    addPropertyTo(this, 'sharedWithJob', Job);
+    addPropertyTo(this, 'designer', User);
+    addPropertyTo(this, 'file', MerchiFile);
+    addPropertyTo(this, 'date');
+    addPropertyTo(this, 'accepted');
+    addPropertyTo(this, 'changesRequested');
+    addPropertyTo(this, 'resendDate');
+    addPropertyTo(this, 'viewed');
+    addPropertyTo(this, 'justViewed');
+    addPropertyTo(this, 'comments', DraftComment);
+    addPropertyTo(this, 'commentsCount');
+    addPropertyTo(this, 'sendSms');
+    addPropertyTo(this, 'sendEmail');
+
+    this.get = function (success, error, embed, include_archived) {
+        var self = this;
+        function handleResponse(result) {
+            success(fromJson(self, result[self.json],
+                             {makesDirty: false}));
+        }
+        getOne({resource: this.resource,
+                id: this.id(),
+                success: handleResponse,
+                error: error,
+                embed: embed,
+                includeArchived: include_archived});
+    };
+
+    this.patch = function (options) {
+        var self = this,
+            data = serialise(this, undefined, undefined, undefined,
+                             {excludeOld: true})[0],
+            job = this.job(),
+            domain = job && job.domain() ? job.domain().id() : null,
+            asDomain = options.asDomain,
+            domainId = isUndefined(asDomain) ? domain : asDomain;
+        function handleResponse(result) {
+            options.success(fromJson(self, result[self.json]));
+        }
+        patchOne({resource: this.resource,
+                  id: this.id(),
+                  success: handleResponse,
+                  error: options.error,
+                  as_domain: domainId,
+                  data: data,
+                  embed: options.embed});
+    };
+
+    this.changesRequested = function () {
+        var comments = this.comments() ? this.comments() : [],
+            i;
+        for (i = 0; i < comments.length; i++) {
+            if (comments[i].changeRequest()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    this.commentsYoungestToEldest = function () {
+        return sortArrayByObjectKeyDescending(this.comments(), 'id');
+    }
+}
+
+export function Drafts() {
+    this.resource = '/drafts';
+    this.json = 'drafts';
+    this.single = Draft;
+
+    this.get = function (success, error, parameters) {
+        var self = this;
+        function handleResponse(result) {
+            success(fromJsonList(self, result,
+                                 {makesDirty: false}));
+        }
+        getList(this.resource, handleResponse, error, parameters);
+     };
+}

package/src/draft_comment.js

@@ -0,0 +1,41 @@
+import { addPropertyTo, serialise, create, enumerateFiles,
+    fromJson } from './model.js';
+import { Draft } from './draft.js';
+import { Job } from './job.js';
+import { User } from './user.js';
+import { Notification } from './notification.js';
+import { MerchiFile } from './merchi_file.js';
+
+export function DraftComment() {
+    this.resource = '/draft_comments';
+    this.json = 'draftComment';
+
+    addPropertyTo(this, 'id');
+    addPropertyTo(this, 'draft', Draft);
+    addPropertyTo(this, 'user', User);
+    addPropertyTo(this, 'file', MerchiFile);
+    addPropertyTo(this, 'notifications', Notification);
+    addPropertyTo(this, 'job', Job);
+    addPropertyTo(this, 'date');
+    addPropertyTo(this, 'text');
+    addPropertyTo(this, 'urgency');
+    addPropertyTo(this, 'subject');
+    addPropertyTo(this, 'sendSms');
+    addPropertyTo(this, 'sendEmail');
+    addPropertyTo(this, 'changeRequest');
+
+    this.create = function (options) {
+        var data = serialise(this),
+            self = this;
+        function handleResponse(result) {
+            options.success(fromJson(self, result[self.json]));
+        }
+        create({resource: this.resource,
+                parameters: data[0],
+                files: enumerateFiles(data[1]),
+                success: handleResponse,
+                as_domain: options.as_domain,
+                error: options.error,
+                embed: options.embed});
+    };
+}