@zohodesk/library-platform 1.0.0-exp.1

package/src/platform/zrecord/adapters/controllers/DeleteMultipleRecordLocalController.ts

@@ -0,0 +1,16 @@
+import IController from '@cc/architecture/IController';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default class DeleteMultipleRecordLocalController implements IController<any> {
+  constructor(private service: IService) {}
+
+  handle = (event) => {
+    const { state, updateState, action } = event;
+    const { payload } = action;
+    const { recordIds } = payload;
+    const { deleteMultipleRecordUseCase } = this.service;
+
+    deleteMultipleRecordUseCase.updateDependency(state, updateState);
+    deleteMultipleRecordUseCase.execute({ recordIds });
+  };
+}

package/src/platform/zrecord/adapters/controllers/FailureController.ts

@@ -0,0 +1,23 @@
+import IController from '@cc/architecture/IController';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default class FailureController implements IController<any> {
+  constructor(private service: IService) {}
+
+  handle = (event) => {
+    const { state, updateState } = event;
+    const { action, dispatch } = event;
+
+    const { metaData, payload } = action;
+    const { error } = payload;
+    const { failureUseCase } = this.service;
+
+    failureUseCase.updateDependency(state, updateState);
+
+    failureUseCase.execute({
+      dispatch,
+      error,
+      metaData
+    });
+  };
+}

package/src/platform/zrecord/adapters/controllers/FetchMoreController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+export default class FetchMoreController extends AbstractController<any> {
+  handle(event) {
+    const { state, updateState } = event;
+    const { action, dispatch } = event;
+    const { metaData, payload } = action;
+    const { apiName, actionName, props } = payload;
+    const { fetchMoreUseCase } = this.service;
+
+    fetchMoreUseCase.updateDependency(state, updateState);
+    fetchMoreUseCase.execute({ dispatch, metaData, apiName, actionName, props });
+  }
+}

package/src/platform/zrecord/adapters/controllers/FieldChangeController.ts

@@ -0,0 +1,12 @@
+import AbstractController from './AbstractController';
+
+export default class FieldChangeController extends AbstractController<any> {
+  handle(event: any) {
+    const { state, updateState, action } = event;
+    const { fieldName, recordId, value } = action.payload;
+    const { fieldChangeUseCase } = this.service;
+
+    fieldChangeUseCase.updateDependency(state, updateState);
+    fieldChangeUseCase.execute({ fieldName, recordId, value });
+  }
+}

package/src/platform/zrecord/adapters/controllers/MountController.ts

@@ -0,0 +1,17 @@
+import { HttpTemplates } from '@platform/data-broker/dbc';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default class MountController {
+  constructor(private recordApis: HttpTemplates, private service: IService) {}
+
+  handle = (event) => {
+    const { state, updateState } = event;
+
+    const { initializeUseCase } = this.service;
+    initializeUseCase.updateDependency(state, updateState);
+
+    initializeUseCase.execute({
+      apiTemplates: this.recordApis
+    });
+  };
+}

package/src/platform/zrecord/adapters/controllers/NoContentController.ts

@@ -0,0 +1,20 @@
+import IController from '@cc/architecture/IController';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default class NoContentController implements IController<any> {
+  constructor(private service: IService) {}
+
+  handle = (event) => {
+    const { state, updateState } = event;
+    const { action, dispatch } = event;
+    const { metaData } = action;
+    const { noContentUseCase } = this.service;
+
+    noContentUseCase.updateDependency(state, updateState);
+
+    noContentUseCase.execute({
+      dispatch,
+      metaData
+    });
+  };
+}

package/src/platform/zrecord/adapters/controllers/RecordUpdateLocalController.ts

@@ -0,0 +1,14 @@
+import AbstractController from './AbstractController';
+
+export default class RecordUpdateLocalController extends AbstractController<any> {
+  handle(event) {
+    const { state, updateState, action } = event;
+    const { recordId, record } = action.payload;
+    const { recordUpdateLocalUseCase } = this.service;
+    recordUpdateLocalUseCase.updateDependency(state, updateState);
+    recordUpdateLocalUseCase.execute({
+      recordId,
+      record
+    });
+  }
+}

package/src/platform/zrecord/adapters/controllers/RefetchController.ts

