fix: Getting the sheet columns in import sheet

fix: Typo one-click demo page

packages/server/src/api/controllers/Import/ImportController.ts

@@ -40,7 +40,6 @@ export class ImportController extends BaseController {
         body('mapping.*.group').optional(),
         body('mapping.*.from').exists(),
         body('mapping.*.to').exists(),
-        body('mapping.*.dateFormat').optional({ nullable: true }),
       ],
       this.validationResult,
       this.asyncMiddleware(this.mapping.bind(this)),

packages/server/src/lib/Transformer/Transformer.ts

@@ -2,6 +2,7 @@ import moment from 'moment';
 import * as R from 'ramda';
 import { includes, isFunction, isObject, isUndefined, omit } from 'lodash';
 import { formatNumber, sortObjectKeysAlphabetically } from 'utils';
+import { EXPORT_DTE_FORMAT } from '@/services/Export/constants';
 
 export class Transformer {
   public context: any;
@@ -156,22 +157,34 @@ export class Transformer {
   }
 
   /**
-   *
+   * Format date.
-   * @param date
+   * @param {} date
-   * @returns
+   * @param {string} format -
+   * @returns {}
    */
-  protected formatDate(date) {
+  protected formatDate(date, format?: string) {
-    return date ? moment(date).format(this.dateFormat) : '';
+    // Use the export date format if the async operation is in exporting,
+    // otherwise use the given or default format.
+    const _format = this.context.exportAls.isExport
+      ? EXPORT_DTE_FORMAT
+      : format || this.dateFormat;
+
+    return date ? moment(date).format(_format) : '';
   }
 
-  protected formatDateFromNow(date){
+  /**
+   *
+   * @param date
+   * @returns {}
+   */
+  protected formatDateFromNow(date) {
     return date ? moment(date).fromNow(true) : '';
   }
 
   /**
    *
    * @param number
-   * @returns
+   * @returns {}
    */
   protected formatNumber(number, props?) {
     return formatNumber(number, { money: false, ...props });
@@ -181,7 +194,7 @@ export class Transformer {
    *
    * @param money
    * @param options
-   * @returns
+   * @returns {}
    */
   protected formatMoney(money, options?) {
     return formatNumber(money, {

packages/server/src/lib/Transformer/TransformerInjectable.ts

@@ -3,12 +3,17 @@ import { isNull } from 'lodash';
 import HasTenancyService from '@/services/Tenancy/TenancyService';
 import { TenantMetadata } from '@/system/models';
 import { Transformer } from './Transformer';
+import { ImportAls } from '@/services/Import/ImportALS';
+import { ExportAls } from '@/services/Export/ExportAls';
 
 @Service()
 export class TransformerInjectable {
   @Inject()
   private tenancy: HasTenancyService;
 
+  @Inject()
+  private exportAls: ExportAls;
+
   /**
    * Retrieves the application context of all tenant transformers.
    * @param   {number} tenantId
@@ -17,10 +22,12 @@ export class TransformerInjectable {
   async getApplicationContext(tenantId: number) {
     const i18n = this.tenancy.i18n(tenantId);
     const organization = await TenantMetadata.query().findOne({ tenantId });
+    const exportAls = this.exportAls;
 
     return {
       organization,
       i18n,
+      exportAls,
     };
   }
 

packages/server/src/models/Customer.Settings.ts

@@ -95,6 +95,11 @@ export default {
     },
   },
   columns: {
+    customerType: {
+      name: 'Customer Type',
+      type: 'text',
+      accessor: 'formattedCustomerType',
+    },
     firstName: {
       name: 'vendor.field.first_name',
       type: 'text',
@@ -135,116 +140,117 @@ export default {
     openingBalance: {
       name: 'vendor.field.opening_balance',
       type: 'number',
-      printable: false
+      printable: false,
     },
     openingBalanceAt: {
       name: 'vendor.field.opening_balance_at',
       type: 'date',
-      printable: false
+      printable: false,
+      accessor: 'formattedOpeningBalanceAt'
     },
     currencyCode: {
       name: 'vendor.field.currency',
       type: 'text',
-      printable: false
+      printable: false,
     },
     status: {
       name: 'vendor.field.status',
-      printable: false
+      printable: false,
     },
     note: {
       name: 'vendor.field.note',
-      printable: false
+      printable: false,
     },
     // Billing Address
     billingAddress1: {
       name: 'Billing Address 1',
       column: 'billing_address1',
       type: 'text',
-      printable: false
+      printable: false,
     },
     billingAddress2: {
       name: 'Billing Address 2',
       column: 'billing_address2',
       type: 'text',
-      printable: false
+      printable: false,
     },
     billingAddressCity: {
       name: 'Billing Address City',
       column: 'billing_address_city',
       type: 'text',
-      printable: false
+      printable: false,
     },
     billingAddressCountry: {
       name: 'Billing Address Country',
       column: 'billing_address_country',
       type: 'text',
-      printable: false
+      printable: false,
     },
     billingAddressPostcode: {
       name: 'Billing Address Postcode',
       column: 'billing_address_postcode',
       type: 'text',
-      printable: false
+      printable: false,
     },
     billingAddressState: {
       name: 'Billing Address State',
       column: 'billing_address_state',
       type: 'text',
-      printable: false
+      printable: false,
     },
     billingAddressPhone: {
       name: 'Billing Address Phone',
       column: 'billing_address_phone',
       type: 'text',
-      printable: false
+      printable: false,
     },
     // Shipping Address
     shippingAddress1: {
       name: 'Shipping Address 1',
       column: 'shipping_address1',
       type: 'text',
-      printable: false
+      printable: false,
     },
     shippingAddress2: {
       name: 'Shipping Address 2',
       column: 'shipping_address2',
       type: 'text',
-      printable: false
+      printable: false,
     },
     shippingAddressCity: {
       name: 'Shipping Address City',
       column: 'shipping_address_city',
       type: 'text',
-      printable: false
+      printable: false,
     },
     shippingAddressCountry: {
       name: 'Shipping Address Country',
       column: 'shipping_address_country',
       type: 'text',
-      printable: false
+      printable: false,
     },
     shippingAddressPostcode: {
       name: 'Shipping Address Postcode',
       column: 'shipping_address_postcode',
       type: 'text',
-      printable: false
+      printable: false,
     },
     shippingAddressPhone: {
       name: 'Shipping Address Phone',
       column: 'shipping_address_phone',
       type: 'text',
-      printable: false
+      printable: false,
     },
     shippingAddressState: {
       name: 'Shipping Address State',
       column: 'shipping_address_state',
       type: 'text',
-      printable: false
+      printable: false,
     },
     createdAt: {
       name: 'vendor.field.created_at',
       type: 'date',
-      printable: false
+      printable: false,
     },
   },
   fields2: {

packages/server/src/services/Export/ExportAls.ts

@@ -0,0 +1,48 @@
+import { Service } from 'typedi';
+import { AsyncLocalStorage } from 'async_hooks';
+
+@Service()
+export class ExportAls {
+  private als: AsyncLocalStorage<Map<string, any>>;
+
+  constructor() {
+    this.als = new AsyncLocalStorage();
+  }
+
+  /**
+   * Runs a callback function within the context of a new AsyncLocalStorage store.
+   * @param callback The function to be executed within the AsyncLocalStorage context.
+   * @returns The result of the callback function.
+   */
+  public run<T>(callback: () => T): T {
+    return this.als.run<T>(new Map(), () => {
+      this.markAsExport();
+
+      return callback();
+    });
+  }
+
+  /**
+   * Retrieves the current AsyncLocalStorage store.
+   * @returns The current store or undefined if not in a valid context.
+   */
+  public getStore(): Map<string, any> | undefined {
+    return this.als.getStore();
+  }
+
+  /**
+   * Marks the current context as an export operation.
+   * @param flag Boolean flag to set or unset the export status. Defaults to true.
+   */
+  public markAsExport(flag: boolean = true): void {
+    const store = this.getStore();
+    store?.set('isExport', flag);
+  }
+  /**
+   * Checks if the current context is an export operation.
+   * @returns {boolean} True if the context is an export operation, false otherwise.
+   */
+  public get isExport(): boolean {
+    return !!this.getStore()?.get('isExport');
+  }
+}

packages/server/src/services/Export/ExportService.ts

@@ -10,6 +10,7 @@ import { Errors, ExportFormat } from './common';
 import { IModelMeta, IModelMetaColumn } from '@/interfaces';
 import { flatDataCollections, getDataAccessor } from './utils';
 import { ExportPdf } from './ExportPdf';
+import { ExportAls } from './ExportAls';
 
 @Service()
 export class ExportResourceService {
@@ -22,13 +23,33 @@ export class ExportResourceService {
   @Inject()
   private exportPdf: ExportPdf;
 
+  @Inject()
+  private exportAls: ExportAls;
+
+  /**
+   *
+   * @param {number} tenantId
+   * @param {string} resourceName
+   * @param {ExportFormat} format
+   * @returns
+   */
+  public async export(
+    tenantId: number,
+    resourceName: string,
+    format: ExportFormat = ExportFormat.Csv
+  ) {
+    return this.exportAls.run(() =>
+      this.exportAlsRun(tenantId, resourceName, format)
+    );
+  }
+
   /**
    * Exports the given resource data through csv, xlsx or pdf.
    * @param {number} tenantId - Tenant id.
    * @param {string} resourceName - Resource name.
    * @param {ExportFormat} format - File format.
    */
-  public async export(
+  public async exportAlsRun(
     tenantId: number,
     resourceName: string,
     format: ExportFormat = ExportFormat.Csv

packages/server/src/services/Export/constants.ts

@@ -1 +1,2 @@
 export const EXPORT_SIZE_LIMIT = 9999999;
+export const EXPORT_DTE_FORMAT = 'YYYY-MM-DD';

packages/server/src/services/Import/ImportALS.ts

@@ -8,6 +8,7 @@ export class ImportAls {
   constructor() {
     this.als = new AsyncLocalStorage();
   }
+
   /**
    * Runs a callback function within the context of a new AsyncLocalStorage store.
    * @param callback The function to be executed within the AsyncLocalStorage context.
@@ -82,7 +83,7 @@ export class ImportAls {
    * Checks if the current context is an import operation.
    * @returns {boolean} True if the context is an import operation, false otherwise.
    */
-  public isImport(): boolean {
+  public get isImport(): boolean {
     return !!this.getStore()?.get('isImport');
   }
 
@@ -90,7 +91,7 @@ export class ImportAls {
    * Checks if the current context is an import commit operation.
    * @returns {boolean} True if the context is an import commit operation, false otherwise.
    */
-  public isImportCommit(): boolean {
+  public get isImportCommit(): boolean {
     return !!this.getStore()?.get('isImportCommit');
   }
 
@@ -98,7 +99,7 @@ export class ImportAls {
    * Checks if the current context is an import preview operation.
    * @returns {boolean} True if the context is an import preview operation, false otherwise.
    */
-  public isImportPreview(): boolean {
+  public get isImportPreview(): boolean {
     return !!this.getStore()?.get('isImportPreview');
   }
 }

packages/server/src/services/Import/ImportFileCommon.ts

@@ -1,4 +1,3 @@
-import XLSX from 'xlsx';
 import bluebird from 'bluebird';
 import * as R from 'ramda';
 import { Inject, Service } from 'typedi';
@@ -12,11 +11,7 @@ import {
   ImportableContext,
 } from './interfaces';
 import { ServiceError } from '@/exceptions';
-import {
+import { getUniqueImportableValue, trimObject } from './_utils';
-  convertMappingsToObject,
-  getUniqueImportableValue,
-  trimObject,
-} from './_utils';
 import { ImportableResources } from './ImportableResources';
 import ResourceService from '../Resource/ResourceService';
 import { Import } from '@/system/models';
@@ -32,21 +27,6 @@ export class ImportFileCommon {
   @Inject()
   private resource: ResourceService;
   
-  /**
-   * Maps the columns of the imported data based on the provided mapping attributes.
-   * @param {Record<string, any>[]} body - The array of data objects to map.
-   * @param {ImportMappingAttr[]} map - The mapping attributes.
-   * @returns {Record<string, any>[]} - The mapped data objects.
-   */
-  public parseXlsxSheet(buffer: Buffer): Record<string, unknown>[] {
-    const workbook = XLSX.read(buffer, { type: 'buffer', raw: true });
-
-    const firstSheetName = workbook.SheetNames[0];
-    const worksheet = workbook.Sheets[firstSheetName];
-
-    return XLSX.utils.sheet_to_json(worksheet, {});
-  }
-
   /**
    * Imports the given parsed data to the resource storage through registered importable service.
    * @param {number} tenantId -
@@ -85,14 +65,11 @@ export class ImportFileCommon {
         rowNumber,
         uniqueValue,
       };
-      const mappingSettings = convertMappingsToObject(importFile.columnsParsed);
-
       try {
         // Validate the DTO object before passing it to the service layer.
         await this.importFileValidator.validateData(
           resourceFields,
-          transformedDTO,
+          transformedDTO
-          mappingSettings
         );
         try {
           // Run the importable function and listen to the errors.

packages/server/src/services/Import/ImportFileDataValidator.ts

@@ -1,9 +1,5 @@
 import { Service } from 'typedi';
-import {
+import { ImportInsertError, ResourceMetaFieldsMap } from './interfaces';
-  ImportInsertError,
-  ImportMappingAttr,
-  ResourceMetaFieldsMap,
-} from './interfaces';
 import { ERRORS, convertFieldsToYupValidation } from './_utils';
 import { IModelMeta } from '@/interfaces';
 import { ServiceError } from '@/exceptions';
@@ -28,13 +24,9 @@ export class ImportFileDataValidator {
    */
   public async validateData(
     importableFields: ResourceMetaFieldsMap,
-    data: Record<string, any>,
+    data: Record<string, any>
-    mappingSettings: Record<string, ImportMappingAttr> = {}
   ): Promise<void | ImportInsertError[]> {
-    const YupSchema = convertFieldsToYupValidation(
+    const YupSchema = convertFieldsToYupValidation(importableFields);
-      importableFields,
-      mappingSettings
-    );
     const _data = { ...data };
 
     try {

packages/server/src/services/Import/ImportFileProcess.ts

@@ -2,18 +2,14 @@ import { Inject, Service } from 'typedi';
 import { chain } from 'lodash';
 import { Knex } from 'knex';
 import { ServiceError } from '@/exceptions';
-import {
+import { ERRORS, getUnmappedSheetColumns, readImportFile } from './_utils';
-  ERRORS,
-  getSheetColumns,
-  getUnmappedSheetColumns,
-  readImportFile,
-} from './_utils';
 import { ImportFileCommon } from './ImportFileCommon';
 import { ImportFileDataTransformer } from './ImportFileDataTransformer';
 import ResourceService from '../Resource/ResourceService';
 import UnitOfWork from '../UnitOfWork';
 import { ImportFilePreviewPOJO } from './interfaces';
 import { Import } from '@/system/models';
+import { parseSheetData } from './sheet_utils';
 
 @Service()
 export class ImportFileProcess {
@@ -49,10 +45,10 @@ export class ImportFileProcess {
     if (!importFile.isMapped) {
       throw new ServiceError(ERRORS.IMPORT_FILE_NOT_MAPPED);
     }
-    // Read the imported file.
+    // Read the imported file and parse the given buffer to get columns
+    // and sheet data in json format.
     const buffer = await readImportFile(importFile.filename);
-    const sheetData = this.importCommon.parseXlsxSheet(buffer);
+    const [sheetData, sheetColumns] = parseSheetData(buffer);
-    const header = getSheetColumns(sheetData);
 
     const resource = importFile.resource;
     const resourceFields = this.resource.getResourceFields2(tenantId, resource);
@@ -87,7 +83,7 @@ export class ImportFileProcess {
       .flatten()
       .value();
 
-    const unmappedColumns = getUnmappedSheetColumns(header, mapping);
+    const unmappedColumns = getUnmappedSheetColumns(sheetColumns, mapping);
     const totalCount = allData.length;
 
     const createdCount = successedImport.length;

packages/server/src/services/Import/ImportFileUpload.ts

@@ -11,6 +11,7 @@ import { ImportFileCommon } from './ImportFileCommon';
 import { ImportFileDataValidator } from './ImportFileDataValidator';
 import { ImportFileUploadPOJO } from './interfaces';
 import { Import } from '@/system/models';
+import { parseSheetData } from './sheet_utils';
 
 @Service()
 export class ImportFileUploadService {
@@ -77,14 +78,12 @@ export class ImportFileUploadService {
     const buffer = await readImportFile(filename);
 
     // Parse the buffer file to array data.
-    const sheetData = this.importFileCommon.parseXlsxSheet(buffer);
+    const [sheetData, sheetColumns] = parseSheetData(buffer);
+    const coumnsStringified = JSON.stringify(sheetColumns);
 
     // Throws service error if the sheet data is empty.
     validateSheetEmpty(sheetData);
 
-    const sheetColumns = this.importFileCommon.parseSheetColumns(sheetData);
-    const coumnsStringified = JSON.stringify(sheetColumns);
-
     try {
       // Validates the params Yup schema.
       await this.importFileCommon.validateParamsSchema(resource, params);

packages/server/src/services/Import/_utils.ts

@@ -17,10 +17,9 @@ import {
   head,
   split,
   last,
-  set,
 } from 'lodash';
 import pluralize from 'pluralize';
-import { ImportMappingAttr, ResourceMetaFieldsMap } from './interfaces';
+import { ResourceMetaFieldsMap } from './interfaces';
 import { IModelMetaField, IModelMetaField2 } from '@/interfaces';
 import { ServiceError } from '@/exceptions';
 import { multiNumberParse } from '@/utils/multi-number-parse';
@@ -59,19 +58,11 @@ export function trimObject(obj: Record<string, string | number>) {
  * @param {ResourceMetaFieldsMap} fields
  * @returns {Yup}
  */
-export const convertFieldsToYupValidation = (
+export const convertFieldsToYupValidation = (fields: ResourceMetaFieldsMap) => {
-  fields: ResourceMetaFieldsMap,
-  parentFieldName: string = '',
-  mappingSettings: Record<string, ImportMappingAttr> = {}
-) => {
   const yupSchema = {};
 
   Object.keys(fields).forEach((fieldName: string) => {
     const field = fields[fieldName] as IModelMetaField;
-    const fieldPath = parentFieldName
-      ? `${parentFieldName}.${fieldName}`
-      : fieldName;
-
     let fieldSchema;
     fieldSchema = Yup.string().label(field.name);
 
@@ -114,23 +105,13 @@ export const convertFieldsToYupValidation = (
           if (!val) {
             return true;
           }
-          const fieldDateFormat =
+          return moment(val, 'YYYY-MM-DD', true).isValid();
-            (get(
-              mappingSettings,
-              `${fieldPath}.dateFormat`
-            ) as unknown as string) || 'YYYY-MM-DD';
-
-          return moment(val, fieldDateFormat, true).isValid();
         }
       );
     } else if (field.fieldType === 'url') {
       fieldSchema = fieldSchema.url();
     } else if (field.fieldType === 'collection') {
-      const nestedFieldShema = convertFieldsToYupValidation(
+      const nestedFieldShema = convertFieldsToYupValidation(field.fields);
-        field.fields,
-        field.name,
-        mappingSettings
-      );
       fieldSchema = Yup.array().label(field.name);
 
       if (!isUndefined(field.collectionMaxLength)) {
@@ -277,7 +258,6 @@ export const getResourceColumns = (resourceColumns: {
     ]) => {
       const extra: Record<string, any> = {};
       const key = fieldKey;
-      const type = field.fieldType;
 
       if (group) {
         extra.group = group;
@@ -290,7 +270,6 @@ export const getResourceColumns = (resourceColumns: {
         name,
         required,
         hint: importHint,
-        type,
         order,
         ...extra,
       };
@@ -343,8 +322,6 @@ export const valueParser =
       });
       const result = await relationQuery.first();
       _value = get(result, 'id');
-    } else if (field.fieldType === 'date') {
-      
     } else if (field.fieldType === 'collection') {
       const ObjectFieldKey = key.includes('.') ? key.split('.')[1] : key;
       const _valueParser = valueParser(fields, tenantModels);
@@ -456,8 +433,8 @@ export const getMapToPath = (to: string, group = '') =>
   group ? `${group}.${to}` : to;
 
 export const getImportsStoragePath = () => {
-  return path.join(global.__storage_dir, `/imports`);
+  return  path.join(global.__storage_dir, `/imports`);
-};
+}
 
 /**
  * Deletes the imported file from the storage and database.
@@ -480,19 +457,3 @@ export const readImportFile = (filename: string) => {
 
   return fs.readFile(`${filePath}/${filename}`);
 };
-
-/**
- * Converts an array of mapping objects to a structured object.
- * @param {Array<Object>} mappings - Array of mapping objects.
- * @returns {Object} - Structured object based on the mappings.
- */
-export const convertMappingsToObject = (mappings) => {
-  return mappings.reduce((acc, mapping) => {
-    const { to, group } = mapping;
-    const key = group ? `['${group}.${to}']` : to;
-
-    set(acc, key, mapping);
-
-    return acc;
-  }, {});
-};

packages/server/src/services/Import/sheet_utils.ts

@@ -0,0 +1,56 @@
+import XLSX from 'xlsx';
+import { first } from 'lodash';
+
+/**
+ * Parses the given sheet buffer to worksheet.
+ * @param {Buffer} buffer
+ * @returns {XLSX.WorkSheet}
+ */
+export function parseFirstSheet(buffer: Buffer): XLSX.WorkSheet {
+  const workbook = XLSX.read(buffer, { type: 'buffer', raw: true });
+
+  const firstSheetName = workbook.SheetNames[0];
+  const worksheet = workbook.Sheets[firstSheetName];
+
+  return worksheet;
+}
+
+/**
+ * Extracts the given worksheet to columns.
+ * @param {XLSX.WorkSheet} worksheet
+ * @returns {Array<string>}
+ */
+export function extractSheetColumns(worksheet: XLSX.WorkSheet): Array<string> {
+  // By default, sheet_to_json scans the first row and uses the values as headers.
+  // With the header: 1 option, the function exports an array of arrays of values.
+  const sheetCells = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
+  const sheetCols = first(sheetCells) as Array<string>;
+
+  return sheetCols.filter((col) => col);
+}
+
+/**
+ * Parses the given worksheet to json values. the keys are columns labels.
+ * @param {XLSX.WorkSheet} worksheet
+ * @returns {Array<Record<string, string>>}
+ */
+export function parseSheetToJson(
+  worksheet: XLSX.WorkSheet
+): Array<Record<string, string>> {
+  return XLSX.utils.sheet_to_json(worksheet, {});
+}
+
+/**
+ * Parses the given sheet buffer then retrieves the sheet data and columns.
+ * @param {Buffer} buffer
+ */
+export function parseSheetData(
+  buffer: Buffer
+): [Array<Record<string, string>>, string[]] {
+  const worksheet = parseFirstSheet(buffer);
+
+  const columns = extractSheetColumns(worksheet);
+  const data = parseSheetToJson(worksheet);
+
+  return [data, columns];
+}

packages/server/src/subscribers/Inventory/Inventory.ts

@@ -92,7 +92,7 @@ export default class InventorySubscriber {
     inventoryTransactions,
     trx,
   }: IInventoryTransactionsCreatedPayload) => {
-    const inImportPreviewScope = this.importAls.isImportPreview();
+    const inImportPreviewScope = this.importAls.isImportPreview;
 
     // Avoid running the cost items job if the async process is in import preview.
     if (inImportPreviewScope) return;

packages/webapp/src/components/App.tsx

@@ -1,4 +1,5 @@
 // @ts-nocheck
+import { lazy, Suspense } from 'react';
 import { Router, Switch, Route } from 'react-router';
 import { createBrowserHistory } from 'history';
 import { QueryClientProvider, QueryClient } from 'react-query';
@@ -11,25 +12,26 @@ import 'moment/locale/es-us';
 import AppIntlLoader from './AppIntlLoader';
 import { EnsureAuthenticated } from '@/components/Guards/EnsureAuthenticated';
 import GlobalErrors from '@/containers/GlobalErrors/GlobalErrors';
-import DashboardPrivatePages from '@/components/Dashboard/PrivatePages';
-import { Authentication } from '@/containers/Authentication/Authentication';
 
-import LazyLoader from '@/components/LazyLoader';
 import { SplashScreen, DashboardThemeProvider } from '../components';
 import { queryConfig } from '../hooks/query/base';
-import { EnsureUserEmailVerified } from './Guards/EnsureUserEmailVerified';
-import { EnsureAuthNotAuthenticated } from './Guards/EnsureAuthNotAuthenticated';
 import { EnsureUserEmailNotVerified } from './Guards/EnsureUserEmailNotVerified';
 
-const EmailConfirmation = LazyLoader({
+const DashboardPrivatePages = lazy(
-  loader: () => import('@/containers/Authentication/EmailConfirmation'),
+  () => import('@/components/Dashboard/PrivatePages'),
-});
+);
-const RegisterVerify = LazyLoader({
+const AuthenticationPage = lazy(
-  loader: () => import('@/containers/Authentication/RegisterVerify'),
+  () => import('@/containers/Authentication/AuthenticationPage'),
-});
+);
-const OneClickDemoPage = LazyLoader({
+const EmailConfirmation = lazy(
-  loader: () => import('@/containers/OneClickDemo/OneClickDemoPage'),
+  () => import('@/containers/Authentication/EmailConfirmation'),
-});
+);
+const RegisterVerify = lazy(
+  () => import('@/containers/Authentication/RegisterVerify'),
+);
+const OneClickDemoPage = lazy(
+  () => import('@/containers/OneClickDemo/OneClickDemoPage'),
+);
 
 /**
  * App inner.
@@ -38,36 +40,27 @@ function AppInsider({ history }) {
   return (
     <div className="App">
       <DashboardThemeProvider>
-        <Router history={history}>
+        <Suspense fallback={'Loading...'}>
-          <Switch>
+          <Router history={history}>
-            <Route path={'/one_click_demo'} children={<OneClickDemoPage />} />
+            <Switch>
-            <Route path={'/auth/register/verify'}>
+              <Route path={'/one_click_demo'} children={<OneClickDemoPage />} />
-              <EnsureAuthenticated>
+              <Route path={'/auth/register/verify'}>
-                <EnsureUserEmailNotVerified>
+                <EnsureAuthenticated>
-                  <RegisterVerify />
+                  <EnsureUserEmailNotVerified>
-                </EnsureUserEmailNotVerified>
+                    <RegisterVerify />
-              </EnsureAuthenticated>
+                  </EnsureUserEmailNotVerified>
-            </Route>
+                </EnsureAuthenticated>
+              </Route>
 
-            <Route path={'/auth/email_confirmation'}>
+              <Route
-              <EmailConfirmation />
+                path={'/auth/email_confirmation'}
-            </Route>
+                children={<EmailConfirmation />}
-
+              />
-            <Route path={'/auth'}>
+              <Route path={'/auth'} children={<AuthenticationPage />} />
-              <EnsureAuthNotAuthenticated>
+              <Route path={'/'} children={<DashboardPrivatePages />} />
-                <Authentication />
+            </Switch>
-              </EnsureAuthNotAuthenticated>
+          </Router>
-            </Route>
+        </Suspense>
-
-            <Route path={'/'}>
-              <EnsureAuthenticated>
-                <EnsureUserEmailVerified>
-                  <DashboardPrivatePages />
-                </EnsureUserEmailVerified>
-              </EnsureAuthenticated>
-            </Route>
-          </Switch>
-        </Router>
 
         <GlobalErrors />
       </DashboardThemeProvider>

packages/webapp/src/components/Dashboard/PrivatePages.tsx

@@ -1,35 +1,37 @@
 // @ts-nocheck
-import React from 'react';
+import React, { lazy } from 'react';
 import { Switch, Route } from 'react-router';
 
 import Dashboard from '@/components/Dashboard/Dashboard';
-import SetupWizardPage from '@/containers/Setup/WizardSetupPage';
 
-import EnsureOrganizationIsReady from '../Guards/EnsureOrganizationIsReady';
-import EnsureOrganizationIsNotReady from '../Guards/EnsureOrganizationIsNotReady';
 import { PrivatePagesProvider } from './PrivatePagesProvider';
+import EnsureOrganizationIsReady from '../Guards/EnsureOrganizationIsReady';
+import { EnsureAuthenticated } from '../Guards/EnsureAuthenticated';
+import { EnsureUserEmailVerified } from '../Guards/EnsureUserEmailVerified';
 
 import '@/style/pages/Dashboard/Dashboard.scss';
 
+const SetupWizardPage = lazy(
+  () => import('@/containers/Setup/WizardSetupPage'),
+);
 /**
  * Dashboard inner private pages.
  */
 export default function DashboardPrivatePages() {
   return (
-    <PrivatePagesProvider>
+    <EnsureAuthenticated>
-      <Switch>
+      <EnsureUserEmailVerified>
-        <Route path={'/setup'}>
+        <PrivatePagesProvider>
-          <EnsureOrganizationIsNotReady>
+          <Switch>
-            <SetupWizardPage />
+            <Route path={'/setup'} children={<SetupWizardPage />} />
-          </EnsureOrganizationIsNotReady>
+            <Route path="/">
-        </Route>
+              <EnsureOrganizationIsReady>
-
+                <Dashboard />
-        <Route path="/">
+              </EnsureOrganizationIsReady>
-          <EnsureOrganizationIsReady>
+            </Route>
-            <Dashboard />
+          </Switch>
-          </EnsureOrganizationIsReady>
+        </PrivatePagesProvider>
-        </Route>
+      </EnsureUserEmailVerified>
-      </Switch>
+    </EnsureAuthenticated>
-    </PrivatePagesProvider>
   );
 }

packages/webapp/src/components/LazyLoader.tsx

@@ -1,22 +0,0 @@
-// @ts-nocheck
-import * as React from 'react';
-import * as Loadable from 'react-loadable';
-
-const Loader = (config) =>
-  Loadable({
-    loading: (props) => {
-      if (props.error) {
-        /* tslint:disable */
-        console.error(`======= DefaultLoader Error =======`);
-        console.error(props.error);
-        console.error(`======= DefaultLoader Error =======`);
-        /* tslint:enable */
-        return null;
-      }
-      return null;
-    },
-    delay: 250,
-    ...config
-  });
-
-export default Loader;

packages/webapp/src/components/Preferences/PreferencesContentRoute.tsx

@@ -1,21 +1,33 @@
 // @ts-nocheck
-import React from 'react';
+import React, { Suspense } from 'react';
 import { Route, Switch } from 'react-router-dom';
-import preferencesRoutes from '@/routes/preferences';
+import { getPreferenceRoutes } from '@/routes/preferences';
+import { Spinner } from '@blueprintjs/core';
+import { Box } from '../Layout';
 
 export default function DashboardContentRoute() {
+  const preferencesRoutes = getPreferenceRoutes();
+
   return (
     <Route pathname="/preferences">
-      <Switch>
+      <Suspense
-        {preferencesRoutes.map((route, index) => (
+        fallback={
-          <Route
+          <Box style={{ padding: 20 }}>
-            key={index}
+            <Spinner size={20} />
-            path={`${route.path}`}
+          </Box>
-            exact={route.exact}
+        }
-            component={route.component}
+      >
-          />
+        <Switch>
-        ))}
+          {preferencesRoutes.map((route, index) => (
-      </Switch>
+            <Route
+              key={index}
+              path={`${route.path}`}
+              exact={route.exact}
+              component={route.component}
+            />
+          ))}
+        </Switch>
+      </Suspense>
     </Route>
   );
 }

packages/webapp/src/containers/Authentication/Authentication.tsx

@@ -2,10 +2,12 @@
 import { Route, Switch, useLocation } from 'react-router-dom';
 import BodyClassName from 'react-body-classname';
 import styled from 'styled-components';
+import { Suspense } from 'react';
 import { TransitionGroup, CSSTransition } from 'react-transition-group';
+import { Spinner } from '@blueprintjs/core';
 
 import authenticationRoutes from '@/routes/authentication';
-import { Icon, FormattedMessage as T } from '@/components';
+import { Box, Icon, FormattedMessage as T } from '@/components';
 import { AuthMetaBootProvider } from './AuthMetaBoot';
 
 import '@/style/pages/Authentication/Auth.scss';
@@ -20,7 +22,15 @@ export function Authentication() {
           </AuthLogo>
 
           <AuthMetaBootProvider>
-            <AuthenticationRoutes />
+            <Suspense
+              fallback={
+                <Box style={{ marginTop: '5rem' }}>
+                  <Spinner size={30} />
+                </Box>
+              }
+            >
+              <AuthenticationRoutes />
+            </Suspense>
           </AuthMetaBootProvider>
         </AuthInsider>
       </AuthPage>

packages/webapp/src/containers/Authentication/AuthenticationPage.tsx

@@ -0,0 +1,10 @@
+import { EnsureAuthNotAuthenticated } from "@/components/Guards/EnsureAuthNotAuthenticated";
+import { Authentication } from "./Authentication";
+
+export default function AuthenticationPage() {
+  return (
+    <EnsureAuthNotAuthenticated>
+      <Authentication />
+    </EnsureAuthNotAuthenticated>
+  );
+}

packages/webapp/src/containers/Import/ImportFileMapping.module.scss

@@ -14,7 +14,7 @@
 
   th.label,
   td.label{
-    width: 30% !important;
+    width: 32% !important;
   }
 
   thead{
@@ -31,14 +31,16 @@
     tr td {
       vertical-align: middle;
     }
+
+    tr td{
+      :global(.bp4-popover-target .bp4-button),
+      :global(.bp4-popover-wrapper){
+        max-width: 250px;
+      }
+    }
   }
 }
 
 .requiredSign{
   color: rgb(250, 82, 82);
 }
-
-.columnSelectButton{
-  max-width: 250px;
-  min-width: 250px;
-}

packages/webapp/src/containers/Import/ImportFileMapping.tsx

@@ -8,12 +8,9 @@ import { EntityColumnField, useImportFileContext } from './ImportFileProvider';
 import { CLASSES } from '@/constants';
 import { ImportFileContainer } from './ImportFileContainer';
 import { ImportStepperStep } from './_types';
-import {
+import { ImportFileMapBootProvider } from './ImportFileMappingBoot';
-  ImportFileMapBootProvider,
-  useImportFileMapBootContext,
-} from './ImportFileMappingBoot';
 import styles from './ImportFileMapping.module.scss';
-import { getDateFieldKey, getFieldKey } from './_utils';
+import { getFieldKey } from './_utils';
 
 export function ImportFileMapping() {
   const { importId, entityColumns } = useImportFileContext();
@@ -85,7 +82,6 @@ interface ImportFileMappingFieldsProps {
  */
 function ImportFileMappingFields({ fields }: ImportFileMappingFieldsProps) {
   const { sheetColumns } = useImportFileContext();
-  const { dateFormats } = useImportFileMapBootContext();
 
   const items = useMemo(
     () => sheetColumns.map((column) => ({ value: column, text: column })),
@@ -99,35 +95,22 @@ function ImportFileMappingFields({ fields }: ImportFileMappingFieldsProps) {
           {column.required && <span className={styles.requiredSign}>*</span>}
         </td>
         <td className={styles.field}>
-          <Group spacing={12} noWrap>
+          <Group spacing={4}>
             <FSelect
-              name={`['${getFieldKey(column.key, column.group)}'].from`}
+              name={getFieldKey(column.key, column.group)}
               items={items}
               popoverProps={{ minimal: true }}
               minimal={true}
               fill={true}
-              className={styles.columnSelectButton}
             />
             {column.hint && (
               <Hint content={column.hint} position={Position.BOTTOM} />
             )}
-            {column.type === 'date' && (
-              <FSelect
-                name={getDateFieldKey(column.key, column.group)}
-                items={dateFormats}
-                placeholder={'Select date format'}
-                minimal={true}
-                fill={true}
-                valueAccessor={'key'}
-                textAccessor={'label'}
-                labelAccessor={''}
-              />
-            )}
           </Group>
         </td>
       </tr>
     ),
-    [items, dateFormats],
+    [items],
   );
   const columns = useMemo(
     () => fields.map(columnMapper),

packages/webapp/src/containers/Import/ImportFileMappingBoot.tsx

@@ -2,11 +2,8 @@ import { Spinner } from '@blueprintjs/core';
 import React, { createContext, useContext } from 'react';
 import { Box } from '@/components';
 import { useImportFileMeta } from '@/hooks/query/import';
-import { useDateFormats } from '@/hooks/query';
 
-interface ImportFileMapBootContextValue {
+interface ImportFileMapBootContextValue {}
-  dateFormats: Array<any>;
-}
 
 const ImportFileMapBootContext = createContext<ImportFileMapBootContextValue>(
   {} as ImportFileMapBootContextValue,
@@ -42,22 +39,14 @@ export const ImportFileMapBootProvider = ({
     enabled: Boolean(importId),
   });
 
-  // Fetch date format options.
-  const { data: dateFormats, isLoading: isDateFormatsLoading } =
-    useDateFormats();
-
   const value = {
     importFile,
     isImportFileLoading,
     isImportFileFetching,
-    dateFormats,
-    isDateFormatsLoading,
   };
-  const isLoading = isDateFormatsLoading || isImportFileLoading;
-
   return (
     <ImportFileMapBootContext.Provider value={value}>
-      {isLoading ? (
+      {isImportFileLoading ? (
         <Box style={{ padding: '2rem', textAlign: 'center' }}>
           <Spinner size={26} />
         </Box>

packages/webapp/src/containers/Import/ImportFileProvider.tsx

@@ -13,7 +13,6 @@ export type EntityColumnField = {
   required?: boolean;
   hint?: string;
   group?: string;
-  type: string;
 };
 
 export interface EntityColumn {

packages/webapp/src/containers/Import/ImportFileUploadStep.module.scss

@@ -6,8 +6,8 @@
   flex: 1;
   padding: 32px 20px;
   padding-bottom: 80px;
-  min-width: 800px;
+  min-width: 660px;
-  max-width: 800px;
+  max-width: 760px;
   width: 75%;
   margin-left: auto;
   margin-right: auto;

packages/webapp/src/containers/Import/_types.ts

@@ -12,13 +12,4 @@ export interface ImportFileMappingFormProps {
   children: React.ReactNode;
 }
 
-export type ImportFileMappingFormValues = Record<
+export type ImportFileMappingFormValues = Record<string, string | null>;
-  string,
-  { from: string | null; dateFormat?: string }
->;
-
-export type ImportFileMappingRes = {
-  from: string;
-  to: string;
-  group: string;
-}[];

packages/webapp/src/containers/Import/_utils.ts

@@ -17,15 +17,13 @@ import {
 } from './ImportFileProvider';
 import { useImportFileMapBootContext } from './ImportFileMappingBoot';
 import { deepdash, transformToForm } from '@/utils';
-import { ImportFileMappingFormValues, ImportFileMappingRes } from './_types';
+import { ImportFileMappingFormValues } from './_types';
 
 export const getFieldKey = (key: string, group = '') => {
   return group ? `${group}.${key}` : key;
 };
 
-export const getDateFieldKey = (key: string, group: string = '') => {
+type ImportFileMappingRes = { from: string; to: string; group: string }[];
-  return `${getFieldKey(key, group)}.dateFormat`;
-};
 
 /**
  * Transformes the mapping form values to request.
@@ -36,10 +34,10 @@ export const transformValueToReq = (
   value: ImportFileMappingFormValues,
 ): { mapping: ImportFileMappingRes[] } => {
   const mapping = chain(value)
-    .pickBy((_value, key) => !isEmpty(_value) && _value?.from)
+    .thru(deepdash.index)
-    .map((_value, key) => ({
+    .pickBy((_value, key) => !isEmpty(get(value, key)))
-      from: _value.from,
+    .map((from, key) => ({
-      dateFormat: _value.dateFormat,
+      from,
       to: key.includes('.') ? last(key.split('.')) : key,
       group: key.includes('.') ? head(key.split('.')) : '',
     }))
@@ -54,15 +52,11 @@ export const transformValueToReq = (
  * @returns {Record<string, object | string>}
  */
 export const transformResToFormValues = (
-  value: { from: string; to: string; group: string }[],
+  value: { from: string; to: string , group: string }[],
 ): Record<string, object | string> => {
   return value?.reduce((acc, map) => {
-    const path = map?.group ? `['${map.group}.${map.to}']` : map.to;
+    const path = map?.group ? `${map.group}.${map.to}` : map.to;
-    const dateFormatObj = map?.dateFormat
+    set(acc, path, map.from);
-      ? { dateFormat: map?.dateFormat }
-      : {};
-
-    set(acc, path, { from: map?.from, ...dateFormatObj });
     return acc;
   }, {});
 };
@@ -82,10 +76,10 @@ const getInitialDefaultValues = (
       const _matched = sheetColumns.find(
         (column) => lowerCase(column) === _name,
       );
-      const path = groupKey ? `['${groupKey}.${key}']` : key;
+      const _key = groupKey ? `${groupKey}.${key}` : key;
-      const from = _matched ? _matched : '';
+      const _value = _matched ? _matched : '';
 
-      set(acc, path, { from });
+      set(acc, _key, _value);
     });
     return acc;
   }, {});
@@ -108,6 +102,7 @@ export const useImportFileMappingInitialValues = () => {
     () => getInitialDefaultValues(entityColumns, sheetColumns),
     [entityColumns, sheetColumns],
   );
+
   return useMemo<Record<string, any>>(
     () =>
       assign(

packages/webapp/src/containers/OneClickDemo/OneClickDemoPageContent.tsx

@@ -73,8 +73,9 @@ export function OneClickDemoPageContent() {
               )}
               {running && (
                 <Text className={style.waitingText}>
-                  We're preparing temporary environment for trial, It typically
+                  We're preparing the temporary environment for trial. It
-                  take few seconds. Do not close or refresh the page.
+                  typically takes a few seconds. Do not close or refresh the
+                  page.
                 </Text>
               )}
             </Stack>

packages/webapp/src/containers/Setup/WizardSetupPage.tsx

@@ -2,14 +2,17 @@
 import React from 'react';
 import SetupRightSection from './SetupRightSection';
 import SetupLeftSection from './SetupLeftSection';
+import EnsureOrganizationIsNotReady from '@/components/Guards/EnsureOrganizationIsNotReady';
 
 import '@/style/pages/Setup/SetupPage.scss';
 
 export default function WizardSetupPage() {
   return (
-    <div class="setup-page">
+    <EnsureOrganizationIsNotReady>
-      <SetupLeftSection />
+      <div class="setup-page">
-      <SetupRightSection />
+        <SetupLeftSection />
-    </div>
+        <SetupRightSection />
+      </div>
+    </EnsureOrganizationIsNotReady>
   );
-};
+}

packages/webapp/src/routes/authentication.tsx

@@ -1,43 +1,35 @@
 // @ts-nocheck
-import LazyLoader from '@/components/LazyLoader';
+import { lazy } from 'react';
 
 const BASE_URL = '/auth';
 
 export default [
   {
     path: `${BASE_URL}/login`,
-    component: LazyLoader({
+    component: lazy(() => import('@/containers/Authentication/Login')),
-      loader: () => import('@/containers/Authentication/Login'),
-    }),
   },
   {
     path: `${BASE_URL}/send_reset_password`,
-    component: LazyLoader({
+    component: lazy(
-      loader: () => import('@/containers/Authentication/SendResetPassword'),
+      () => import('@/containers/Authentication/SendResetPassword'),
-    }),
+    ),
   },
   {
     path: `${BASE_URL}/reset_password/:token`,
-    component: LazyLoader({
+    component: lazy(() => import('@/containers/Authentication/ResetPassword')),
-      loader: () => import('@/containers/Authentication/ResetPassword'),
-    }),
   },
   {
     path: `${BASE_URL}/invite/:token/accept`,
-    component: LazyLoader({
+    component: lazy(() => import('@/containers/Authentication/InviteAccept')),
-      loader: () => import('@/containers/Authentication/InviteAccept'),
-    }),
   },
   {
     path: `${BASE_URL}/register/email_confirmation`,
-    component: LazyLoader({
+    component: lazy(
-      loader: () => import('@/containers/Authentication/EmailConfirmation'),
+      () => import('@/containers/Authentication/EmailConfirmation'),
-    }),
+    ),
   },
   {
     path: `${BASE_URL}/register`,
-    component: LazyLoader({
+    component: lazy(() => import('@/containers/Authentication/Register')),
-      loader: () => import('@/containers/Authentication/Register'),
-    }),
   },
 ];

packages/webapp/src/routes/preferences.tsx

@@ -1,88 +1,96 @@
 // @ts-nocheck
 import { lazy } from 'react';
-import General from '@/containers/Preferences/General/General';
-import Users from '../containers/Preferences/Users/Users';
-import Roles from '../containers/Preferences/Users/Roles/RolesForm/RolesFormPage';
-import Accountant from '@/containers/Preferences/Accountant/Accountant';
-import Currencies from '@/containers/Preferences/Currencies/Currencies';
-import Item from '@/containers/Preferences/Item';
-// import SMSIntegration from '../containers/Preferences/SMSIntegration';
-import DefaultRoute from '../containers/Preferences/DefaultRoute';
-import Warehouses from '../containers/Preferences/Warehouses';
-import Branches from '../containers/Preferences/Branches';
-import Invoices from '../containers/Preferences/Invoices/PreferencesInvoices';
-import { PreferencesCreditNotes } from '../containers/Preferences/CreditNotes/PreferencesCreditNotes';
-import { PreferencesEstimates } from '@/containers/Preferences/Estimates/PreferencesEstimates';
-import { PreferencesReceipts } from '@/containers/Preferences/Receipts/PreferencesReceipts';
-
-import BillingPage from '@/containers/Subscriptions/BillingPage';
 
 const BASE_URL = '/preferences';
 
-export default [
+export const getPreferenceRoutes = () => [
   {
     path: `${BASE_URL}/general`,
-    component: General,
+    component: lazy(() => import('@/containers/Preferences/General/General')),
     exact: true,
   },
   {
     path: `${BASE_URL}/users`,
-    component: Users,
+    component: lazy(() => import('../containers/Preferences/Users/Users')),
     exact: true,
   },
   {
     path: `${BASE_URL}/invoices`,
-    component: Invoices,
+    component: lazy(
+      () => import('../containers/Preferences/Invoices/PreferencesInvoices'),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/credit-notes`,
-    component: PreferencesCreditNotes,
+    component: lazy(() =>
+      import(
+        '../containers/Preferences/CreditNotes/PreferencesCreditNotes'
+      ).then((module) => ({ default: module.PreferencesCreditNotes })),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/estimates`,
-    component: PreferencesEstimates,
+    component: lazy(() =>
+      import('@/containers/Preferences/Estimates/PreferencesEstimates').then(
+        (module) => ({ default: module.PreferencesEstimates }),
+      ),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/receipts`,
-    component: PreferencesReceipts,
+    component: lazy(() =>
+      import('@/containers/Preferences/Receipts/PreferencesReceipts').then(
+        (module) => ({ default: module.PreferencesReceipts }),
+      ),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/roles`,
-    component: Roles,
+    component: lazy(
+      () =>
+        import('../containers/Preferences/Users/Roles/RolesForm/RolesFormPage'),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/roles/:id`,
-    component: Roles,
+    component: lazy(
+      () =>
+        import('../containers/Preferences/Users/Roles/RolesForm/RolesFormPage'),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/currencies`,
-    component: Currencies,
+    component: lazy(
+      () => import('@/containers/Preferences/Currencies/Currencies'),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/warehouses`,
-    component: Warehouses,
+    component: lazy(() => import('../containers/Preferences/Warehouses')),
     exact: true,
   },
   {
     path: `${BASE_URL}/branches`,
-    component: Branches,
+    component: lazy(() => import('../containers/Preferences/Branches')),
     exact: true,
   },
   {
     path: `${BASE_URL}/accountant`,
-    component: Accountant,
+    component: lazy(
+      () => import('@/containers/Preferences/Accountant/Accountant'),
+    ),
     exact: true,
   },
   {
     path: `${BASE_URL}/items`,
-    component: Item,
+    component: lazy(() => import('@/containers/Preferences/Item')),
     exact: true,
   },
   // {
@@ -92,12 +100,12 @@ export default [
   // },
   {
     path: `${BASE_URL}/billing`,
-    component: BillingPage,
+    component: lazy(() => import('@/containers/Subscriptions/BillingPage')),
     exact: true,
   },
   {
     path: `${BASE_URL}/`,
-    component: DefaultRoute,
+    component: lazy(() => import('../containers/Preferences/DefaultRoute')),
     exact: true,
   },
 ];