@zohodesk/library-platform 1.0.0-exp.1

package/src/platform/zfield/adapters/controllers/ExeucteActionController.ts

@@ -0,0 +1,24 @@
+import IService from "../../usecases/interfaces/gateways/IService";
+import AbstractController from './AbstractController';
+
+class ExecuteActionController extends AbstractController {
+  // TODO: Add event type
+  handle(event): void {
+    const { state, updateState, action, dispatch } = event;
+    const { executeUseCase } = this.service;
+    const { actionName, props, apiName } = action.payload;
+    const { metaData } = action;
+
+    executeUseCase.updateDependencies(state, updateState);
+
+    executeUseCase.execute({
+      dispatch,
+      props,
+      apiName, // availableFields
+      actionName, // getAvailableFields
+      metaData
+    });
+  }
+}
+
+export default ExecuteActionController;

package/src/platform/zfield/adapters/controllers/FetchFailureController.ts

@@ -0,0 +1,16 @@
+import AbstractController from "./AbstractController";
+
+class FetchFailureController extends AbstractController {
+  // TODO: Add event type
+  handle(event): void {
+    const { state, updateState, action, dispatch } = event;
+    const { metaData, payload } = action;
+    const { error, apiName } = payload;
+    const { fetchFailureUseCase } = this.service;
+    
+    fetchFailureUseCase.updateDependencies(state, updateState);
+    fetchFailureUseCase.execute({ dispatch, error, metaData, apiName });
+  }
+}
+
+export default FetchFailureController;

package/src/platform/zfield/adapters/controllers/FetchNoContentController.ts

@@ -0,0 +1,16 @@
+import AbstractController from "./AbstractController";
+
+class FetchNoContentController extends AbstractController {
+  // TODO: Add event type
+  handle(event): void {
+    const { state, updateState, action, dispatch } = event;
+    const { metaData, payload } = action;
+    const { apiName } = payload;
+    const { fetchNoContentUseCase } = this.service;
+    
+    fetchNoContentUseCase.updateDependencies(state, updateState);
+    fetchNoContentUseCase.execute({ dispatch, metaData, apiName });
+  }
+}
+
+export default FetchNoContentController;

package/src/platform/zfield/adapters/controllers/FetchSuccessController.ts

@@ -0,0 +1,16 @@
+import AbstractController from "./AbstractController";
+
+class FetchSuccessController extends AbstractController {
+  // TODO: Add event type
+  handle(event): void {
+    const { state, updateState, action, dispatch } = event;
+    const { metaData, payload } = action;
+    const { response, apiName } = payload;
+    const { fetchSuccessUseCase } = this.service;
+    
+    fetchSuccessUseCase.updateDependencies(state, updateState);
+    fetchSuccessUseCase.execute({ dispatch, response, metaData, apiName });
+  }
+}
+
+export default FetchSuccessController;

package/src/platform/zfield/adapters/controllers/InitializeController.ts

@@ -0,0 +1,20 @@
+import { HttpTemplates } from '@platform/data-broker/dbc';
+import IService from "../../usecases/interfaces/gateways/IService";
+import AbstractController from './AbstractController';
+
+class InitializeController extends AbstractController {
+  constructor(service: IService, private apiDetails: HttpTemplates) {
+    super(service);
+  }
+
+  // TODO: Add event type
+  handle(event): void {
+    const { state, updateState } = event;
+    const { initializeUseCase } = this.service;
+
+    initializeUseCase.updateDependencies(state, updateState);
+    initializeUseCase.execute({ apiTemplates: this.apiDetails });
+  }
+}
+
+export default InitializeController;

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

@@ -0,0 +1,16 @@
+import AbstractController from "./AbstractController";
+
+class RefetchController extends AbstractController {
+  // TODO: Add event type
+  handle(event): void {
+    const { state, updateState, action, dispatch } = event;
+    const { metaData, payload } = action;
+    const { apiName } = payload;
+    const { refetchUseCase } = this.service;
+    
+    refetchUseCase.updateDependencies(state, updateState);
+    refetchUseCase.execute({ dispatch, metaData, apiName });
+  }
+}
+
+export default RefetchController;

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