@@ -0,0 +1,24 @@
+import IController from '@cc/architecture/IController';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default class RefetchController implements IController<any> {
+  constructor(private service: IService) {}
+
+  handle = (event) => {
+    const { state, updateState } = event;
+    const { action, dispatch } = event;
+    const { refetchUseCase } = this.service;
+    refetchUseCase.updateDependency(state, updateState);
+
+    const { actionName, props, apiName } = action.payload;
+    const metaData = action.metaData;
+
+    refetchUseCase.execute({
+      dispatch,
+      actionName,
+      apiName,
+      props,
+      metaData
+    });
+  };
+}

package/src/platform/zrecord/adapters/controllers/SuccessController.ts

@@ -0,0 +1,21 @@
+import IController from '@cc/architecture/IController';
+import IService from '../../usecases/interfaces/gateways/IService';
+
+export default class SuccessController implements IController<any> {
+  constructor(private service: IService) {}
+
+  handle = (event) => {
+    const { state, updateState } = event;
+    const { action, dispatch } = event;
+    const { metaData, payload } = action;
+    const { response } = payload;
+    const { successUseCase } = this.service;
+    successUseCase.updateDependency(state, updateState);
+
+    successUseCase.execute({
+      dispatch,
+      response,
+      metaData
+    });
+  };
+}

package/src/platform/zrecord/adapters/gateways/Repository.ts

@@ -0,0 +1,23 @@
+import IRepository from '../../usecases/interfaces/gateways/IRepository';
+import RecordsManagerFactory from '../../usecases/entities-factory/RecordsManagerFactory';
+import { ITemplateHelpers } from '../../usecases/interfaces/gateways/ITemplateHelpers';
+import { State } from '../../usecases/interfaces/gateways/State';
+
+export default class Repository implements IRepository {
+  private state: State;
+  init(state: State) {
+    this.state = state;
+  }
+
+  getRecordsManagerEntity(templateHelpers: ITemplateHelpers) {
+    const { zrecord } = this.state.behaviours;
+    const { apiTemplates, records = [], hasMore, isFetching } = zrecord;
+
+    const recordManager = RecordsManagerFactory.create(
+      apiTemplates,
+      { data: records, hasMore, isFetching },
+      templateHelpers
+    );
+    return recordManager;
+  }
+}

package/src/platform/zrecord/adapters/gateways/Service.ts

@@ -0,0 +1,42 @@
+import IService from '../../usecases/interfaces/gateways/IService';
+
+import InputDependencies from '../../usecases/interfaces/InputDependencies';
+import InitializeUseCase from '../../usecases/interactors/InitializeUseCase';
+import ExecuteActionUseCase from '../../usecases/interactors/ExecuteActionUseCase';
+import FailureUseCase from '../../usecases/interactors/FailureUseCase';
+import SuccessUseCase from '../../usecases/interactors/SuccessUseCase';
+import RefetchUseCase from '../../usecases/interactors/RefetchUseCase';
+import NoContentUseCase from '../../usecases/interactors/NoContentUseCase';
+import FetchMoreUseCase from '../../usecases/interactors/FetchMoreUseCase';
+import RecordUpdateLocalUseCase from '../../usecases/interactors/RecordUpdateLocalUseCase';
+import DeleteMultipleRecordUseCase from '../../usecases/interactors/DeleteMultipleRecordUseCase';
+import AppendRecordsUseCase from '../../usecases/interactors/AppendRecordsUseCase';
+import FieldChangeUseCase from '../../usecases/interactors/FieldChangeUseCase';
+
+export default class Service implements IService {
+  initializeUseCase: InitializeUseCase;
+  executeUseCase: ExecuteActionUseCase;
+  failureUseCase: FailureUseCase;
+  successUseCase: SuccessUseCase;
+  refetchUseCase: RefetchUseCase;
+  noContentUseCase: NoContentUseCase;
+  appendRecordsUseCase: AppendRecordsUseCase;
+  fieldChangeUseCase: FieldChangeUseCase;
+  fetchMoreUseCase: FetchMoreUseCase;
+  recordUpdateLocalUseCase: RecordUpdateLocalUseCase;
+  deleteMultipleRecordUseCase: DeleteMultipleRecordUseCase;
+
+  constructor(dependencies: InputDependencies) {
+    this.initializeUseCase = new InitializeUseCase(dependencies);
+    this.executeUseCase = new ExecuteActionUseCase(dependencies);
+    this.failureUseCase = new FailureUseCase(dependencies);
+    this.successUseCase = new SuccessUseCase(dependencies);
+    this.refetchUseCase = new RefetchUseCase(dependencies);
+    this.noContentUseCase = new NoContentUseCase(dependencies);
+    this.appendRecordsUseCase = new AppendRecordsUseCase(dependencies);
+    this.fieldChangeUseCase = new FieldChangeUseCase(dependencies);
+    this.fetchMoreUseCase = new FetchMoreUseCase(dependencies);
+    this.recordUpdateLocalUseCase = new RecordUpdateLocalUseCase(dependencies);
+    this.deleteMultipleRecordUseCase = new DeleteMultipleRecordUseCase(dependencies);
+  }
+}

