@solidstarters/solid-core 1.2.191 → 1.2.192

package/src/services/crud.service.ts

@@ -1,8 +1,12 @@
-import { BadRequestException, Inject, NotFoundException, Optional } from "@nestjs/common";
-import { ConfigService, ConfigType } from "@nestjs/config";
+import { BadRequestException, NotFoundException } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
-import { Repository } from "typeorm/repository/Repository";
+import { isArray } from "class-validator";
+import { CommonEntity, SolidBaseRepository } from "src";
+import { ERROR_MESSAGES } from "src/constants/error-messages";
+import { SUCCESS_MESSAGES } from "src/constants/success-messages";
+import { EntityManager, FindOptionsWhere, In, IsNull, Not, QueryFailedError, SelectQueryBuilder } from "typeorm";
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 import { BasicFilterDto } from "../dtos/basic-filters.dto";
 import { ComputedFieldValueType, RelationType, SelectionValueType, SolidFieldType } from "../dtos/create-field-metadata.dto";
 import { MediaStorageProviderType } from "../dtos/create-media-storage-provider-metadata.dto";
@@ -31,16 +35,13 @@ import { UUIDFieldCrudManager } from "../helpers/field-crud-managers/UUIDFieldCr
 import { FieldCrudManager, MediaWithFullUrl } from "../interfaces";
 import { CrudHelperService } from "./crud-helper.service";
 import { FileService } from "./file.service";
+import { HashingService } from "./hashing.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
-import { isArray } from "class-validator";
-import { ERROR_MESSAGES } from "src/constants/error-messages";
-import { SUCCESS_MESSAGES } from "src/constants/success-messages";
 import { RequestContextService } from "./request-context.service";
-import { HashingService } from "./hashing.service";
 
-export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
+export class CRUDService<T extends CommonEntity> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
 
     constructor(
         readonly modelMetadataService: ModelMetadataService,
@@ -50,7 +51,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         readonly discoveryService: DiscoveryService,
         readonly crudHelperService: CrudHelperService,
         readonly entityManager: EntityManager,
-        readonly repo: Repository<T>,
+        readonly repo: SolidBaseRepository<T>,
         readonly modelName: string,
         readonly moduleName: string,
         readonly moduleRef: ModuleRef,
@@ -87,7 +88,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             // 5. Save the entity
             // For media, we need to use a storage provider and save the media, then save the associated uri against the entity or media table
             const entity = this.repo.create(createDto);
-            const savedEntity = await this.repo.save(entity) as T;
+            const savedEntity = await this.repo.save(entity) as unknown as T;
 
             // 6. Save the media
             if (hasMediaFields) {
@@ -170,9 +171,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
         const entity = await this.repo.findOne({
             where: {
-                //@ts-ignore
                 id: id,
-            }
+            } as unknown as FindOptionsWhere<T>,
         });
         if (!entity) {
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
@@ -231,10 +231,10 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         });
         const entity = await this.repo.findOne({
             where: {
-                //@ts-ignore
                 id: id,
-            }
-        });
+            } as unknown as FindOptionsWhere<T>,
+        }
+        );
         if (!entity) {
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
@@ -444,7 +444,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         requestContextService.setRequestFilter(basicFilterDto);
 
         // Create above query on pincode table using query builder
-        var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
+        var qb: SelectQueryBuilder<T> = await this.repo.createSecurityRuleAwareQueryBuilder(alias)
         qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
         if (internationalisation && draftPublishWorkflow) {
             qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef);
@@ -493,7 +493,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // For each group, get the records and the count
         for (const group of groupByResult) {
             if (populateGroup) {
-                let groupByQb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias);
+                let groupByQb: SelectQueryBuilder<T> = await this.repo.createSecurityRuleAwareQueryBuilder(alias);
                 groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias);
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
@@ -638,9 +638,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
         let entity = await this.repo.findOne({
             where: {
-                //@ts-ignore
                 id: id,
-            },
+            } as unknown as FindOptionsWhere<T>,
             relations: normalizedPopulate,
             select: fields,
         });
@@ -688,7 +687,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 transformedDto = await fieldManager.transformForCreate(createDto);
             }
             const entity = this.repo.create(transformedDto);
-            entitiesForSave.push(entity as T);
+            entitiesForSave.push(entity as unknown as T);
         }
         // Save all entities in a single batch
         const savedEntities = await this.repo.save(entitiesForSave) as T[];