@@ -0,0 +1,32 @@
+import IRepository from '../../usecases/interfaces/gateways/IRepository';
+import FieldsManagerBuilder from '../../usecases/entity-factory/FieldsManagerBuilder';
+import State from "../../entities/interfaces/BehaviourState";
+import FieldsManager from '../../entities/fields-manager/FieldsManager';
+
+class Repository implements IRepository {
+  private state: State;
+
+  init(state: State): void {
+    this.state = state;
+  }
+
+  getFieldManager(): FieldsManager {
+    const {
+      fields,
+      selectedFields,
+      isFieldsFetching,
+      isSelectedFieldsFetching,
+      apiTemplate
+    } = this.state.behaviours.zfield;
+
+    return new FieldsManagerBuilder()
+      .setAvailableFields(fields)
+      .setSelectedFields(selectedFields)
+      .setAvailableFieldsFetchingStatus(isFieldsFetching)
+      .setSelectedFieldsFetchingStatus(isSelectedFieldsFetching)
+      .setApiTemplate(apiTemplate)
+      .build();
+  }
+}
+
+export default Repository;

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

@@ -0,0 +1,28 @@
+import ExecuteActionUseCase from '../../usecases/interactors/ExecuteActionUseCase';
+import FetchNoContentUseCase from '../../usecases/interactors/FetchNoContentUseCase';
+import FetchSuccessUseCase from '../../usecases/interactors/FetchSuccessUseCase';
+import RefetchUseCase from '../../usecases/interactors/RefetchUseCase';
+import InitializeUseCase from '../../usecases/interactors/InitializeUseCase';
+import IService from '../../usecases/interfaces/gateways/IService';
+import UsecaseDependencies from '../../usecases/interfaces/UsecaseDependencies';
+import FetchFailureUseCase from '../../usecases/interactors/FetchFailureUseCase';
+
+class Service implements IService {
+  initializeUseCase: InitializeUseCase;
+  executeUseCase: ExecuteActionUseCase;
+  fetchSuccessUseCase: FetchSuccessUseCase;
+  fetchFailureUseCase: FetchFailureUseCase;
+  fetchNoContentUseCase: FetchNoContentUseCase;
+  refetchUseCase: RefetchUseCase;
+
+  constructor(dependencies: UsecaseDependencies) {
+    this.initializeUseCase = new InitializeUseCase(dependencies);
+    this.executeUseCase = new ExecuteActionUseCase(dependencies);
+    this.fetchSuccessUseCase = new FetchSuccessUseCase(dependencies);
+    this.fetchFailureUseCase = new FetchFailureUseCase(dependencies);
+    this.fetchNoContentUseCase = new FetchNoContentUseCase(dependencies);
+    this.refetchUseCase = new RefetchUseCase(dependencies);
+  }
+}
+
+export default Service;

package/src/platform/zfield/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/zfield/adapters/presenters/Presenter.ts

@@ -0,0 +1,32 @@
+import IPresenter from '../../usecases/interfaces/output/IPresenter';
+import State from '../../entities/interfaces/BehaviourState';
+import { GetTemplate } from '@platform/data-broker/dbc';
+
+class Presenter implements IPresenter {
+  private updateState: Function;
+  private state: any;
+
+  updateDependencies(state: any, updateState: Function): void {
+    this.state = state;
+    this.updateState = updateState;
+  }
+
+  updateFields(fieldState: State): void {
+    this.updateState({
+      ...this.state,
+      behaviours: {
+        ...this.state.behaviours,
+        zfield: fieldState
+      }
+    });
+  }
+
+  updateApiTemplate(apiTemplate: GetTemplate): void {
+    this.updateFields({
+      ...this.state.behaviours?.zfield,
+      apiTemplate
+    });
+  }
+}
+
+export default Presenter;

