@zohodesk/library-platform 1.0.0 → 1.0.2-exp.1.0

package/es/platform/zfield/domain/entities/Field.ts

@@ -0,0 +1,44 @@
+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/es/platform/zfield/domain/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/es/platform/zfield/domain/entities/MultiLineField.ts

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

package/es/platform/zfield/domain/entities/MultiSelectField.ts

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

package/es/platform/zfield/domain/entities/PercentageField.ts

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

package/es/platform/zfield/domain/entities/PhoneField.ts

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

package/es/platform/zfield/domain/entities/PickListField.ts

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

package/es/platform/zfield/domain/entities/SingleLineField.ts

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

package/es/platform/zfield/domain/entities/URLField.ts

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

package/es/platform/zfield/domain/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;

package/es/platform/zfield/domain/entities/fields-manager/FieldsManager.ts

@@ -0,0 +1,92 @@
+import IField from '../interfaces/IField';
+import { FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS } from '@bc/zfield/Constants';
+import FieldApiName from '../interfaces/FieldApiName';
+import { BehaviourState, SelectedFields } from '../interfaces/BehaviourState';
+import IFieldManager from '../interfaces/IFieldManger';
+import MetaData from '../interfaces/MetaData';
+import { DATA_SOURCE_EXECUTE } from '@bc/zdata-source/Constants';
+import { DATA_SOURCE_SUCCESS } from '@bc/zdata-source/Symbols';
+
+class FieldManager implements IFieldManager {
+  constructor(
+    private fields: IField[],
+    private selectedFields: SelectedFields,
+    private isFieldsFetching: boolean,
+    private isSelectedFieldsFetching: boolean
+  ) {}
+
+  createSuccessAction(fields: IField[], metaData: MetaData) {
+    return {
+      type: FIELD_FETCH_SUCCESS,
+      payload: { fields },
+      metaData
+    };
+  }
+
+  createFailureAction(error: any, metaData: MetaData) {
+    return {
+      type: FIELD_FETCH_FAILURE,
+      payload: { error },
+      metaData
+    };
+  }
+
+  createNoContentAction(metaData: MetaData) {
+    return {
+      type: FIELD_FETCH_NO_CONTENT,
+      payload: {},
+      metaData
+    };
+  }
+
+  createDataSourceExecuteEvent(props: any, apiName: FieldApiName) {
+    return {
+      type: DATA_SOURCE_EXECUTE,
+      payload: {
+        props,
+        actionName: apiName
+      },
+      metaData: { actionName: apiName, [DATA_SOURCE_SUCCESS]: { metaData: { apiName } } }
+    };
+  }
+
+  isFieldFetching(metaData: MetaData): boolean {
+    const { apiName } = metaData;
+    return apiName === 'availableFields' || apiName === 'selectedFields';
+  }
+
+  startFetching(apiName: FieldApiName) {
+    if (apiName === 'availableFields') {
+      this.isFieldsFetching = true;
+    } else if (apiName === 'selectedFields') {
+      this.isSelectedFieldsFetching = true;
+    }
+  }
+
+  stopFetching(apiName: FieldApiName) {
+    if (apiName === 'availableFields') {
+      this.isFieldsFetching = false;
+    } else if (apiName === 'selectedFields') {
+      this.isSelectedFieldsFetching = false;
+    }
+  }
+
+  setFields(data: any, apiName: FieldApiName): void {
+    if (apiName === FieldApiName.AVAILABLE_FIELDS) {
+      this.fields = data;
+    } else if (apiName === FieldApiName.SELECTED_FIELDS) {
+      this.selectedFields = data;
+    }
+  }
+
+  toObject(): BehaviourState {
+    return {
+      fields: this.fields,
+      selectedFields: this.selectedFields,
+      isFieldsFetching: this.isFieldsFetching,
+      isSelectedFieldsFetching: this.isSelectedFieldsFetching
+    };
+  }
+}
+
+export default FieldManager;

package/es/platform/zfield/domain/entities/fields-manager/SelectedFieldsManager.ts

