@solidstarters/solid-core 1.2.189 → 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/file.service.ts

@@ -124,30 +124,7 @@ export class FileService {
   }
 
   async copyToS3WithPublic(filePath: string, ContentType: string, fileName: string, bucketName: string): Promise<string> {
-    this.checkIfS3ClientExists();
-    try {
-      // Read Image File TO Fetch Buffer 
-      const data = await this.readImageFile(filePath);
-
-      const params = {
-        Bucket: bucketName,
-        Key: fileName,
-        Body: data,
-        ContentType: ContentType, // Set the correct MIME type
-        ACL: "public-read" as ObjectCannedACL
-      };
-      // Upload it to S3
-      // const response = await this.s3.upload(params).promise();
-      const command = new PutObjectCommand(params);
-      const response = await this.s3Client.send(command);
-
-      // Return the URL file Name
-      // To access the file  - https://rep-public-files.s3.amazonaws.com/${fileName}
-      return fileName
-
-    } catch (error) {
-      throw new Error(`${ERROR_MESSAGES.FILE_COPY_ERROR}: ${error.message}`);
-    }
+    return this.copyToS3(filePath, ContentType, fileName, bucketName);
   }
 
   async deleteFromS3(fileName: string, bucketName: string): Promise<string> {

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
 
  ) {