package/src/platform/zfield/entities/BooleanField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class BooleanField extends Field<boolean> { }
+export default BooleanField;

package/src/platform/zfield/entities/CurrencyField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class CurrencyField extends Field<number> { }
+export default CurrencyField;

package/src/platform/zfield/entities/DateField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class DateField extends Field<Date> { }
+export default DateField;

package/src/platform/zfield/entities/DateTimeField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class DateTimeField extends Field<Date> { }
+export default DateTimeField;

package/src/platform/zfield/entities/EmailField.ts

@@ -0,0 +1,6 @@
+import Field from "./Field";
+
+type EmailModel = string;
+
+class EmailField extends Field<EmailModel> { }
+export default EmailField;

package/src/platform/zfield/entities/Field.ts

@@ -0,0 +1,45 @@
+import FieldModel from "./interfaces/FieldModel";
+import IField from "./interfaces/IField";
+
+abstract class Field<T> implements IField {
+  constructor(
+    private id: string,
+    private type: string,
+    private name: string,
+    private displayLabel: string,
+    private isCustomField: boolean,
+    private i18NLabel: string,
+    private isSortable: boolean,
+    private isVisible: boolean,
+    private isReadOnly: boolean,
+    private isEncryptedField: boolean,
+    private isPHI: boolean,
+    private maxLength: number,
+    private isMandatory: boolean,
+    protected value: T
+  ) { }
+
+  public getId(): string {
+    return this.id;
+  }
+  
+  toObject() {
+    return {
+      id: this.id,
+      type: this.type,
+      name: this.name,
+      displayLabel: this.displayLabel,
+      isCustomField: this.isCustomField,
+      i18NLabel: this.i18NLabel,
+      isSortable: this.isSortable,
+      isVisible: this.isVisible,
+      isReadOnly: this.isReadOnly,
+      isEncryptedField: this.isEncryptedField,
+      isPHI: this.isPHI,
+      maxLength: this.maxLength,
+      isMandatory: this.isMandatory,
+      value: this.value
+    };
+  }
+}
+export default Field;

package/src/platform/zfield/entities/LookupField.ts

@@ -0,0 +1,12 @@
+import Field from "./Field";
+
+type LookupFieldValue = {
+  id: string;
+  firstName?: string;
+  lastName?: string;
+  photoURL?: string;
+};
+
+class LookupField extends Field<LookupFieldValue> { }
+
+export default LookupField;

package/src/platform/zfield/entities/MultiLineField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class MultiLineField extends Field<string> { }
+export default MultiLineField;

package/src/platform/zfield/entities/MultiSelectField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class MultiSelectField extends Field<string[]> { }
+export default MultiSelectField;

package/src/platform/zfield/entities/PercentageField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class PercentageField extends Field<number> { }
+export default PercentageField;

package/src/platform/zfield/entities/PhoneField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class PhoneField extends Field<string> { }
+export default PhoneField;

package/src/platform/zfield/entities/PickListField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class PickListField extends Field<string> { }
+export default PickListField;

package/src/platform/zfield/entities/SingleLineField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class SingleLineField extends Field<string> { }
+export default SingleLineField;

package/src/platform/zfield/entities/URLField.ts

@@ -0,0 +1,4 @@
+import Field from "./Field";
+
+class URLField extends Field<string> { }
+export default URLField;

package/src/platform/zfield/entities/api-template/APITemplate.ts