@@ -0,0 +1,87 @@
+import { FIELD_FETCH, FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS, FIELD_REFETCH } from "@bc/zfield/Constants";
+import { SelectedFieldsState } from "../interfaces/BehaviourState";
+import IFieldsManager from "../interfaces/IFieldManger";
+import MetaData from "../interfaces/MetaData";
+import { FETCH } from "@bc/zhttp/Constants";
+
+class SelectedFieldsManager implements IFieldsManager<SelectedFieldsState> {
+  constructor(
+    private selectedFields: any,
+    private isSelectedFieldsFetching: boolean
+  ) {}
+
+  startFetching(): void {
+    this.isSelectedFieldsFetching = true;
+  }
+  stopFetching(): void {
+    this.isSelectedFieldsFetching = false;
+  }
+  resetFields(): void {
+    this.selectedFields = [];
+  }
+
+  isFieldFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH] && metaData.apiName === 'selectedFields';
+  }
+  isFieldRefetching(metaData: MetaData): boolean {
+    return metaData[FIELD_REFETCH] && metaData.apiName === 'selectedFields';
+  }
+  isFieldSuccessFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_SUCCESS] && metaData.apiName === 'selectedFields';
+  }
+  isFieldFailureFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_FAILURE] && metaData.apiName === 'selectedFields';
+  }
+  isFieldNoContentFetching(metaData: MetaData): boolean {
+    return metaData[FIELD_FETCH_NO_CONTENT] && metaData.apiName === 'selectedFields';
+  }
+  mergeMetaData(metaData: MetaData, apiName: string, actionName: string): MetaData {
+    return {
+      ...metaData,
+      apiName,
+      actionName
+    };
+  }
+  createFieldsSuccessAction(metaData: MetaData, selectedFields: any): any {
+    const { type, payload } = metaData[FIELD_FETCH_SUCCESS];
+    return {
+      type,
+      payload: {
+        payloadFromMeta: payload,
+        fields: selectedFields
+      }
+    };
+  }
+  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(): SelectedFieldsState {
+    return {
+      selectedFields: this.selectedFields,
+      isSelectedFieldsFetching: this.isSelectedFieldsFetching
+    }
+  }
+}
+
+export default SelectedFieldsManager;

package/es/platform/zfield/domain/entities/index.ts

@@ -0,0 +1,15 @@
+export { default as Field } from './Field';
+
+export { default as BooleanField } from './BooleanField';
+export { default as SingleLineField } from './SingleLineField';
+export { default as MultiLineField } from './MultiLineField';
+export { default as URLField } from './URLField';
+export { default as EmailField } from './EmailField';
+export { default as PhoneField } from './PhoneField';
+export { default as CurrencyField } from './CurrencyField';
+export { default as PercentageField } from './PercentageField';
+export { default as DateField } from './DateField';
+export { default as DateTimeField } from './DateTimeField';
+export { default as PickListField } from './PickListField';
+export { default as MultiSelectField } from './MultiSelectField';
+export { default as LookupField } from './LookupField';

package/es/platform/zfield/domain/entities/interfaces/ActionModel.ts

@@ -0,0 +1,7 @@
+type ActionModel<T> = {
+  type: string;
+  payload: T;
+  metaData?: any;
+}
+
+export default ActionModel;

package/es/platform/zfield/domain/entities/interfaces/BehaviourState.ts

@@ -0,0 +1,18 @@
+import IField from './IField';
+
+export type SelectedFields = string[];
+
+export type BehaviourState = {
+  fields: IField[];
+  selectedFields: SelectedFields;
+  isFieldsFetching: boolean;
+  isSelectedFieldsFetching: boolean;
+};
+
+type State = {
+  behaviours: {
+    zfield: BehaviourState;
+  };
+};
+
+export default State;

package/es/platform/zfield/domain/entities/interfaces/FieldApiName.ts

@@ -0,0 +1,6 @@
+enum FieldApiName {
+  AVAILABLE_FIELDS = 'availableFields',
+  SELECTED_FIELDS = 'selectedFields'
+}
+
+export default FieldApiName;

package/es/platform/zfield/domain/entities/interfaces/FieldModel.ts