package/src/platform/zrecord/adapters/gateways/TemplateHelpers.ts

@@ -0,0 +1,37 @@
+import { ITemplateHelpers } from '../../usecases/interfaces/gateways/ITemplateHelpers';
+
+export default class TemplateHelpers implements ITemplateHelpers {
+  private getPathValue(path: string, obj: any): any {
+    return path.split('.').reduce(function (prev, curr) {
+      return prev ? prev[curr] : undefined;
+    }, obj);
+  }
+
+  replaceTemplateVariables(inputString: string, replacementObj: any): string {
+    return inputString.replace(/{{(.*?)}}/g, (match: string, key: string) => {
+      let value = this.getPathValue(key.trim(), replacementObj);
+      if(Array.isArray(value) || value instanceof Object) {
+        return JSON.stringify(value)
+      }
+      return value !== undefined ? value : match;
+    });
+  }
+
+  objectToQueryString(obj: any): string {
+    return Object.keys(obj)
+      .map(
+        (key: string) =>
+          encodeURIComponent(key) + '=' + encodeURIComponent(obj[key])
+      )
+      .join('&');
+  }
+
+  constructQueryString(inputString: string, replacementObj: any): string {
+    const replacedString = this.replaceTemplateVariables(
+      inputString,
+      replacementObj
+    );
+    const parsedObj = JSON.parse(replacedString);
+    return this.objectToQueryString(parsedObj);
+  }
+}

package/src/platform/zrecord/adapters/presenters/Presenter.ts

@@ -0,0 +1,23 @@
+import IPresenter from '../../usecases/interfaces/output/IPresenter';
+
+export default class Presenter implements IPresenter {
+  private updateState: Function;
+  private state: any;
+
+  updateDependencies(state: any, updateState: Function) {
+    this.updateState = updateState;
+    this.state = state;
+  }
+
+  updateRecord(zrecord): void {
+    this.state = {
+      ...this.state,
+      behaviours: { ...this.state.behaviours, zrecord }
+    };
+    this.updateState(this.state);
+  }
+
+  updateAPITemplates(apiTemplates) {
+    this.updateRecord({ apiTemplates });
+  }
+}

package/src/platform/zrecord/entities/APITemplate.ts

@@ -0,0 +1,68 @@
+import IAPITemplate from './interfaces/IAPITemplate';
+import { API_METHODS_ENUM } from './interfaces/apiEnum';
+import { APITemplateModel } from './interfaces/APITemplateModel';
+import { APIDetailsModel } from './interfaces/APIDetailsModel';
+import { ITemplateHelpers } from './interfaces/ITemplateHelpers';
+
+class APITemplate implements IAPITemplate {
+  private input: APITemplateModel;
+  private api: string;
+  private payload: string;
+  private parameters: string;
+  private type: API_METHODS_ENUM;
+  private helper: ITemplateHelpers;
+
+  constructor(input: APITemplateModel, templateHelpers: ITemplateHelpers) {
+    this.input = input;
+    this.api = input.api;
+    this.payload = input.requestBody;
+    this.parameters = input.parameters;
+    this.type = input.type;
+    this.helper = templateHelpers;
+  }
+  private getApi(obj: any) {
+    return this.helper.replaceTemplateVariables(this.api, obj);
+  }
+  private getPayload(obj: any) {
+    if (this.payload) {
+      return this.helper.replaceTemplateVariables(this.payload, obj);
+    } else {
+      return `{}`;
+    }
+  }
+  private getParameter(obj: any) {
+    if (this.parameters) {
+      return this.helper.replaceTemplateVariables(this.parameters, obj);
+    } else {
+      return `""`;
+    }
+  }
+
+  private constructURL(obj: any): string {
+    const queryObj = JSON.parse(this.getParameter(obj));
+    const query = this.helper.objectToQueryString(queryObj);
+    if (query === '') {
+      return this.getApi(obj);
+    }
+    return `${this.getApi(obj)}?${query}`;
+  }
+
+  public getApiDetails(obj: any): APIDetailsModel {
+    return {
+      url: this.constructURL(obj),
+      type: this.type,
+      method: this.type,
+      payload: this.getPayload(obj)
+    };
+  }
+
+  public getTransformer() {
+    return this.input.transformer;
+  }
+
+  public toObject(): APITemplateModel {
+    return this.input;
+  }
+}
+
+export default APITemplate;