@@ -0,0 +1,72 @@
+import IAPITemplate from '../interfaces/api-template/IAPITemplate';
+
+import {
+  API_METHODS,
+  APITemplateModel,
+  APIDetailsModel
+} from '../interfaces/api-template/APIModels';
+import { ITemplateHelpers } from '../interfaces/api-template/ITemplateHelpers';
+
+class APITemplate implements IAPITemplate {
+  private input: APITemplateModel;
+  private api: string;
+  private payload: string;
+  private parameters: string;
+  private type: API_METHODS;
+  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 = API_METHODS[input.type];
+    this.helper = templateHelpers;
+  }
+
+  private getApi(obj: any) {
+    return this.helper.replaceTemplateVariables(this.api, obj);
+  }
+
+  private getPayload(obj: any) {
+    if (this.payload) {
+      return JSON.parse(
+        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);
+    return `${this.getApi(obj)}?${query}`;
+  }
+
+  getApiDetails(obj: any): APIDetailsModel {
+    return {
+      url: this.constructURL(obj),
+      type: this.type,
+      payload: this.getPayload(obj)
+    };
+  }
+
+  getTransformer() {
+    return this.input.transformer;
+  }
+
+  toObject(): APITemplateModel {
+    return this.input;
+  }
+}
+
+export default APITemplate;

package/src/platform/zfield/entities/api-template/APITemplates.ts

@@ -0,0 +1,22 @@
+import { APITemplatesModel } from "../interfaces/api-template/ApiModels";
+import IAPITemplate from "../interfaces/api-template/IAPITemplate";
+import IAPITemplates from "../interfaces/api-template/IAPITemplates";
+
+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/zfield/entities/fields-manager/AvailableFieldsManager.ts

@@ -0,0 +1,86 @@
+import { FETCH } from "@bc/zhttp/Constants";
+import { FIELD_FETCH, FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS, FIELD_REFETCH } from "@bc/zfield/Constants";
+import { AvailableFieldsState } from "../interfaces/BehaviourState";
+import IFieldsManager from "../interfaces/IFieldManger";
+import MetaData from "../interfaces/MetaData";
+
+class AvailableFieldsManager implements IFieldsManager<AvailableFieldsState> {
+  constructor(
+    private availableFields: any,
+    private isAvailableFieldsFetching: boolean
+  ) {}
+  
+  startFetching(): void {
+    this.isAvailableFieldsFetching = true;
+  }
+  stopFetching(): void {
+    this.isAvailableFieldsFetching = false;
+  }
+  resetFields(): void {
+    this.availableFields = [];
+  }
+  isFieldFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH] && metaData.apiName === 'availableFields';
+  }
+  isFieldRefetching(metaData: MetaData): boolean {
+    return metaData[FIELD_REFETCH] && metaData.apiName === 'availableFields';
+  }
+  isFieldSuccessFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_SUCCESS] && metaData.apiName === 'availableFields';
+  }
+  isFieldFailureFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_FAILURE] && metaData.apiName === 'availableFields';
+  }
+  isFieldNoContentFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_NO_CONTENT] && metaData.apiName === 'availableFields';
+  }
+  mergeMetaData(metaData: MetaData, apiName: string, actionName: string): MetaData {
+    return {
+      ...metaData,
+      apiName,
+      actionName
+    };
+  }
+  createFieldsSuccessAction(metaData: MetaData, availableFields: any): any {
+    const { type, payload } = metaData[FIELD_FETCH_SUCCESS];
+    return {
+      type,
+      payload: {
+        payloadFromMeta: payload,
+        fields: availableFields
+      }
+    };
+  }
+  createFieldsFailureAction(metaData: MetaData, error): any {
+    const { type, payload } = metaData[FIELD_FETCH_FAILURE];
+    return {
+      type,
+      payload: {
+        payloadFromMeta: payload,
+        error
+      }
+    };
+  }
+  createFieldsNoContentAction(metaData: MetaData): any {
+    const { type, payload } = metaData[FIELD_FETCH_NO_CONTENT];
+    return {
+      type,
+      payload
+    };
+  }
+  createFieldsFetchingAction(metaData: MetaData, apiDetails): any {
+    return {
+      type: FETCH,
+      payload: apiDetails,
+      metaData
+    }
+  }
+  toObject(): AvailableFieldsState {
+    return {
+      fields: this.availableFields,
+      isAvailableFieldsFetching: this.isAvailableFieldsFetching
+    }
+  }
+}
+
+export default AvailableFieldsManager;