merchi_sdk_ts 0.0.1

package/src/entities/user.test.ts

@@ -0,0 +1,154 @@
+import { Merchi } from '../merchi';
+import { Role } from '../constants/roles';
+import { SystemRoles } from '../constants/system_roles';
+import { DomainType } from '../constants/domain_types';
+import { setup, mockFetch } from '../test_util';
+import { every } from 'lodash';
+
+setup();
+
+test('can make User', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  expect(user).toBeTruthy();
+});
+
+test('can issue public create request to server', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  user.name = 'Test User';
+  const data = Array.from((user.toFormData() as any).entries());
+  const fetch = mockFetch(true, {}, 201);
+  user.publicCreate();
+  const fetchUrl = fetch.mock.calls[0][0];
+  const sentToServer = Array.from(fetch.mock.calls[0][1]['body'].entries());
+  expect(sentToServer).toEqual(data);
+  expect(fetchUrl).toMatch('public_user_create');
+});
+
+test('role helper function', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  const userSupplier = new merchi.User();
+  const domain1 = new merchi.Domain();
+  const domain2 = new merchi.Domain();
+  const enrolledDomain = new merchi.EnrolledDomain();
+  const enrolledDomainSupplier = new merchi.EnrolledDomain();
+  domain1.id = 1;
+  domain2.id = 2;
+  enrolledDomain.role = Role.ADMIN;
+  enrolledDomainSupplier.role = Role.SUPPLIER;
+  // throw error if enrolledDomains is undefined which seems to be an embed issue
+  expect(() => {user.roleInDomain(domain1);}).toThrow(Error);
+
+  // throw error if enrolledDomain.domain is undefined which seems to be an embed issue
+  user.enrolledDomains = [enrolledDomain];
+  expect(() => {user.roleInDomain(domain1);}).toThrow(Error);
+
+  userSupplier.enrolledDomains = [enrolledDomainSupplier];
+
+  enrolledDomain.domain = domain1;
+  enrolledDomainSupplier.domain = domain1;
+  expect(user.roleInDomain(domain1)).toBe(Role.ADMIN);
+  expect(userSupplier.roleInDomain(domain1)).toBe(Role.SUPPLIER);
+  expect(user.roleInDomain(domain2)).toBe(Role.PUBLIC);
+
+  expect(user.isManagementTeam(domain1)).toBe(true);
+  expect(user.isManagementTeam(domain2)).toBe(false);
+  expect(user.isDomainManager(domain1)).toBe(true);
+  expect(user.isDomainManager(domain2)).toBe(false);
+  expect(user.isNotClient(domain1)).toBe(true);
+  expect(userSupplier.isManagementTeam(domain1)).toBe(false);
+  expect(userSupplier.isNotClient(domain1)).toBe(true);
+
+  // have two match enrolled domain is invalid data, but we should return
+  // the highest permission
+  const enrolledDomainClient = new merchi.EnrolledDomain();
+  enrolledDomainClient.role = Role.CLIENT;
+  enrolledDomainClient.domain = domain1;
+
+  user.enrolledDomains = [enrolledDomain, enrolledDomainClient];
+  expect(user.roleInDomain(domain1)).toBe(Role.ADMIN);
+});
+
+test('companies', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  // user.userCompanies not embeded yet will throw a error as it suppose to
+  // be a embed issue
+  expect(() => user.companies()).toThrow();
+
+  const userCompany1 = new merchi.UserCompany();
+  const userCompany2 = new merchi.UserCompany();
+  user.userCompanies = [userCompany1, userCompany2];
+  expect(() => user.companies()).toThrow();
+
+  const company1 = new merchi.Company();
+  const company2 = new merchi.Company();
+  userCompany1.company = company1;
+  userCompany2.company = company2;
+  expect(user.companies()).toEqual([company1, company2]);
+});
+
+test('hasRoles', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  // EnrolledDomains has not been specified yet likely to be a embed issue
+  expect(() => user.hasRoles([Role.ADMIN])).toThrow();
+  const enrollment = new merchi.EnrolledDomain();
+  user.enrolledDomains = [enrollment];
+  // EnrolledDomains.domain has not been specified yet likely to be
+  // a embed issue
+  expect(() => user.hasRoles([Role.PUBLIC])).toThrow();
+
+  enrollment.domain = new merchi.Domain();
+  expect(user.hasRoles([Role.PUBLIC])).toBeTruthy();
+
+  enrollment.role = Role.ADMIN;
+  user.enrolledDomains = [enrollment];
+  expect(user.hasRoles([Role.ADMIN, Role.MANAGER])).toBeTruthy();
+  expect(user.hasRoles([Role.ADMIN, Role.MANAGER], every)).toBeFalsy();
+
+  // for internal supplier domain, role can be maximumly interpreted
+  // as supplier
+  enrollment.domain.domainType = DomainType.DOMAIN_SUPPLIER;
+  expect(user.hasRoles([Role.ADMIN])).toBeFalsy();
+  expect(user.hasRoles([Role.SUPPLIER])).toBeTruthy();
+});
+
+test('testHasSystemRoles', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  // SystemRole has not been specified yet likely to be a embed issue
+  expect(
+    () => user.hasSystemRole(SystemRoles.SYSTEM_COMPONENT_BUILDER)).toThrow();
+  user.systemRoles = [];
+  expect(user.hasSystemRole(SystemRoles.SYSTEM_COMPONENT_BUILDER)).toBeFalsy();
+  const systemRole = new merchi.SystemRole();
+  systemRole.role = SystemRoles.SYSTEM_COMPONENT_BUILDER;
+  user.systemRoles = [systemRole];
+  expect(user.hasSystemRole(SystemRoles.SYSTEM_COMPONENT_BUILDER)).toBeTruthy();
+});
+
+test('domainsByRoles', () => {
+  const merchi = new Merchi();
+  const user = new merchi.User();
+  expect(() => user.domainsByRoles([])).toThrow();
+  user.enrolledDomains = [];
+  expect(user.domainsByRoles([])).toEqual([]);
+  const ed = new merchi.EnrolledDomain();
+  user.enrolledDomains = [ed];
+  expect(() => user.domainsByRoles([])).toThrow();
+  const d = new merchi.Domain();
+  ed.domain = d;
+  expect(() => user.domainsByRoles([])).toThrow();
+  user.isSuperUser = false;
+  expect(user.domainsByRoles([])).toEqual([]);
+  user.isSuperUser = true;
+  expect(user.domainsByRoles([])).toEqual([d]);
+  user.isSuperUser = false;
+  ed.role = Role.MANAGER;
+  expect(user.domainsByRoles([Role.MANAGER])).toEqual([d]);
+  ed.role = Role.DESIGNER;
+  expect(user.domainsByRoles([Role.MANAGER])).toEqual([]);
+});