package/src/platform/zrecord/entities/APITemplates.ts

@@ -0,0 +1,22 @@
+import IAPITemplate from './interfaces/IAPITemplate';
+import IAPITemplates from './interfaces/IAPITemplates';
+import { APITemplatesModel } from './interfaces/APITemplatesModel';
+
+class APITemplates implements IAPITemplates {
+  constructor(private apiTemplates: Map<string, IAPITemplate>) {}
+  getAPITemplateByName(name: string): IAPITemplate {
+    return this.apiTemplates.get(name);
+  }
+  getApiDetails(actionName: string, props) {
+    return this.getAPITemplateByName(actionName).getApiDetails(props);
+  }
+
+  toObject(): APITemplatesModel {
+    const output: APITemplatesModel = {};
+    this.apiTemplates.forEach((record, apiName) => {
+      output[apiName] = record.toObject();
+    });
+    return output;
+  }
+}
+export default APITemplates;

package/src/platform/zrecord/entities/CustomFieldValues.ts

@@ -0,0 +1,30 @@
+import ICustomFieldValues from './interfaces/ICustomFieldValues';
+
+import { FieldValue, RecordCustomFieldsValue } from './interfaces/RecordModel';
+
+export default class CustomFieldValues implements ICustomFieldValues {
+  private fieldsMap: Map<string, FieldValue>;
+  constructor(fieldsMap: RecordCustomFieldsValue) {
+    this.fieldsMap = new Map(Object.entries(fieldsMap || {}));
+  }
+
+  getFieldValueByName(name: string): FieldValue {
+    return this.fieldsMap.get(name);
+  }
+
+  hasField(name: string): boolean {
+    return this.fieldsMap.has(name);
+  }
+
+  setFieldValueByName(name: string, value: FieldValue) {
+    this.fieldsMap.set(name, value);
+  }
+
+  toObject(): RecordCustomFieldsValue {
+    const fields: RecordCustomFieldsValue = {};
+    this.fieldsMap.forEach((value, key) => {
+      fields[key] = value;
+    });
+    return fields;
+  }
+}

package/src/platform/zrecord/entities/Property.ts

@@ -0,0 +1,26 @@
+import { IProperty } from "./interfaces/IProperties";
+
+class Property implements IProperty {
+  private name: string;
+  private required: boolean;
+  private defaultValue: any;
+  private label?: string;
+  private typeMetadata: { schema: JSON };
+  private value: any;
+  getRequired(): boolean {
+    return this.required;
+  }
+  getName(): string {
+    return this.name;
+  }
+  getDefaultValue(): string {
+    return this.defaultValue;
+  }
+  getTypeMetadata() {
+    return this.typeMetadata;
+  }
+  getValue() {
+    return this.value == undefined ? this.defaultValue : this.value;
+  }
+}
+export default Property;

package/src/platform/zrecord/entities/Record.ts

