@solidstarters/solid-core 1.2.92 → 1.2.95

package/src/services/import-transaction.service.ts

@@ -11,15 +11,18 @@ import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
+import { classify } from '@angular-devkit/core/src/utils/strings';
 import { HttpService } from '@nestjs/axios';
-import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
+import { RelationFieldsCommand, RelationType, SolidFieldType } from 'src/dtos/create-field-metadata.dto';
 import { ImportInstructionsResponseDto, StandardImportInstructionsResponseDto } from 'src/dtos/import-instructions.dto';
 import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { MediaWithFullUrl } from 'src/interfaces';
 import { Readable } from 'stream';
 import { ImportTransaction } from '../entities/import-transaction.entity';
 import { CsvService } from './csv.service';
 import { ExcelService } from './excel.service';
+import { SolidIntrospectService } from './solid-introspect.service';
 
 interface ImportTemplateFileInfo {
   stream: NodeJS.ReadableStream;
@@ -45,11 +48,16 @@ export interface ImportableFieldInfo {
   displayName: string;
 }
 
-export interface ImportReadResult {
+export interface ImportPaginatedReadResult {
   headers: string[]; // Headers of the CSV file
   data: Record<string, any>[]; // Data records in the current page
 }
 
+interface ImportMapping {
+  header: string; // The name of the field in the import file
+  fieldName: string; // The name of the field in the model metadata to which the imported field is mapped
+}
+
 @Injectable()
 export class ImportTransactionService extends CRUDService<ImportTransaction> {
   constructor(
@@ -66,96 +74,56 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     readonly moduleRef: ModuleRef,
     readonly excelService: ExcelService,
     readonly csvService: CsvService,
-    readonly httpService: HttpService
-
+    readonly httpService: HttpService,
+    readonly introspectService: SolidIntrospectService,
+    // readonly fieldMetadataService: FieldMetadataService,
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'importTransaction', 'solid-core', moduleRef);
   }
 
   private readonly logger = new Logger(ImportTransactionService.name);
-  saveImportMapping(arg0: number) {
-    throw new Error('Method not implemented.');
-  }
 
-  async getImportMappingInfo(importTransactionId: number): Promise<ImportMappingInfo> {
-    // Load the import transaction for the given ID
-    const importTransaction = await this.findOne(importTransactionId, {
-      populate: ['modelMetadata', 'modelMetadata.fields'],
-      populateMedia: ['fileLocation'],
+  /**
+ * This method is used to return a csv / excel template for the import transaction
+ * It will contain the display names of the fields in the header row
+ * @param modelMetadataId 
+ */
+  async getImportTemplate(modelMetadataId: number, format: ImportFormat = ImportFormat.CSV): Promise<ImportTemplateFileInfo> {
+    // Load the model metadata for the given ID
+    const modelMetadata = await this.modelMetadataService.findOne(modelMetadataId, {
+      populate: ['fields'],
     });
-    if (!importTransaction) {
-      throw new Error(`Import transaction with ID ${importTransactionId} not found.`);
-    }
-
-    // Get all the importable fields from the model metadata
-    const importableFields: ImportableFieldInfo[] = this.fieldsAllowedForImport(importTransaction.modelMetadata.fields).map(field => ({
-      name: field.name,
-      displayName: field.displayName,
-    }));
-
-    // Get the import file stream for the import transaction
-    const importFileMediaObject = importTransaction['_media']['fileLocation'][0] as MediaWithFullUrl; // Since there can be only one fileLocation, we can safely access the first element
-    if (!importFileMediaObject) {
-      throw new Error(`Import file for transaction ID ${importTransactionId} not found.`);
-    }
-    const importFileStream = await this.getImportFileStream(importFileMediaObject);
-
-    // Get a sample of records from the import file
-    const sampleRecord = await this.getFileRecordsSample(importFileStream, importFileMediaObject.mimeType);
-
-    // Convert sampleRecord to the format required for SampleImportedRecordInfo
-    const wrappedRecords: SampleImportedRecordInfo[] = sampleRecord.data.map((record: Record<string, any>) => {
-      return Object.entries(record).map(([key, value]) => ({
-        cellHeader: key,
-        cellValue: value,
-        defaultMappedFieldName: importableFields.find(field => field.displayName === key)?.name || '',
-      }));
-    }).flat();
-
-    //     for await (const page of this.csvService.readCsvInPagesFromStream(importFileStream)) {
-    //   // await dbService.bulkInsert(page);
-    // }
-
-    return {
-      sampleImportedRecordInfo: wrappedRecords, // This will hold the sample data from the file
-      importableFields: importableFields, // This will hold the fields that can be imported
-    };
-  }
-
-  private async getFileRecordsSample(importFileStream: Readable, mimeType: string): Promise<ImportReadResult> {
-    // Depending upon the mime type of the file, read the file in pages
-    // For CSV files, use the csvService to read the file in pages
-    // For Excel files, use the excelService to read the file in pages
-    if (mimeType === 'text/csv') {
-      const generator = this.csvService.readCsvInPagesFromStream(importFileStream, { pageSize: 1 });
-      const firstRecord = await generator.next(); // Get the first record to extract headers and sample data
-      return firstRecord.value;
-    } else if (mimeType === 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') {
-      const generator = this.excelService.readExcelInPagesFromStream(importFileStream, { pageSize: 1 });
-      const firstRecord = await generator.next(); // Get the first record to extract headers and sample data
-      return firstRecord.value;
-    }
-    else { // If the file is neither CSV nor Excel, throw an error
-      throw new Error(`Unsupported file type: ${mimeType}`);
+    if (!modelMetadata) {
+      throw new Error(`Model metadata with ID ${modelMetadataId} not found.`);
     }
-  }
+    // Create a header row with the display names of the fields, excluding the media fields,computed fields
+    const headers = this.fieldsAllowedForImport(modelMetadata.fields)
+      .map(field => field.displayName);
 
-  private async getImportFileStream(importFileMediaObject: MediaWithFullUrl): Promise<Readable> {
-    const fileUrl = importFileMediaObject['_full_url'];
-    const mimeType = importFileMediaObject['mimeType'];
-    if (!fileUrl) {
-      throw new Error(`File URL  ${fileUrl} not found.`);
+    // Depending on the format, generate the template
+    if (format === ImportFormat.CSV) {
+      const stream = await this.csvService.createCsvStream(null, 0, headers); // Create a CSV stream with the header row
+      const fileName = `${modelMetadata.singularName}-import-template.csv`;
+      const mimeType = 'text/csv';
+      return {
+        stream,
+        fileName,
+        mimeType,
+      };
+    } else if (format === ImportFormat.EXCEL) {
+      const stream = await this.excelService.createExcelStream(null, 0, headers); // Create an Excel stream with the header row
+      const fileName = `${modelMetadata.singularName}-import-template.xlsx`;
+      // Set the MIME type for Excel files
+      const mimeType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+      return {
+        stream,
+        fileName,
+        mimeType,
+      };
+    } else {
+      throw new Error(`Unsupported import format: ${format}`);
     }
-    // From the file URL, convert the file URL to a readable stream using nestjs http service and axios
-    const fileUrlResponse = await this.httpService.axiosRef.get(fileUrl, {
-      responseType: 'stream',
-    });
 
-    if (!fileUrlResponse || !fileUrlResponse.data) {
-      throw new Error(`Failed to read file from URL: ${fileUrl}`);
-    }
-    // fileUrlResponse.data is a Node.js Readable stream
-    return fileUrlResponse.data;
   }
 
   async getImportInstructions(modelMetadataId: number): Promise<ImportInstructionsResponseDto> {
@@ -220,47 +188,76 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     };
   }
 
-  /**
-   * This method is used to return a csv / excel template for the import transaction
-   * It will contain the display names of the fields in the header row
-   * @param modelMetadataId 
-   */
-  async getImportTemplate(modelMetadataId: number, format: ImportFormat = ImportFormat.CSV): Promise<ImportTemplateFileInfo> {
-    // Load the model metadata for the given ID
-    const modelMetadata = await this.modelMetadataService.findOne(modelMetadataId, {
-      populate: ['fields'],
-    });
-    if (!modelMetadata) {
-      throw new Error(`Model metadata with ID ${modelMetadataId} not found.`);
-    }
-    // Create a header row with the display names of the fields, excluding the media fields,computed fields
-    const headers = this.fieldsAllowedForImport(modelMetadata.fields)
-      .map(field => field.displayName);
+  async getImportMappingInfo(importTransactionId: number): Promise<ImportMappingInfo> {
+    // Load the import transaction for the given ID
+    const importTransaction = await this.loadImportTransaction(importTransactionId);
 
-    // Depending on the format, generate the template
-    if (format === ImportFormat.CSV) {
-      const stream = await this.csvService.createCsvStream(null, 0, headers); // Create a CSV stream with the header row
-      const fileName = `${modelMetadata.singularName}-import-template.csv`;
-      const mimeType = 'text/csv';
-      return {
-        stream,
-        fileName,
-        mimeType,
-      };
-    } else if (format === ImportFormat.EXCEL) {
-      const stream = await this.excelService.createExcelStream(null, 0, headers); // Create an Excel stream with the header row
-      const fileName = `${modelMetadata.singularName}-import-template.xlsx`;
-      // Set the MIME type for Excel files
-      const mimeType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
-      return {
-        stream,
-        fileName,
-        mimeType,
-      };
-    } else {
-      throw new Error(`Unsupported import format: ${format}`);
-    }
+    // Get all the importable fields from the model metadata
+    const importableFields: ImportableFieldInfo[] = this.fieldsAllowedForImport(importTransaction.modelMetadata.fields).map(field => ({
+      name: field.name,
+      displayName: field.displayName,
+    }));
+
+    // Get the import file media object from the import transaction
+    const importFileMediaObject = this.getImportFileObject(importTransaction);
+
+    // Get the import file stream for the import transaction
+    const importFileStream = await this.getImportFileStream(importFileMediaObject);
+
+    // Get a sample of records from the import file
+    const sampleRecord = await this.getFileRecordsSample(importFileStream, importFileMediaObject.mimeType);
+
+    // Convert sampleRecord to the format required for SampleImportedRecordInfo
+    const wrappedRecords: SampleImportedRecordInfo[] = sampleRecord.data.map((record: Record<string, any>) => {
+      return Object.entries(record).map(([key, value]) => ({
+        cellHeader: key,
+        cellValue: value,
+        defaultMappedFieldName: importableFields.find(field => field.displayName === key)?.name || '',
+      }));
+    }).flat();
+
+    //     for await (const page of this.csvService.readCsvInPagesFromStream(importFileStream)) {
+    //   // await dbService.bulkInsert(page);
+    // }
+
+    return {
+      sampleImportedRecordInfo: wrappedRecords, // This will hold the sample data from the file
+      importableFields: importableFields, // This will hold the fields that can be imported
+    };
+  }
+
+  async startImportSync(importTransactionId: number): Promise<Array<number>> {
+    // Load the import transaction for the given ID
+    const importTransaction = await this.loadImportTransaction(importTransactionId);
+
+    // Get the import file media object from the import transaction
+    const importFileMediaObject = this.getImportFileObject(importTransaction);
+
+    // Get the import file stream for the import transaction
+    const importFileStream = await this.getImportFileStream(importFileMediaObject);
+
+    const ids = await this.writeFileRecordsToDb(
+      importFileStream,
+      importFileMediaObject.mimeType,
+      JSON.parse(importTransaction.mapping) as ImportMapping[], // Parse the mapping from the import transaction
+      importTransaction.modelMetadata,
+    );
+    return ids; // Return the IDs of the created records
+  }
 
+  startImportAsync(importTransactionId: number): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+
+  private async loadImportTransaction(importTransactionId: number) {
+    const importTransaction = await this.findOne(importTransactionId, {
+      populate: ['modelMetadata', 'modelMetadata.fields'],
+      populateMedia: ['fileLocation'],
+    });
+    if (!importTransaction) {
+      throw new Error(`Import transaction with ID ${importTransactionId} not found.`);
+    }
+    return importTransaction;
   }
 
   private fieldsAllowedForImport(fields: FieldMetadata[]): FieldMetadata[] {
@@ -276,6 +273,201 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     );
   }
 
+  private async getFileRecordsSample(importFileStream: Readable, mimeType: string): Promise<ImportPaginatedReadResult> {
+    // Depending upon the mime type of the file, read the file in pages
+    // For CSV files, use the csvService to read the file in pages
+    // For Excel files, use the excelService to read the file in pages
+    if (mimeType === 'text/csv') {
+      const generator = this.csvService.readCsvInPagesFromStream(importFileStream, { pageSize: 1 });
+      const firstRecord = await generator.next(); // Get the first record to extract headers and sample data
+      return firstRecord.value;
+    } else if (mimeType === 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') {
+      const generator = this.excelService.readExcelInPagesFromStream(importFileStream, { pageSize: 1 });
+      const firstRecord = await generator.next(); // Get the first record to extract headers and sample data
+      return firstRecord.value;
+    }
+    else { // If the file is neither CSV nor Excel, throw an error
+      throw new Error(`Unsupported file type: ${mimeType}`);
+    }
+  }
+
+  private getImportFileObject(importTransaction: ImportTransaction): MediaWithFullUrl {
+    const importFileMediaObject = importTransaction['_media']['fileLocation'][0] as MediaWithFullUrl; // Since there can be only one fileLocation, we can safely access the first element
+    if (!importFileMediaObject) {
+      throw new Error(`Import file for transaction ID ${importTransaction.id} not found.`);
+    }
+    return importFileMediaObject;
+  }
 
+  private async getImportFileStream(importFileMediaObject: MediaWithFullUrl): Promise<Readable> {
+    const fileUrl = importFileMediaObject['_full_url'];
+    const mimeType = importFileMediaObject['mimeType'];
+    if (!fileUrl) {
+      throw new Error(`File URL  ${fileUrl} not found.`);
+    }
+    // From the file URL, convert the file URL to a readable stream using nestjs http service and axios
+    const fileUrlResponse = await this.httpService.axiosRef.get(fileUrl, {
+      responseType: 'stream',
+    });
 
-}
+    if (!fileUrlResponse || !fileUrlResponse.data) {
+      throw new Error(`Failed to read file from URL: ${fileUrl}`);
+    }
+    // fileUrlResponse.data is a Node.js Readable stream
+    return fileUrlResponse.data;
+  }
+
+  private async writeFileRecordsToDb(
+    importFileStream: Readable,
+    mimeType: string,
+    mapping: ImportMapping[],
+    modelMetadataWithFields: ModelMetadata,
+  ): Promise<Array<number>> {
+    // Get the model service for the model metadata name
+    const modelService = this.getModelService(modelMetadataWithFields.singularName);
+
+    // Depending upon the mime type of the file, read the file in pages
+    // For CSV files, use the csvService to read the file in pages
+    // For Excel files, use the excelService to read the file in pages
+    if (mimeType === 'text/csv') {
+      // Read the csv file in pages
+      for await (const page of this.csvService.readCsvInPagesFromStream(importFileStream)) {
+        // Convert the paginated result to DTOs
+        const dtos = await this.convertPaginatedResultToDtos(page, modelMetadataWithFields, mapping);
+        // Use the model service to create the records in the database
+        const createdRecords = await modelService.insertMany(dtos, [], {});
+        // Set the solidRequestContext to null, as this is a background job;
+        // Return the IDs of the created records
+        return createdRecords.map(record => record.id);
+      }
+    }
+    else if (mimeType === 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') {
+      // Read the excel file in pages
+      for await (const page of this.excelService.readExcelInPagesFromStream(importFileStream)) {
+        // Convert the paginated result to DTOs
+        const dtos = await this.convertPaginatedResultToDtos(page, modelMetadataWithFields, mapping);
+        // Use the model service to create the records in the database
+        const createdRecords = await modelService.insertMany(dtos, [], {});
+        // Set the solidRequestContext to null, as this is a background job;
+        // Return the IDs of the created records
+        return createdRecords.map(record => record.id);
+      }
+    } else { // If the file is neither CSV nor Excel, throw an error
+      throw new Error(`Unsupported file type: ${mimeType}`);
+    }
+  }
+
+  private getModelService(modelSingularName: string): CRUDService<any> {
+    // Get the model service for the model metadata name
+    const modelServiceWrapper = this.introspectService.getProvider(`${classify(modelSingularName)}Service`);
+    const modelService = modelServiceWrapper.instance as CRUDService<any>;
+    if (!modelService) {
+      throw new Error(`Model service for ${modelSingularName} not found.`);
+    }
+    return modelService;
+  }
+
+  // This method will 
+  private async convertPaginatedResultToDtos(importPaginatedResult: ImportPaginatedReadResult, modelMetadataWithFields: ModelMetadata, mapping: ImportMapping[]) {
+    const dtos = [];
+    // Iterate through the data records in the importPaginatedResult
+    for (const record of importPaginatedResult.data) {
+      // For every key in the record, get the corresponding field from the mapping, if the field is not found in mapping, skip the field
+      const dto = await this.convertImportedRecordToDto(record, mapping, modelMetadataWithFields);
+      dtos.push(dto);
+    }
+    return dtos;
+  }
+
+  private async convertImportedRecordToDto(record: Record<string, any>, mapping: ImportMapping[], modelMetadataWithFields: ModelMetadata) {
+    // Create a new record object
+    const dtoRecord: Record<string, any> = {};
+
+    // Using the saved mapping, populate the dtoRecord w.r.t the record and fields
+    for (const key in record) {
+      const mappedField = mapping.find(m => m.header === key);
+      if (mappedField) {
+        // If the field is found in the mapping, get the field metadata from the model metadata
+        const fieldMetadata = modelMetadataWithFields.fields.find(f => f.name === mappedField.fieldName);
+        // const userKeyField = modelMetadataWithFields.fields.find(f => f.isUserKey === true); // Assuming userKey is a field in the model metadata
+        if (fieldMetadata) {
+          // If the field is found in the model metadata, set the value in the dtoRecord
+          await this.populateDto(dtoRecord, fieldMetadata, record, key);
+        } else {
+          this.logger.warn(`Field ${mappedField.fieldName} not found in model metadata ${modelMetadataWithFields.singularName}`);
+        }
+      }
+    }
+    return dtoRecord;
+  }
+
+  private async populateDto(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string): Promise<Record<string, any>> {
+    const fieldType = fieldMetadata.type;
+    // const userKeyFieldName = userKeyField?.name || 'id'; // Default to 'id' if not found
+
+    switch (fieldType) {
+      case SolidFieldType.relation: {
+        return await this.populateDtoForRelations(fieldMetadata, record, key, dtoRecord);
+      }
+      case SolidFieldType.date: return this.populateDtoForDate(record, key, fieldMetadata, dtoRecord);
+      case SolidFieldType.datetime: return this.populateDtoForDate(record, key, fieldMetadata, dtoRecord);
+      default:
+        dtoRecord[fieldMetadata.name] = record[key];
+        return dtoRecord;
+    }
+  }
+
+  private populateDtoForDate(record: Record<string, any>, key: string, fieldMetadata: FieldMetadata, dtoRecord: Record<string, any>) {
+    {
+      const dateValue = new Date(record[key]);
+      if (isNaN(dateValue.getTime())) {
+        throw new Error(`Invalid date value for field ${fieldMetadata.name}: ${record[key]}`);
+      }
+      dtoRecord[fieldMetadata.name] = dateValue;
+      return dtoRecord;
+    }
+  }
+
+  private async populateDtoForRelations(fieldMetadata: FieldMetadata, record: Record<string, any>, key: string, dtoRecord: Record<string, any>) {
+    if (!fieldMetadata.relationCoModelSingularName) {
+      throw new Error(`Relation coModelSingularName is not defined for relation field ${fieldMetadata.name}`);
+    }
+
+    const relatedRecordsIds = await this.getRelatedEntityIdsFromUserKeys(fieldMetadata, record, key);
+
+    if (fieldMetadata.relationType === RelationType.manyTomany || fieldMetadata.relationType === RelationType.oneToMany) {
+      dtoRecord[`${fieldMetadata.name}Ids`] = relatedRecordsIds;
+      dtoRecord[`${fieldMetadata.name}Command`] = RelationFieldsCommand.set; // Reset the relation field association with the related records IDs
+    }
+    else if (fieldMetadata.relationType === RelationType.manyToOne) {
+      dtoRecord[`${fieldMetadata.name}Id`] = relatedRecordsIds.pop(); // For many-to-one relations, we need only one ID
+    }
+    return dtoRecord;
+  }
+
+  private async getRelatedEntityIdsFromUserKeys(fieldMetadata: FieldMetadata, record: Record<string, any>, key: string): Promise<Array<number>> {
+    const coModelService = this.getModelService(fieldMetadata.relationCoModelSingularName);
+    const coModelWithUserKeyField = await this.modelMetadataService.findOneBySingularName(fieldMetadata.relationCoModelSingularName, ['userKeyField']);
+    const coModelUserKeyFieldName = coModelWithUserKeyField?.userKeyField?.name || 'id'; // Default to 'id' if not found
+
+    // For many-to-many or one-to-many relations, we expect the record cell to contains a comma-separated list of userKeys
+    const relationUserKeys = record[key] ? String(record[key]).split(',').map((userKey: string) => userKey.trim()) : [];
+
+    // Set the relation basic filter dto filters with the userkeys and call the find method of the model service to get the related records
+    const relationFilterDto = {
+      filters: {
+        [coModelUserKeyFieldName]: {
+          $in: relationUserKeys, // Use the userKeyFieldName to filter by userKeys
+        },
+      },
+    };
+
+    // From the userKeys, we will get the IDs of the related records using the userKeyFieldName and throw an error if any of the userKeys is not found
+    const relatedRecordsResult = await coModelService.find(relationFilterDto);
+    if (!relatedRecordsResult || !relatedRecordsResult.records || relatedRecordsResult.records.length === 0 || relatedRecordsResult.records.length !== relationUserKeys.length) {
+      throw new Error(`Missing related records found for userKeys: ${relationUserKeys.join(', ')} in model ${fieldMetadata.relationCoModelSingularName}`);
+    }
+    const relatedRecordsIds = relatedRecordsResult.records.map(record => record.id);
+    return relatedRecordsIds;
+  }
+}

package/src/services/locale.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef  } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from 'src/services/file.service';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { RequestContextService } from './request-context.service';
+import { Locale } from 'src/entities/locale.entity';
+@Injectable()
+export class LocaleService extends CRUDService<Locale>{
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(Locale, 'default')
+    readonly repo: Repository<Locale>,
+    @InjectRepository(Locale, 'default')
+    readonly moduleRef: ModuleRef,
+    @InjectRepository(ModelMetadata)
+    private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    readonly requestContextService: RequestContextService
+ ) {
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'locale', 'solid-core', moduleRef);
+ }
+
+}

package/src/services/mediaStorageProviders/file-storage-provider.ts

@@ -45,7 +45,7 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
             await this.fileService.deleteFile(file.path);
 
             // Create an entry in the media table
-            const mediaEntity = await this.mediaRepository.createMedia({
+        const mediaEntity = await this.mediaRepository.createMedia({
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: this.getFileName(file),

package/src/services/menu-item-metadata.service.ts

@@ -178,6 +178,8 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
         title: rootItem.displayName || rootItem.name,
         path: path,
         key: rootItem.name.toLowerCase().replace(/\s+/g, '-'),
+        icon : rootItem.iconName,
+        // iconVariant : rootItem.iconVariant
       }
       if (children.length > 0) {
         data["children"] = this.buildMenuTree(children, allMenuItems, activeUser);

package/src/services/pending_import_issues

@@ -0,0 +1,3 @@
+1. fileLocation -> file
+2. Change the import response to return proper shape.
+3. Change the urls to reflect proper semantics.

package/src/services/selection-providers/locale-list-selection-provider.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from "@nestjs/common";
+import { ModelMetadataService } from "src/services/model-metadata.service";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
+// import localeCodes from 'locale-codes';
+import * as locale from 'locale-codes'
+
+
+@SelectionProvider()
+@Injectable()
+export class LocaleListSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
+
+    constructor() {
+    }
+
+    help(): string {
+        return "# Gets all locales available to the user";
+    }
+
+    name(): string {
+        return 'LocaleListSelectionProvider';
+    }
+
+    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
+        const locales = locale.all
+            .filter(code => code.tag === optionValue)
+            .map(code => ({ label: `${code.name} (${code.tag})`, value: code.tag }));
+
+        return locales.length > 0 ? locales[0] : null;
+    }
+
+    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+
+        const locales = locale.all
+            .filter(code => {
+                // Look at the documentation here - https://www.npmjs.com/package/locale-codes
+                // In this if you check the section - https://www.npmjs.com/package/locale-codes#locale-list
+
+                // We disabled this because this was not returning the basic locale codes like 'en', 'fr', etc.
+                // We are only interested in the locales that have a tag with a hyphen (-) in it.
+                // if (code.tag.includes('-')) {
+                if (query) {
+                    const lowerCaseQuery = query.toLowerCase();
+                    return code.name.toLowerCase().includes(lowerCaseQuery) || code.tag.toLowerCase().includes(lowerCaseQuery);
+                }
+                return true;
+                // }
+                return false;
+            })
+            .map(code => ({
+                label: `${code.name} (${code.tag})`,
+                value: code.tag,
+            }));
+
+        return locales;
+
+    }
+}

package/src/services/setting.service.ts

@@ -59,7 +59,8 @@ export class SettingService extends CRUDService<Setting> {
       defaultRole: this.iamConfiguration.defaultRole,
       shouldQueueEmails: this.commonConfiguration.shouldQueueEmails,
       shouldQueueSms: this.commonConfiguration.shouldQueueSms,
-      enableDarkMode: true
+      enableDarkMode: true,
+      copyright : ""
     };
 
     const existingSettings = await this.repo.find();
@@ -140,7 +141,8 @@ export class SettingService extends CRUDService<Setting> {
       defaultRole: this.iamConfiguration.defaultRole,
       shouldQueueEmails: this.commonConfiguration.shouldQueueEmails,
       shouldQueueSms: this.commonConfiguration.shouldQueueSms,
-      enableDarkMode: true
+      enableDarkMode: true,
+      copyright : ""
     };
   }