@@ -0,0 +1,18 @@
+type FieldModel = {
+  id: string;
+  type: string;
+  uiType?: string;
+  name: string;
+  displayLabel: string;
+  isCustomField: boolean;
+  i18NLabel: string;
+  isSortable: boolean;
+  isVisible: boolean;
+  isReadOnly: boolean;
+  isEncryptedField: boolean;
+  isPHI: boolean;
+  maxLength: number;
+  isMandatory: boolean;
+};
+
+export default FieldModel;

package/es/platform/zfield/domain/entities/interfaces/IField.ts

@@ -0,0 +1,6 @@
+interface IField {
+  getId(): string;
+  toObject(): any;
+}
+
+export default IField;

package/es/platform/zfield/domain/entities/interfaces/IFieldManger.ts

@@ -0,0 +1,19 @@
+import FieldApiName from './FieldApiName';
+import IField from './IField';
+import MetaData from './MetaData';
+import { BehaviourState } from './BehaviourState';
+
+interface IFieldManager {
+  createSuccessAction(fields: IField[], metaData: MetaData): any;
+  createFailureAction(error: any, metaData: MetaData): any;
+  createNoContentAction(metaData: MetaData): any;
+
+  isFieldFetching(metaData: MetaData): boolean;
+
+  startFetching(apiName: FieldApiName): void;
+  stopFetching(apiName: FieldApiName): void;
+  setFields(data: any, apiName: FieldApiName): void;
+  toObject(): BehaviourState;
+}
+
+export default IFieldManager;

package/es/platform/zfield/domain/entities/interfaces/MetaData.ts

@@ -0,0 +1,21 @@
+import { FIELD_FETCH_FAILURE, FIELD_FETCH_NO_CONTENT, FIELD_FETCH_SUCCESS } from '@bc/zfield/Constants';
+import FieldApiName from './FieldApiName';
+
+type MetaData = {
+  apiName: FieldApiName;
+  actionName: string;
+  [FIELD_FETCH_SUCCESS]: {
+    type: string;
+    payload: object;
+  };
+  [FIELD_FETCH_FAILURE]: {
+    type: string;
+    payload: object;
+  };
+  [FIELD_FETCH_NO_CONTENT]: {
+    type: string;
+    payload: object;
+  };
+};
+
+export default MetaData;

package/es/platform/zfield/frameworks/ActionHandlerFactory.ts

@@ -0,0 +1,40 @@
+import ZFieldActionHandlers from '@bc/zfield/ActionHandlers';
+import { FIELD_EXECUTE, FIELD_REFETCH } from '@bc/zfield/Constants';
+import { HttpTemplates } from '@platform/data-source/dbc'; /* Importing from a data-brokert-contract */
+import Service from '../adapters/gateways/Service';
+import Repository from '../adapters/gateways/Repository';
+import InitializeController from '../adapters/controllers/InitializeController';
+import ExecuteActionController from '../adapters/controllers/ExeucteActionController';
+import FetchSuccessController from '../adapters/controllers/FetchSuccessController';
+import FetchFailureController from '../adapters/controllers/FetchFailureController';
+import FetchNoContentController from '../adapters/controllers/FetchNoContentController';
+import RefetchController from '../adapters/controllers/RefetchController';
+import Presenter from '../adapters/presenters/Presenter';
+import { DATA_SOURCE_EXECUTE_FAILED, DATA_SOURCE_EXECUTE_NO_CONTENT_SUCCEEDED, DATA_SOURCE_EXECUTE_SUCCEEDED } from '@bc/zdata-source/Constants';
+
+class ActionHandlerFactory {
+  static create(apiTemplates: HttpTemplates): ZFieldActionHandlers {
+    const service = this.createService();
+    return this.createHandlers(service, apiTemplates);
+  }
+
+  private static createService(): Service {
+    const repository = new Repository();
+    const presenter = new Presenter();
+
+    return new Service({ repository, presenter });
+  }
+
+  private static createHandlers(service: Service, apiTemplates: HttpTemplates): ZFieldActionHandlers {
+    return {
+      MOUNT: new InitializeController(service, apiTemplates).handle,
+      [FIELD_EXECUTE]: new ExecuteActionController(service).handle,
+      [FIELD_REFETCH]: new RefetchController(service).handle,
+      [DATA_SOURCE_EXECUTE_SUCCEEDED]: new FetchSuccessController(service).handle,
+      [DATA_SOURCE_EXECUTE_FAILED]: new FetchFailureController(service).handle,
+      [DATA_SOURCE_EXECUTE_NO_CONTENT_SUCCEEDED]: new FetchNoContentController(service).handle
+    };
+  }
+}
+
+export default ActionHandlerFactory;