@@ -0,0 +1,62 @@
+import CustomFieldValues from './CustomFieldValues';
+import IRecord from './interfaces/IRecord';
+import { LookupFieldValue, RecordModel } from './interfaces/RecordModel';
+
+export default class Record implements IRecord {
+  private id: string;
+  private owner?: LookupFieldValue;
+  private modifiedTime?: string;
+  private createdTime: string;
+  private name: string;
+  private cf: CustomFieldValues;
+  private layout?: LookupFieldValue;
+  private modifiedBy?: LookupFieldValue;
+  private createdBy?: LookupFieldValue;
+  // NOTE: input is used to keep the original value of the record
+  // In case of record Format will not be use
+  private input: RecordModel;
+
+  constructor(recordObj: RecordModel) {
+    this.input = recordObj;
+    this.id = recordObj.id;
+    this.owner = recordObj.owner;
+    this.modifiedTime = recordObj.modifiedTime;
+    this.createdTime = recordObj.createdTime;
+    this.name = recordObj.name;
+    this.layout = recordObj.layout;
+    this.modifiedBy = recordObj.modifiedBy;
+    this.createdBy = recordObj.createdBy;
+    this.cf = new CustomFieldValues(recordObj.cf);
+  }
+
+  updateField(fieldName: string, value) {
+    if (this.cf.hasField(fieldName)) {
+      // NOTE: this.input is used to keep the original value of the record
+      // In case of a rollback, we can use this.input to restore the original value
+      // this.input.cf is used to keep the original value of the custom field
+      this.input.cf[fieldName] = value;
+      this.cf.setFieldValueByName(fieldName, value);
+      return;
+    }
+    this[fieldName] = value;
+    this.input[fieldName] = value;
+  }
+
+  toObject(): RecordModel {
+    return this.input
+    return {
+      id: this.id,
+      owner: this.owner,
+      modifiedTime: this.modifiedTime,
+      createdTime: this.createdTime,
+      name: this.name,
+      cf: this.cf.toObject(),
+      layout: this.layout,
+      modifiedBy: this.modifiedBy,
+      createdBy: this.createdBy
+    };
+  }
+  getId() {
+    return this.id;
+  }
+}

package/src/platform/zrecord/entities/Records.ts

@@ -0,0 +1,83 @@
+import IRecords from './interfaces/IRecords';
+import Record from './Record';
+import { RecordsModel } from './interfaces/RecordsModel';
+
+export default class Records implements IRecords {
+  private records: Record[];
+  private isFetching: boolean;
+  private hasMore: boolean;
+  private fetchLimit: number;
+
+  constructor({ data, isFetching, hasMore }: RecordsModel, fetchLimit: number = 25) {
+    this.records = data.map(obj => new Record(obj));
+    this.hasMore = hasMore;
+    this.fetchLimit = fetchLimit;
+    this.isFetching = isFetching;
+  }
+
+  public canFetchMore() {
+    return this.hasMore;
+  }
+
+  public getIsFetching(): boolean {
+    return this.isFetching;
+  }
+
+  public setHasMore(hasMore: boolean) {
+    this.hasMore = hasMore;
+  }
+
+  public setIsFetching(isFetching: boolean) {
+    this.isFetching = isFetching;
+  }
+
+  public setRecords(records: Record[]) {
+    this.records = records;
+  }
+
+  updateHasMore(recordsLength: number): void {
+    this.hasMore = recordsLength >= this.fetchLimit;
+  }
+
+  getRecordsLength(): number {
+    return this.records.length;
+  }
+
+  hasMoreRecords(): boolean {
+    return this.hasMore;
+  }
+
+  isRecordsFetching(): boolean {
+    return this.isFetching;
+  }
+
+  public appendRecords(records: Record[]) {
+    this.records = [...this.records, ...records];
+  }
+
+  public updateRecordField({ fieldName, recordId, value }) {
+    const record = this.records.find(record => record.getId() === recordId);
+    if (!record) return;
+    record.updateField(fieldName, value);
+  }
+
+  deleteMultipleRecord(recordIds: string[]) {
+    this.records = this.records.filter(r => !recordIds.includes(r.getId()));
+  }
+
+  public updateRecord(recordId, record) {
+    this.records = this.records.map(r => (r.getId() === recordId ? record : r));
+  }
+
+  getRecord(index: number): Record {
+    return this.records[index];
+  }
+
+  toObject(): RecordsModel {
+    return {
+      data: this.records.map(record => record.toObject()),
+      hasMore: this.hasMore,
+      isFetching: this.isFetching
+    };
+  }
+}