@@ -729,9 +728,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             const id = ids[i]
             const entity = await this.repo.findOne({
                 where: {
-                    //@ts-ignore
                     id: id,
-                }
+                } as unknown as FindOptionsWhere<T>,
             });
             removedEntities.push(entity);
         }
@@ -757,9 +755,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
             const softDeletedRows = await this.repo.findOne({
                 where: {
-                    //@ts-ignore
                     id, deletedAt: Not(IsNull())
-                },
+                } as unknown as FindOptionsWhere<T>,
                 withDeleted: true,
             });
 
@@ -768,9 +765,9 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             }
 
             await this.repo.update(id, {
-                //@ts-ignore
                 deletedAt: null, deletedTracker: "not-deleted"
-            });
+            } as unknown as QueryDeepPartialEntity<T>
+         );
 
             return { message: SUCCESS_MESSAGES.RECORD_RECOVERED, data: softDeletedRows };
         } catch (error) {
@@ -802,10 +799,9 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
             // Find soft-deleted records matching the given IDs
             const softDeletedRows = await this.repo.find({
                 where: {
-                    //@ts-ignore
                     id: In(ids),
                     deletedAt: Not(IsNull()),
-                },
+                } as unknown as FindOptionsWhere<T>,
                 withDeleted: true,
             });
 
@@ -815,9 +811,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
             // Recover the specific records by setting deletedAt to null
             await this.repo.update(
-                //@ts-ignore
-                { id: In(ids) },
-                { deletedAt: null, deletedTracker: "not-deleted" }
+                { id: In(ids) } as unknown as FindOptionsWhere<T>,
+                { deletedAt: null, deletedTracker: "not-deleted" } as unknown as QueryDeepPartialEntity<T>
             );
 
             return { message: SUCCESS_MESSAGES.SELECTED_RECORDS_RECOVERED, recoveredIds: ids };

package/src/services/dashboard-question-sql-dataset-config.service.ts

