@solidstarters/solid-core 1.2.134 → 1.2.135

package/src/solid-core.module.ts

@@ -213,7 +213,37 @@ import { ComputedEntityFieldSubscriber } from './subscribers/computed-entity-fie
 import { CreatedByUpdatedBySubscriber } from './subscribers/created-by-updated-by.subscriber';
 import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
+import { Dashboard } from './entities/dashboard.entity';
+import { DashboardService } from './services/dashboard.service';
+import { DashboardController } from './controllers/dashboard.controller';
+import { DashboardVariable } from './entities/dashboard-variable.entity';
+import { DashboardVariableService } from './services/dashboard-variable.service';
+import { DashboardVariableController } from './controllers/dashboard-variable.controller';
+import { Question } from './entities/question.entity';
+import { QuestionService } from './services/question.service';
+import { QuestionController } from './controllers/question.controller';
 import { HttpExceptionFilter } from './filters/http-exception.filter';
+import { DashboardVariableSQLDynamicProvider } from './services/dashboard-selection-providers/dashboard-variable-sql-dynamic-provider.service';
+import { DasbhoardVariableTestDynamicProvider } from './services/dashboard-selection-providers/dashboard-variable-test-dynamic-provider.service';
+import { ListOfDashboardVariableProvidersSelectionProvider } from './services/selection-providers/list-of-dashboard-variable-providers-selection-provider.service';
+import { ListOfDashboardQuestionProvidersSelectionProvider } from './services/selection-providers/list-of-dashboard-question-providers-selection-provider.service';
+import { QuestionSqlDatasetConfig } from './entities/question-sql-dataset-config.entity';
+import { QuestionSqlDatasetConfigService } from './services/question-sql-dataset-config.service';
+import { QuestionSqlDatasetConfigController } from './controllers/question-sql-dataset-config.controller';
+import { ChartJsSqlDataProvider } from './services/question-data-providers/chartjs-sql-data-provider.service';
+import { SqlExpressionResolverService } from './services/sql-expression-resolver.service';
+import { PrimeReactMeterGroupSqlDataProvider } from './services/question-data-providers/prime-react-meter-group-sql-data-provider.service';
+import { PrimeReactDatatableSqlDataProvider } from './services/question-data-providers/prime-react-datatable-sql-data-provider.service';
+import { AiInteraction } from './entities/ai-interaction.entity';
+import { AiInteractionService } from './services/ai-interaction.service';
+import { AiInteractionController } from './controllers/ai-interaction.controller';
+import { DashboardMapper } from './mappers/dashboard-mapper';
+import { DashboardRepository } from './repository/dashboard.repository';
+import { DashboardSubscriber } from './subscribers/dashboard.subscriber';
+import { DashboardVariableSubscriber } from './subscribers/dashboard-variable.subscriber';
+import { QuestionSubscriber } from './subscribers/question.subscriber';
+import { QuestionSqlDatasetConfigSubscriber } from './subscribers/question-sql-dataset-config.subscriber';
+import { ScheduleModule } from '@nestjs/schedule';
 
 
 @Global()
@@ -252,12 +282,14 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
       ImportTransaction,
       ImportTransactionErrorLog,
       UserActivityHistory,
+      AiInteraction,
     ]),
     ConfigModule.forFeature(appBuilderConfig),
     ConfigModule.forFeature(commonConfig),
     ConfigModule.forFeature(iamConfig),
     ConfigModule.forFeature(jwtConfig),
     JwtModule.registerAsync(jwtConfig.asProvider()),