package/src/entities/user.ts

@@ -0,0 +1,394 @@
+import { Address } from './address';
+import { Assignment } from './assignment';
+import { Cart } from './cart';
+import { Category } from './category';
+import { CompanyInvitation } from './company_invitation';
+import { DomainInvitation } from './domain_invitation';
+import { Draft } from './draft';
+import { DraftComment } from './draft_comment';
+import { EmailAddress } from './email_address';
+import { EnrolledDomain } from './enrolled_domain';
+import { Domain } from './domain';
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+import { Invoice } from './invoice';
+import { Job } from './job';
+import { JobComment } from './job_comment';
+import { Notification } from './notification';
+import { Payment } from './payment';
+import { PhoneNumber } from './phone_number';
+import { Product } from './product';
+import { ProductionComment } from './production_comment';
+import { Session } from './session';
+import { Shipment } from './shipment';
+import { SystemRole } from './system_role';
+import { Theme } from './theme';
+import { UserCompany } from './user_company';
+import { Company } from './company';
+import { Role,
+  DOMAIN_MANAGERS,
+  MANAGEMENT_TEAM,
+  BUSINESS_ACCOUNTS,
+  ROLES_RANK
+} from '../constants/roles';
+import { InternalTag } from './internal_tag';
+import { UserType } from '../constants/user_types';
+import { SystemRoles as SR } from '../constants/system_roles';
+
+import { some } from 'lodash';
+
+export class User extends Entity {
+  protected static resourceName = 'users';
+  protected static singularName = 'user';
+  protected static pluralName = 'users';
+
+  @User.property({type: Date})
+  public archived?: Date | null;
+
+  @User.property()
+  public id?: number;
+
+  @User.property()
+  public isSuperUser?: boolean;
+
+  @User.property()
+  public userType?: UserType;
+
+  @User.property()
+  public registeredAsGuest?: boolean;
+
+  @User.property({arrayType: 'InternalTag'})
+  public internalTags?: InternalTag[];
+
+  @User.property({arrayType: 'Domain'})
+  public registeredUnderDomains?: Domain[];
+
+  @User.property({type: String})
+  public password?: string | null;
+
+  @User.property({type: String})
+  public salt?: string | null;
+
+  @User.property({type: String})
+  public facebookUserId?: string | null;
+
+  @User.property({type: String})
+  public resetToken?: string | null;
+
+  @User.property({type: String})
+  public resetTokenDate?: Date | null;
+
+  @User.property({type: String})
+  public smsToken?: string | null;
+
+  @User.property({type: Date})
+  public resetSmsTokenDate?: Date | null;
+
+  @User.property({type: String})
+  public smsClientToken?: string | null;
+
+  @User.property()
+  public smsTokenConfirmed?: boolean;
+
+  @User.property()
+  public smsLoginThreshold?: number;
+
+  @User.property()
+  public hasStore?: boolean;
+
+  @User.property()
+  public enableCrashReports?: boolean;
+
+  @User.property()
+  public enableClientEmails?: boolean;
+
+  @User.property({type: String})
+  public clientToken?: string | null;
+
+  @User.property()
+  public name?: string;
+
+  @User.property({type: String})
+  public internalUseNotes?: string;
+
+  @User.property({type: String})
+  public internalUseAiContext?: string;
+
+  @User.property({type: String})
+  public aiContext?: string;
+
+  @User.property()
+  public callToActions?: string;
+
+  @User.property()
+  public callToActionDetails?: any[];
+
+  @User.property({type: String})
+  public comments?: string | null;
+
+  @User.property({type: String})
+  public timezone?: string | null;
+
+  @User.property({type: Date})
+  public created?: Date | null;
+
+  @User.property({type: String})
+  public preferredLanguage?: string | null;
+
+  @User.property()
+  public enableInvoiceReminders?: boolean;
+
+  @User.property()
+  public enableStoreNotifications?: boolean;
+
+  @User.property()
+  public isAdminOfSubscribedCompany?: boolean;
+
+  @User.property({ arrayType: 'JobComment' })
+  public jobComments?: JobComment[];
+
+  @User.property({ arrayType: 'EmailAddress' })
+  public _emailAddresses?: EmailAddress[];
+
+  @User.property({ arrayType: 'PhoneNumber' })
+  public _phoneNumbers?: PhoneNumber[];
+
+  @User.property({ arrayType: 'Address' })
+  public _addresses?: Address[];
+
+  @User.property({ arrayType: 'UserCompany' })
+  public _companies?: UserCompany[];
+
+  @User.property({ arrayType: 'Company' })
+  public companiesNeedStripe?: Company[];
+
+  @User.property({ arrayType: 'Category' })
+  public categories?: Category[];
+
+  @User.property({ arrayType: 'Product' })
+  public products?: Product[];
+
+  @User.property({type: 'MerchiFile'})
+  public profilePicture?: MerchiFile | null;
+
+  @User.property({ arrayType: 'PhoneNumber' })
+  public phoneNumbers?: PhoneNumber[];
+
+  @User.property({ arrayType: 'Session' })
+  public sessions?: Session[];
+
+  @User.property({ arrayType: 'Shipment' })
+  public shipmentsAsSender?: Shipment[];
+
+  @User.property({ arrayType: 'Shipment' })
+  public shipmentsAsReceiver?: Shipment[];
+
+  @User.property({ arrayType: 'DraftComment' })
+  public draftComments?: DraftComment[];
+
+  @User.property({ arrayType: 'DraftComment' })
+  public forwardedDraftComments?: DraftComment[];
+
+  @User.property({ arrayType: 'SystemRole' })
+  public systemRoles?: SystemRole[];
+
+  @User.property({ arrayType: 'EmailAddress' })
+  public emailAddresses?: EmailAddress[];
+
+  @User.property({ arrayType: 'Notification' })
+  public notifications?: Notification[];
+
+  @User.property({ arrayType: 'Notification' })
+  public sentNotifications?: Notification[];
+
+  @User.property({ arrayType: 'Assignment' })
+  public assignments?: Assignment[];
+
+  @User.property({ arrayType: 'UserCompany' })
+  public userCompanies?: UserCompany[];
+
+  @User.property({ arrayType: 'Draft' })
+  public drafts?: Draft[];
+
+  @User.property({ arrayType: 'CompanyInvitation' })
+  public companyInvitations?: CompanyInvitation[];
+
+  @User.property({ arrayType: 'Address' })
+  public addresses?: Address[];
+
+  @User.property({ arrayType: 'MerchiFile' })
+  public uploadFiles?: MerchiFile[];
+
+  @User.property({ arrayType: 'JobComment' })
+  public forwardedJobComments?: JobComment[];
+
+  @User.property({ arrayType: 'Job' })
+  public appliedJobs?: Job[];
+
+  @User.property({ arrayType: 'Job' })
+  public managedJobs?: Job[];
+
+  @User.property({ arrayType: 'Job' })
+  public draftingJobs?: Job[];
+
+  @User.property({ arrayType: 'Product' })
+  public saved_products?: Product[];
+
+  @User.property({ arrayType: 'Cart' })
+  public carts?: Cart[];
+
+  @User.property({ arrayType: 'Payment' })
+  public payments?: Payment[];
+
+  @User.property({ arrayType: 'EnrolledDomain' })
+  public enrolledDomains?: EnrolledDomain[];
+
+  @User.property({ arrayType: 'Invoice' })
+  public responsibleInvoices?: Invoice[];
+
+  @User.property({ arrayType: 'Invoice' })
+  public createdInvoices?: Invoice[];
+
+  @User.property({ arrayType: 'Invoice' })
+  public invoicesHas?: Invoice[];
+
+  @User.property({ arrayType: 'DomainInvitation' })
+  public sentDomainInvitations?: DomainInvitation[];
+
+  @User.property({ arrayType: 'DomainInvitation' })
+  public receivedDomainInvitations?: DomainInvitation[];
+
+  @User.property({ arrayType: 'Theme' })
+  public themes?: Theme[];
+
+  @User.property({ arrayType: 'ProductionComment' })
+  public forwardedProductionComments?: ProductionComment[];
+
+  @User.property({ arrayType: 'Domain' })
+  public accessibleDomainsAsClient?: Domain[];
+
+  public publicCreate = this.createFactory(
+    {resourceName: 'public_user_create'});
+
+  public roleInDomain = (domain: Domain): Role => {
+    if (this.enrolledDomains === undefined) {
+      const err = 'enrolledDomains is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    if (
+      this.enrolledDomains
+        .map(enrolledDomain => enrolledDomain.domain)
+        .some(domain => domain === undefined)
+    ) {
+      const err =
+        'Domain of enrolled domain is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    const matchingEnrolledDomains = this.enrolledDomains.filter(
+      enrolledDomain => enrolledDomain.domain && enrolledDomain.domain.id === domain.id);
+
+    if (matchingEnrolledDomains.length > 1) {
+      const highestRoleRank = Math.max(
+        ...matchingEnrolledDomains.map(ed => ROLES_RANK.findIndex(e => e === ed.role)));
+      return ROLES_RANK[highestRoleRank];
+    }
+
+    // due to some current system issues, user can have multiple enrolled domain
+    // of one domain, if that is the case either of them can be consider as
+    // valid, need to revisit it in the future related to #
+    if (matchingEnrolledDomains.length > 0) {
+      if (matchingEnrolledDomains[0].role !== undefined) {
+        return matchingEnrolledDomains[0].role;
+      }
+    }
+    return Role.PUBLIC;
+  };
+
+  public isSuper(): boolean {
+    if (this.isSuperUser === undefined) {
+      const err = 'isSuperUser is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    return this.isSuperUser!;
+  }
+
+  public companies(): Company[] {
+    if (this.userCompanies === undefined) {
+      const err = 'userCompanies is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    return this.userCompanies.map((userCompany) => {
+      if (userCompany.company === undefined) {
+        const err = 'userCompany.company is undefined, did you forget to embed it?';
+        throw new Error(err);
+      }
+      return userCompany.company!;
+    });
+  }
+
+  public isDomainManager(domain: Domain) {
+    return DOMAIN_MANAGERS.includes(this.roleInDomain(domain));
+  }
+
+  public isManagementTeam(domain: Domain) {
+    return MANAGEMENT_TEAM.includes(this.roleInDomain(domain));
+  }
+
+  public isNotClient(domain: Domain) {
+    return BUSINESS_ACCOUNTS.includes(this.roleInDomain(domain));
+  }
+
+  public domainsByRoles(roles: Role[]) {
+    if (this.enrolledDomains === undefined) {
+      const err = 'enrolledDomains is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    const result = [];
+    for (let i = 0; i < this.enrolledDomains.length; ++i) {
+      const domain = this.enrolledDomains[i].domain;
+      if (domain === undefined) {
+        const err = 'domain is undefined, did you forget to embed it?';
+        throw new Error(err);
+      }
+      if (this.hasAuthority(domain, roles)) {
+        result.push(domain);
+      }
+    }
+    return result;
+  }
+
+  public hasAuthority(domain: Domain, roles: Role[]) {
+    if (this.isSuper()) {
+      return true;
+    }
+    const role = this.roleInDomain(domain);
+    for (let i = 0; i < roles.length; ++i) {
+      if (roles[i] === role) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public hasSystemRole(role: SR): boolean {
+    if (this.systemRoles === undefined) {
+      const err = 'systemRoles is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    return some(this.systemRoles.map(systemRole => systemRole.role === role));
+  }
+
+  public hasRoles(roles: Role[], combinationMethod = some) {
+    if (this.enrolledDomains === undefined) {
+      const err = 'enrolledDomains is undefined, did you forget to embed it?';
+      throw new Error(err);
+    }
+    const allRoles = this.enrolledDomains.map(
+      enrolledDomain => enrolledDomain.getRole()
+    );
+    allRoles.push(Role.PUBLIC);
+    return combinationMethod(
+      roles.map((role) => allRoles.indexOf(role) !== -1)
+    );
+  }
+}

package/src/entities/user_company.test.ts

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

package/src/entities/user_company.ts

@@ -0,0 +1,27 @@
+import { Company } from './company';
+import { Entity } from '../entity';
+import { User } from './user';
+
+export class UserCompany extends Entity {
+  protected static resourceName = 'user_companies';
+  protected static singularName = 'userCompany';
+  protected static pluralName = 'userCompanies';
+
+  @UserCompany.property({type: Date})
+  public archived?: Date | null;
+
+  @UserCompany.property()
+  public id?: number;
+
+  @UserCompany.property({type: Boolean})
+  public main?: boolean | null;
+
+  @UserCompany.property()
+  public isAdmin?: boolean;
+
+  @UserCompany.property({type: User})
+  public user?: User | null;
+
+  @UserCompany.property({type: Company})
+  public company?: Company | null;
+}

package/src/entities/variation.test.ts

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

package/src/entities/variation.ts

@@ -0,0 +1,61 @@
+import { CartItem } from './cart_item';
+import { Entity } from '../entity';
+import { MerchiFile } from './file';
+import { Job } from './job';
+import { VariationField } from './variation_field';
+import { VariationOption } from './variation_option';
+import { VariationsGroup } from './variations_group';
+
+export class Variation extends Entity {
+  protected static resourceName = 'variations';
+  protected static singularName = 'variation';
+  protected static pluralName = 'variations';
+
+  @Variation.property({type: Date})
+  public archived?: Date | null;
+
+  @Variation.property()
+  public id?: number;
+
+  @Variation.property({type: String})
+  public value?: string | null;
+
+  @Variation.property()
+  public currency?: string;
+
+  @Variation.property()
+  public cost?: number;
+
+  @Variation.property()
+  public quantity?: number;
+
+  @Variation.property()
+  public onceOffCost?: number;
+
+  @Variation.property()
+  public unitCost?: number;
+
+  @Variation.property()
+  public unitCostTotal?: number;
+
+  @Variation.property()
+  public variationField?: VariationField;
+
+  @Variation.property({type: VariationsGroup})
+  public variationsGroup?: VariationsGroup | null;
+
+  @Variation.property({type: Job})
+  public job?: Job | null;
+
+  @Variation.property({type: CartItem})
+  public cartItem?: CartItem | null;
+
+  @Variation.property({arrayType: 'MerchiFile'})
+  public variationFiles?: MerchiFile[];
+
+  @Variation.property({arrayType: 'VariationOption'})
+  public selectedOptions?: VariationOption[];
+
+  @Variation.property({arrayType: 'VariationOption'})
+  public selectableOptions?: VariationOption[];
+}