@@ -12,6 +12,7 @@ import { CrudHelperService } from 'src/services/crud-helper.service';
 
 
 import { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
+import { DashboardQuestionSqlDatasetConfigRepository } from 'src/repository/dashboard-question-sql-dataset-config.repository';
 
 @Injectable()
 export class DashboardQuestionSqlDatasetConfigService extends CRUDService<DashboardQuestionSqlDatasetConfig>{
@@ -24,8 +25,9 @@ export class DashboardQuestionSqlDatasetConfigService extends CRUDService<Dashbo
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(DashboardQuestionSqlDatasetConfig, 'default')
-    readonly repo: Repository<DashboardQuestionSqlDatasetConfig>,
+    // @InjectRepository(DashboardQuestionSqlDatasetConfig, 'default')
+    // readonly repo: Repository<DashboardQuestionSqlDatasetConfig>,
+    readonly repo: DashboardQuestionSqlDatasetConfigRepository,
     readonly moduleRef: ModuleRef
 
  ) {

package/src/services/dashboard-question.service.ts

@@ -17,6 +17,7 @@ import { DashboardQuestion } from '../entities/dashboard-question.entity';
 import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
 import { DashboardService } from './dashboard.service';
 import { Dashboard } from 'src/entities/dashboard.entity';
+import { DashboardQuestionRepository } from 'src/repository/dashboard-question.repository';
 
 enum SOURCE_TYPE {
   SQL = 'sql',
@@ -39,8 +40,9 @@ export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(DashboardQuestion, 'default')
-    readonly repo: Repository<DashboardQuestion>,
+    // @InjectRepository(DashboardQuestion, 'default')
+    // readonly repo: Repository<DashboardQuestion>,
+    readonly repo: DashboardQuestionRepository,
     readonly moduleRef: ModuleRef,
     readonly solidRegistry: SolidRegistry, // Assuming solidRegistry is injected for data providers
   ) {

package/src/services/dashboard-variable.service.ts

@@ -12,6 +12,8 @@ import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 
 import { DashboardVariable } from '../entities/dashboard-variable.entity';
+import { Dashboard } from 'src/entities/dashboard.entity';
+import { DashboardVariableRepository } from 'src/repository/dashboard-variable.repository';
 
 @Injectable()
 export class DashboardVariableService extends CRUDService<DashboardVariable> {
@@ -25,8 +27,9 @@ export class DashboardVariableService extends CRUDService<DashboardVariable> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(DashboardVariable, 'default')
-    readonly repo: Repository<DashboardVariable>,
+    // @InjectRepository(DashboardVariable, 'default')
+    // readonly repo: Repository<DashboardVariable>,
+    readonly repo: DashboardVariableRepository,
     readonly moduleRef: ModuleRef,
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'dashboardVariable', 'solid-core', moduleRef);

package/src/services/docker exec -it mssql //"

@@ -0,0 +1,8 @@
+docker exec -it mssql \
+  /opt/mssql-tools18/bin/sqlcmd \
+  -S localhost \
+  -U sa \
+  -P 'YourStrong!Passw0rd' \
+  -d mswipe_erp_solidx \
+  -C -b -r1 -e \
+  -i /tmp/ReportsAndHRMS.sql

package/src/services/email-template.service.ts

@@ -15,6 +15,7 @@ import { FileService } from './file.service';
 import { MediaService } from './media.service';
 import { DiscoveryService, ModuleRef } from '@nestjs/core';
 import { CrudHelperService } from './crud-helper.service';
+import { EmailTemplateRepository } from 'src/repository/email-template.repository';
 
 @Injectable()
 export class EmailTemplateService extends CRUDService<EmailTemplate>{
@@ -29,8 +30,9 @@ export class EmailTemplateService extends CRUDService<EmailTemplate>{
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(EmailTemplate, 'default')
-    readonly repo: Repository<EmailTemplate>,
+    // @InjectRepository(EmailTemplate, 'default')
+    // readonly repo: Repository<EmailTemplate>,
+    readonly repo: EmailTemplateRepository,
     readonly moduleRef: ModuleRef,
     ) {
         super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'emailTemplate', 'app-builder', moduleRef);

package/src/services/export-template.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { ForbiddenException, Injectable } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { EntityManager, Repository } from 'typeorm';
@@ -19,11 +19,28 @@ import { Readable } from 'stream';
 import { ExportTemplate } from '../entities/export-template.entity';
 import { ExportTransactionFileInfo, ExportTransactionService } from './export-transaction.service';
 import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
+import { ExportTemplateRepository } from 'src/repository/export-template.repository';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+import {upperFirst, camelCase} from 'lodash';
 
 @Injectable()
 export class ExportTemplateService extends CRUDService<ExportTemplate>{
-  async startExportSync(updateDto: UpdateExportTemplateDto, filters:any): Promise<ExportTransactionFileInfo> {
+  async startExportSync(updateDto: UpdateExportTemplateDto, filters:any,  activeUser: ActiveUserData): Promise<ExportTransactionFileInfo> {
     // Create the export transaction entry, with status 'started'
+    const modelMetadata = await this.modelMetadataService.findOne(updateDto?.modelMetadataId);
+    const modelName = upperFirst(camelCase(modelMetadata.singularName));
+    const permissionKey = `${modelName}Controller.findMany`;
+
+    const userPermissions = activeUser.permissions ?? [];
+    const hasPermission = Array.isArray(userPermissions)
+      ? userPermissions.includes(permissionKey)
+      : userPermissions[permissionKey] === true;
+
+    if (!hasPermission) {
+      throw new ForbiddenException(
+        `Missing permission: ${permissionKey}`
+      );
+    }
     const exportTransaction: CreateExportTransactionDto =  await this.exportTransactionService.toDto({
       datetime: new Date(),
       status: 'started',
@@ -62,8 +79,9 @@ export class ExportTemplateService extends CRUDService<ExportTemplate>{
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ExportTemplate, 'default')
-    readonly repo: Repository<ExportTemplate>,
+    // @InjectRepository(ExportTemplate, 'default')
+    // readonly repo: Repository<ExportTemplate>,
+    readonly repo: ExportTemplateRepository,
     readonly exportTransactionService: ExportTransactionService,
     readonly moduleRef: ModuleRef
  ) {

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

@@ -30,6 +30,10 @@ import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { UpdateExportTemplateDto } from 'src/dtos/update-export-template.dto';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
+import { ExportTransactionRepository } from 'src/repository/export-transaction.repository';
+import { Field } from 'mysql2/typings/mysql/lib/parsers/typeCast';
+import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
+import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
 
 const EXPORT_CHUNK_SIZE = 100;
 enum ExportStatus {
@@ -63,16 +67,19 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ExportTransaction, 'default')
-    readonly repo: Repository<ExportTransaction>,
+    // @InjectRepository(ExportTransaction, 'default')
+    // readonly repo: Repository<ExportTransaction>,
+    readonly repo: ExportTransactionRepository,
     readonly introspectService: SolidIntrospectService,
     readonly excelService: ExcelService,
     readonly csvService: CsvService,
     // readonly fieldMetadataService: FieldMetadataService,
-    @InjectRepository(FieldMetadata, 'default')
-    readonly fieldRepo: Repository<FieldMetadata>,
-    @InjectRepository(ModelMetadata, 'default')
-    readonly ModelMetadataRepo: Repository<ModelMetadata>,
+    // @InjectRepository(FieldMetadata, 'default')
+    // readonly fieldRepo: Repository<FieldMetadata>,
+    // @InjectRepository(ModelMetadata, 'default')
+    // readonly modelMetadataRepo: Repository<ModelMetadata>,
+    readonly fieldRepo: FieldMetadataRepository,
+    readonly modelMetadataRepo: ModelMetadataRepository,
     readonly moduleRef: ModuleRef,
     private readonly modelMetadataHelperService: ModelMetadataHelperService,
 
@@ -85,7 +92,7 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     try {
       // const loadedExportTransaction = await this.loadExportTransaction(id);
       // from updateDto, get modelId and get modelMetadata
-      const modeldata = await this.ModelMetadataRepo.findOne({
+      const modeldata = await this.modelMetadataRepo.findOne({
         where: { id: updateDto?.modelMetadataId },
         relations: { fields: true },
       })
@@ -109,7 +116,7 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     try {
       // const loadedExportTransaction = await this.loadExportTransaction(id)
       // from updateDto, get modelId and get modelMetadata
-      const modeldata = await this.ModelMetadataRepo.findOne({
+      const modeldata = await this.modelMetadataRepo.findOne({
         where: { id: updateDto?.modelMetadataId },
         relations: { fields: true },
       })
@@ -226,7 +233,7 @@ export class ExportTransactionService extends CRUDService<ExportTransaction> {
     const relatedModelsUserKeyMap = new Map<string, string>();
     for (const field of modelFields) {
       if (field.relationType && field.relationCoModelSingularName) {
-        const relatedModelMetadata = await this.ModelMetadataRepo.findOne({
+        const relatedModelMetadata = await this.modelMetadataRepo.findOne({
           where: { singularName: field.relationCoModelSingularName },
           relations: ['userKeyField'],
         });

package/src/services/field-metadata.service.ts

@@ -221,7 +221,7 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         let { limit, offset, populateMedia } = basicFilterDto;
 
         // Create above query on pincode table using query builder
-        var qb: SelectQueryBuilder<FieldMetadata> = this.fieldMetadataRepo.createQueryBuilder(alias)
+        var qb: SelectQueryBuilder<FieldMetadata> = await this.fieldMetadataRepo.createSecurityRuleAwareQueryBuilder(alias)
         qb = await this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
 
         // Get the records and the count

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

@@ -12,6 +12,7 @@ import { CrudHelperService } from 'src/services/crud-helper.service';
 
 
 import { ImportTransactionErrorLog } from '../entities/import-transaction-error-log.entity';
+import { ImportTransactionErrorLogRepository } from 'src/repository/import-transaction-error-log.repository';
 
 @Injectable()
 export class ImportTransactionErrorLogService extends CRUDService<ImportTransactionErrorLog>{
@@ -24,8 +25,9 @@ export class ImportTransactionErrorLogService extends CRUDService<ImportTransact
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ImportTransactionErrorLog, 'default')
-    readonly repo: Repository<ImportTransactionErrorLog>,
+    // @InjectRepository(ImportTransactionErrorLog, 'default')
+    // readonly repo: Repository<ImportTransactionErrorLog>,
+    readonly repo: ImportTransactionErrorLogRepository,
     readonly moduleRef: ModuleRef
 
  ) {

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

@@ -1,7 +1,7 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, ForbiddenException, Injectable, Logger } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
 
 import { ConfigService } from '@nestjs/config';
 import { CrudHelperService } from 'src/services/crud-helper.service';
@@ -13,20 +13,25 @@ import { ModuleMetadataService } from 'src/services/module-metadata.service';
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
 import { HttpService } from '@nestjs/axios';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
 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 { ImportTransactionErrorLog } from 'src/entities/import-transaction-error-log.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { parseFlexibleDate } from 'src/helpers/date.helper';
 import { MediaWithFullUrl } from 'src/interfaces';
+import { ImportTransactionRepository } from 'src/repository/import-transaction.repository';
 import { Readable } from 'stream';
 import { v4 as uuidv4 } from 'uuid';
 import { ImportTransaction } from '../entities/import-transaction.entity';
 import { CsvService } from './csv.service';
 import { ExcelService } from './excel.service';
 import { SolidIntrospectService } from './solid-introspect.service';
-import { ERROR_MESSAGES } from 'src/constants/error-messages';
-import { parseFlexibleDate } from 'src/helpers/date.helper';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
+import { getUserExcludedFields } from 'src/helpers/user-helper';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+import {upperFirst, camelCase} from 'lodash';
 
 interface ImportTemplateFileInfo {
   stream: NodeJS.ReadableStream;
@@ -97,13 +102,15 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
-    @InjectRepository(ImportTransaction, 'default')
-    readonly repo: Repository<ImportTransaction>,
+    // @InjectRepository(ImportTransaction, 'default')
+    // readonly repo: Repository<ImportTransaction>,
+    readonly repo: ImportTransactionRepository,
     readonly moduleRef: ModuleRef,
     readonly excelService: ExcelService,
     readonly csvService: CsvService,
     readonly httpService: HttpService,
     readonly introspectService: SolidIntrospectService,
+    private readonly modelMetadataHelperService: ModelMetadataHelperService,
     // readonly fieldMetadataService: FieldMetadataService,
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'importTransaction', 'solid-core', moduleRef);
@@ -124,8 +131,16 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     if (!modelMetadata) {
       throw new Error(ERROR_MESSAGES.MODEL_METADATA_NOT_FOUND(modelMetadataId));
     }
+
+    const allFields = await this.modelMetadataHelperService.loadFieldHierarchy(
+      modelMetadata.singularName,
+    );
+
+    // Replace original fields with full hierarchy fields
+    // modelMetadata.fields = allFields;  
+
     // Create a header row with the display names of the fields, excluding the media fields,computed fields
-    const headers = this.fieldsAllowedForImport(modelMetadata.fields)
+    const headers = this.fieldsAllowedForImport(allFields)
       .map(field => field.displayName);
 
     // Depending on the format, generate the template
@@ -163,6 +178,19 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       throw new Error(ERROR_MESSAGES.MODEL_METADATA_NOT_FOUND(modelMetadataId));
     }
 
+    // Step 2: Load full field hierarchy (includes parent model fields)
+    const allFields = await this.modelMetadataHelperService.loadFieldHierarchy(
+      modelMetadata.singularName,
+    );
+
+    const systemFieldNames = this.modelMetadataHelperService
+      .getSystemFieldsMetadata()
+      .map(field => field.name);
+
+    const userExcluded = getUserExcludedFields();
+    // Replace modelMetadata.fields with combined (child + parent) fields
+    // modelMetadata.fields = allFields;
+
     // Create the standard import instructions
     const standardInstructions: StandardImportInstructionsResponseDto = {
       requiredFields: [],
@@ -176,8 +204,18 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     };
 
     // Iterate through the fields and populate the standard instructions
-    for (const field of modelMetadata.fields) {
-      if (field.isSystem) continue; // Skip system fields
+    for (const field of allFields) {
+      // Skip system fields
+      if (systemFieldNames.includes(field.name)) {
+        continue;
+      }
+
+      // Skip excluded user fields (NO model name check needed)
+      if (userExcluded.includes(field.name)) {
+        continue;
+      }
+
+      // if (field.isSystem) continue; // Skip system fields
       if (field.required) {
         standardInstructions.requiredFields.push(field.displayName);
       }
@@ -255,9 +293,22 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     };
   }
 
-  async startImportSync(importTransactionId: number): Promise<ImportSyncResult> {
+  async startImportSync(importTransactionId: number, activeUser: ActiveUserData): Promise<ImportSyncResult> {
     // Load the import transaction for the given ID
     const importTransaction = await this.loadImportTransaction(importTransactionId);
+    const modelName = upperFirst(camelCase(importTransaction.modelMetadata.singularName));
+    const permissionKey = `${modelName}Controller.insertMany`;
+
+    const userPermissions = activeUser.permissions ?? [];
+    const hasPermission = Array.isArray(userPermissions)
+      ? userPermissions.includes(permissionKey)
+      : userPermissions[permissionKey] === true;
+
+    if (!hasPermission) {
+      throw new ForbiddenException(
+        `Missing permission: ${permissionKey}`
+      );
+    }
 
     // Get the import file media object from the import transaction
     const importFileMediaObject = this.getImportFileObject(importTransaction);
@@ -366,18 +417,43 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
   }
 
 
+  // 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 async loadImportTransaction(importTransactionId: number) {
+    // Step 1: Load the transaction with model metadata
     const importTransaction = await this.findOne(importTransactionId, {
-      populate: ['modelMetadata', 'modelMetadata.fields'],
+      populate: ['modelMetadata'],
       populateMedia: ['fileLocation'],
     });
-    if (!importTransaction) {
-      throw new Error(`Import transaction with ID ${importTransactionId} not found.`);
-    }
+
+    // Step 2: Load full field hierarchy (child + parent fields)
+    const modelFields = await this.modelMetadataHelperService.loadFieldHierarchy(
+      importTransaction.modelMetadata.singularName,
+    );
+
+    // Step 3: Attach the combined fields back into the modelMetadata
+    importTransaction.modelMetadata.fields = modelFields;
+
     return importTransaction;
   }
 
   private fieldsAllowedForImport(fields: FieldMetadata[]): FieldMetadata[] {
+    // Get system field names (e.g. id, createdAt, updatedAt...)
+    const systemFieldNames = this.modelMetadataHelperService
+      .getSystemFieldsMetadata()
+      .map(field => field.name);
+
+    const userExcluded = getUserExcludedFields();
+
     // Filter out fields that are not allowed for import
     return fields.filter(field =>
       field.type !== SolidFieldType.mediaMultiple && // Exclude media multiple fields
@@ -387,7 +463,10 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       field.type !== SolidFieldType.richText &&
       field.type !== SolidFieldType.uuid &&
       field.relationType !== RelationType.oneToMany &&
-      field.isSystem !== true // Exclude system fields
+      !systemFieldNames.includes(field.name) &&
+      // field.isSystem !== true // Exclude system fields
+
+      !userExcluded.includes(field.name)
     );
   }
 
@@ -567,11 +646,11 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     // TODO Move this logic to field crud managers i.e add a parse method to the field crud manager interface
     switch (fieldType) {
       case SolidFieldType.relation: {
-        return await this.populateDtoForRelations(fieldMetadata, record, key, dtoRecord); 
+        return await this.populateDtoForRelations(fieldMetadata, record, key, dtoRecord);
       }
       case SolidFieldType.date:
       case SolidFieldType.datetime:
-         return this.populateDtoForDate(record, key, fieldMetadata, dtoRecord);
+        return this.populateDtoForDate(record, key, fieldMetadata, dtoRecord);
       case SolidFieldType.int:
       case SolidFieldType.bigint:
       case SolidFieldType.decimal:
@@ -594,7 +673,7 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
       }
     }
   }
-  
+
   private populateDtoForSelectionValues(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string) {
     const rawValue = record[key];
 
@@ -658,17 +737,17 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
         dtoRecord[fieldMetadata.name] = null; // If the cell is empty, set the field to null
         return dtoRecord;
       }
-     // Use flexible date parser
-     this.logger.verbose(cellValue,'cellValue');
-     
-  const dateValue = parseFlexibleDate(cellValue);
-  this.logger.verbose(dateValue,'dateValue');
-
-  if (!dateValue) {
-    throw new Error(
-      `Invalid date value for cell ${key} with value ${cellValue}`
-    );
-  }
+      // Use flexible date parser
+      this.logger.verbose(cellValue, 'cellValue');
+
+      const dateValue = parseFlexibleDate(cellValue);
+      this.logger.verbose(dateValue, 'dateValue');
+
+      if (!dateValue) {
+        throw new Error(
+          `Invalid date value for cell ${key} with value ${cellValue}`
+        );
+      }
       dtoRecord[fieldMetadata.name] = dateValue;
       return dtoRecord;
     }