+    ScheduleModule.forRoot(),
     ServeStaticModule.forRoot({
       rootPath: join(process.cwd(), 'media-files-storage'),
       serveRoot: '/media-files-storage',
@@ -272,6 +304,11 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     HttpModule,
     ConfigModule,
     ClsModule,
+    TypeOrmModule.forFeature([Dashboard]),
+    TypeOrmModule.forFeature([DashboardVariable]),
+    TypeOrmModule.forFeature([Question]),
+    TypeOrmModule.forFeature([QuestionSqlDatasetConfig]),
+    TypeOrmModule.forFeature([AiInteraction]),
   ],
   controllers: [
     ModuleMetadataController,
@@ -310,6 +347,11 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     ImportTransactionController,
     ImportTransactionErrorLogController,
     UserActivityHistoryController,
+    DashboardController,
+    DashboardVariableController,
+    QuestionController,
+    QuestionSqlDatasetConfigController,
+    AiInteractionController,
   ],
   providers: [
     {
@@ -454,7 +496,25 @@ import { HttpExceptionFilter } from './filters/http-exception.filter';
     ComputedFieldEvaluationSubscriber,
     ConcatEntityComputedFieldProvider,
     UserActivityHistoryService,
-    
+    DashboardService,
+    DashboardVariableService,
+    QuestionService,
+    DashboardVariableSQLDynamicProvider,
+    DasbhoardVariableTestDynamicProvider,
+    ListOfDashboardVariableProvidersSelectionProvider,
+    ListOfDashboardQuestionProvidersSelectionProvider,
+    QuestionSqlDatasetConfigService,
+    ChartJsSqlDataProvider,
+    PrimeReactMeterGroupSqlDataProvider,
+    PrimeReactDatatableSqlDataProvider,
+    SqlExpressionResolverService,
+    AiInteractionService,
+    DashboardMapper,
+    DashboardRepository,
+    DashboardSubscriber,
+    DashboardVariableSubscriber,
+    QuestionSubscriber,
+    QuestionSqlDatasetConfigSubscriber,
   ],
   exports: [
     ModuleMetadataService,

package/src/subscribers/dashboard-variable.subscriber.ts

@@ -0,0 +1,63 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { DashboardVariable } from "src/entities/dashboard-variable.entity";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardVariableService } from "src/services/dashboard-variable.service";
+import { DashboardService } from "src/services/dashboard.service";
+import { EntitySubscriberInterface, DataSource, InsertEvent, UpdateEvent, EntityManager } from "typeorm";
+
+@Injectable()
+export class DashboardVariableSubscriber implements EntitySubscriberInterface<DashboardVariable> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return DashboardVariable;
+    }
+
+    async afterInsert(event: InsertEvent<DashboardVariable>) {
+        if (!event.entity) {
+            this.logger.debug('No dashboard variable entity found in the DashboardVariableSubscriber afterInsert method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
+    }
+
+    async afterUpdate(event: UpdateEvent<DashboardVariable>) {
+        if (!event.databaseEntity) {
+            this.logger.debug('No dashboard variable entity found in the DashboardVariableSubscriber afterUpdate method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
+    }
+
+    private async saveDashboardToConfig(dashboardVariable: DashboardVariable, entityManager: EntityManager): Promise<void> {
+        const dashboard = dashboardVariable.dashboard;
+        // Get the dashboard from the question & call the saveDashboardToConfig method
+        if (!dashboard) {
+            this.logger.debug(`Dashboard is undefined for dashboard variable id ${dashboardVariable.id}`);
+            return;
+        }
+
+        // populate the dashboard with its variables
+        const populatedDashboard = await entityManager.findOne(Dashboard, {
+            where: { id: dashboard.id },
+            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
+        });
+
+        if (!populatedDashboard) {
+            throw new Error(`Dashboard not found for question id ${populatedDashboard.id}`);
+        }
+
+        // Call the saveDashboardToConfig method from the DashboardService
+        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
+    }
+}

package/src/subscribers/dashboard.subscriber.ts

@@ -0,0 +1,43 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectDataSource } from "@nestjs/typeorm";
+import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
+import { Dashboard } from 'src/entities/dashboard.entity';
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardMapper } from 'src/mappers/dashboard-mapper';
+import { DashboardService } from 'src/services/dashboard.service';
+import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+export class DashboardSubscriber implements EntitySubscriberInterface<Dashboard> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return Dashboard;
+    }
+
+    async afterInsert(event: InsertEvent<Dashboard>) {
+        if (!event.entity) {
+            this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
+            return;
+        }
+        await this.dashboardService.saveDashboardToConfig(event.entity);
+    }
+
+    async afterUpdate(event: UpdateEvent<Dashboard>) {
+        if (!event.entity) {
+            this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
+            return;
+        }
+
+        await this.dashboardService.saveDashboardToConfig(event.databaseEntity);
+    }
+
+}