package/es/platform/zfield/frameworks/ZFieldBehaviourFactory.ts

@@ -0,0 +1,16 @@
+import Behaviour from '@cc/component/Behaviour';
+import ActionHandlerFactory from './ActionHandlerFactory';
+import { HttpTemplates } from '@platform/data-source/dbc';
+
+class ZFieldBehaviourFactory {
+  static create(apiTemplates: HttpTemplates): Behaviour {
+    return {
+      name: 'zfield',
+      setInitialState: () => ({}),
+      eventHandlers: ActionHandlerFactory.create(apiTemplates),
+      properties: {}
+    };
+  }
+}
+
+export default ZFieldBehaviourFactory;

package/es/platform/zhttp/adapters/controllers/FetchController.ts

@@ -0,0 +1,19 @@
+import FetchUseCase from '../../applications/usecases/FetchUseCase';
+
+class FetchController {
+  constructor(private fetchUseCase: FetchUseCase) {
+    this.fetchUseCase = fetchUseCase;
+    this.handle = this.handle.bind(this);
+  }
+
+  handle(event) {
+    const { action, dispatch, state } = event;
+    const { payload, metaData } = action;
+    const { headers } = state.properties;
+    const { url, method, getResponse } = payload;
+
+    this.fetchUseCase.execute({ url, method, headers, getResponse, metaData, dispatch, payload: payload.payload });
+  }
+}
+
+export default FetchController;

package/es/platform/zhttp/adapters/gateway/FetchGateWay.ts

@@ -0,0 +1,15 @@
+import {
+  FetchFunction,
+  FetchOptions,
+  IFetchGateWay
+} from '../../applications/interfaces/gateway/IFetchGateWay';
+
+class FetchGateWay implements IFetchGateWay {
+  constructor(private fetchFunction: FetchFunction) {}
+  async fetch(url: string, options: FetchOptions): Promise<Response> {
+    const response = await this.fetchFunction(url, options);
+    return response;
+  }
+}
+
+export default FetchGateWay;

package/es/platform/zhttp/applications/interfaces/InputDependencies.ts

@@ -0,0 +1,6 @@
+import { IFetchGateWay } from './gateway/IFetchGateWay';
+
+type InputDependencies = {
+  fetchGateWay: IFetchGateWay;
+};
+export default InputDependencies;

package/es/platform/zhttp/applications/interfaces/UseCase.ts

@@ -0,0 +1,4 @@
+interface UseCase<T> {
+  execute(input: T): void;
+}
+export default UseCase;

package/es/platform/zhttp/applications/interfaces/gateway/IFetchGateWay.ts

@@ -0,0 +1,15 @@
+type FetchHeader = {} | { [key: string]: string };
+
+export type FetchOptions = {
+  headers: FetchHeader;
+  method: string;
+};
+
+export type FetchFunction = (
+  url: string,
+  options: FetchOptions
+) => Promise<Response>;
+
+export interface IFetchGateWay {
+  fetch(url: string, options: FetchOptions): Promise<Response>;
+}

package/es/platform/zhttp/applications/interfaces/input/FetchInputModel.ts

@@ -0,0 +1,10 @@
+type FetchInputModel = {
+  dispatch: Function;
+  getResponse: Function;
+  url: string;
+  method: string;
+  payload: any;
+  headers: object;
+  metaData: object;
+};
+export default FetchInputModel;

package/es/platform/zhttp/applications/usecases/AbstractUseCase.ts

@@ -0,0 +1,8 @@
+import InputDependencies from "../interfaces/InputDependencies";
+import UseCase from "../interfaces/UseCase";
+
+abstract class AbstractUseCase<InputModel> implements UseCase<InputModel> {
+  constructor(protected dependencies: InputDependencies) {}
+  abstract execute(inputModel: InputModel): void;
+}
+export default AbstractUseCase;