package/src/subscribers/question-sql-dataset-config.subscriber.ts

@@ -0,0 +1,63 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { QuestionSqlDatasetConfig } from "src/entities/question-sql-dataset-config.entity";
+import { Question } from "src/entities/question.entity";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardService } from "src/services/dashboard.service";
+import { QuestionService } from "src/services/question.service";
+import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+export class QuestionSqlDatasetConfigSubscriber implements EntitySubscriberInterface<QuestionSqlDatasetConfig> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return QuestionSqlDatasetConfig;
+    }
+
+    async afterInsert(event: InsertEvent<QuestionSqlDatasetConfig>) {
+        const question = event.entity.question;
+        if (!question) {
+            this.logger.debug('No question found in the QuestionSqlDatasetConfigSubscriber afterInsert method');
+            return;
+        }
+        await this.saveQuestionToConfig(question, event.queryRunner.manager);
+    }
+
+    async afterUpdate(event: UpdateEvent<QuestionSqlDatasetConfig>) {
+        const question = event.databaseEntity.question;
+        if (!question) {
+            this.logger.debug('No question found in the QuestionSqlDatasetConfigSubscriber afterUpdate method');
+            return;
+        }
+        await this.saveQuestionToConfig(question, event.queryRunner.manager);
+    }
+
+    private async saveQuestionToConfig(question: Question, entityManager: EntityManager): Promise<void> {
+        // Populate the dashboard for the question
+        const populatedQuestion = await entityManager.findOne(Question, {
+            where: {
+                id: question.id,
+            },
+            relations: ['dashboard', 'dashboard.module', 'dashboard.dashboardVariables', 'dashboard.questions', 'dashboard.questions.questionSqlDatasetConfigs'],
+        });
+        const dashboard = populatedQuestion?.dashboard;
+
+        if (!dashboard) {
+            throw new Error(`Dashboard not found for question id ${question.id}`);
+        }
+
+        // Call the saveDashboardToConfig method from the DashboardService
+        await this.dashboardService.saveDashboardToConfig(dashboard);
+    }
+
+}

package/src/subscribers/question.subscriber.ts

@@ -0,0 +1,65 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import e from "express";
+import { DashboardVariable } from "src/entities/dashboard-variable.entity";
+import { Dashboard } from "src/entities/dashboard.entity";
+import { Question } from "src/entities/question.entity";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { DashboardService } from "src/services/dashboard.service";
+import { QuestionService } from "src/services/question.service";
+import { EntitySubscriberInterface, DataSource, InsertEvent, UpdateEvent, EntityManager } from "typeorm";
+
+@Injectable()
+export class QuestionSubscriber implements EntitySubscriberInterface<Question> {
+    private readonly logger = new Logger(this.constructor.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly dashboardService: DashboardService,
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return Question;
+    }
+
+    async afterInsert(event: InsertEvent<Question>) {
+        if (!event.entity) {
+            this.logger.debug('No question entity found in the QuestionSubscriber afterInsert method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
+    }
+
+    async afterUpdate(event: UpdateEvent<Question>) {
+        if (!event.databaseEntity) {
+            this.logger.debug('No question entity found in the QuestionSubscriber afterUpdate method');
+            return;
+        }
+        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
+    }
+
+    private async saveDashboardToConfig(question: Question, entityManager: EntityManager): Promise<void> {
+        const dashboard = question.dashboard;
+        // Get the dashboard from the question & call the saveDashboardToConfig method
+        if (!dashboard) {
+            this.logger.debug(`Dashboard is undefined for question id ${question.id}`);
+            return;
+        }
+
+        // populate the dashboard with its variables
+        const populatedDashboard = await entityManager.findOne(Dashboard, {
+            where: { id: dashboard.id },
+            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
+        });
+
+        if (!populatedDashboard) {
+            throw new Error(`Dashboard not found for question id ${populatedDashboard.id}`);
+        }
+
+        // Call the saveDashboardToConfig method from the DashboardService
+        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
+    }
+}