@solidxai/core 0.1.6 → 0.1.8-beta.0

package/src/services/authentication.service.ts

@@ -464,10 +464,6 @@ export class AuthenticationService {
 
     private async notifyUserOnOtpInitiateRegistration(user: User, registrationValidationSource: string) {
         const companyLogo = await this.getCompanyLogo();
-        const dummyOtp = this.getDummyOtpForUser(user);
-
-        if (dummyOtp)
-            return; // Do nothing if dummy otp is configured.
         if (registrationValidationSource === PasswordlessLoginValidateWhatSources.EMAIL) {
             const mailService = this.mailServiceFactory.getMailService();
             mailService.sendEmailUsingTemplate(
@@ -594,13 +590,12 @@ export class AuthenticationService {
         return true;
     }
 
-    private async otp(user?: User): Promise<otp> {
+    private async otp(): Promise<otp> {
         const now = new Date();
         const otpExpiry = this.settingService.getConfigValue<SolidCoreSetting>('otpExpiry');
-        const dummyOtp = this.getDummyOtpForUser(user);
         now.setMinutes(now.getMinutes() + otpExpiry);
         return {
-            token: dummyOtp ? dummyOtp : randomInt(100000, 999999).toString(),
+            token: randomInt(100000, 999999).toString(),
             expiresAt: now,
         };
     }
@@ -692,8 +687,11 @@ export class AuthenticationService {
 
         const type = this.resolveLoginType(signInDto);
         const user = await this.findUserForLogin(type, signInDto.identifier);
-        await this.assignLoginOtp(user, type);
-        this.notifyUserOnOtpInititateLogin(user, type);
+        const dummyOtp = this.getDummyOtpForUser(user);
+        if (!dummyOtp) {
+            await this.assignLoginOtp(user, type);
+            this.notifyUserOnOtpInititateLogin(user, type);
+        }
         return this.buildLoginOtpResponse(user, type);
     }
 
@@ -738,15 +736,22 @@ export class AuthenticationService {
     }
 
     private async assignLoginOtp(user: User, type: PasswordlessLoginValidateWhatSources): Promise<void> {
-        const { token, expiresAt } = await this.otp(user);
+        const { token, expiresAt } = await this.otp();
         if (type === PasswordlessLoginValidateWhatSources.EMAIL) {
             user.emailVerificationTokenOnLogin = token;
             user.emailVerificationTokenOnLoginExpiresAt = expiresAt;
+            await this.userRepository.update(user.id, {
+                emailVerificationTokenOnLogin: token,
+                emailVerificationTokenOnLoginExpiresAt: expiresAt,
+            });
         } else {
             user.mobileVerificationTokenOnLogin = token;
             user.mobileVerificationTokenOnLoginExpiresAt = expiresAt;
+            await this.userRepository.update(user.id, {
+                mobileVerificationTokenOnLogin: token,
+                mobileVerificationTokenOnLoginExpiresAt: expiresAt,
+            });
         }
-        await this.userRepository.save(user);
     }
 
     private buildLoginOtpResponse(user: User, type: PasswordlessLoginValidateWhatSources) {
@@ -815,6 +820,15 @@ export class AuthenticationService {
 
         const user = await this.findUserForLogin(type, identifier, { withRoles: true });
         this.checkAccountBlocked(user);
+        const dummyOtp = this.getDummyOtpForUser(user);
+
+        if (dummyOtp) {
+            if (otp !== dummyOtp) {
+                throw new UnauthorizedException(ERROR_MESSAGES.INVALID_OTP);
+            }
+            return this.buildLoginTokenResponse(user);
+        }
+
         try {
             this.validateLoginOtp(user, otp, type);
         } catch (e) {
@@ -822,13 +836,9 @@ export class AuthenticationService {
             throw e;
         }
 
-        // we do not need to clear the otp when dummy otp is configured...
-        const dummyOtp = this.getDummyOtpForUser(user);
-        if (!dummyOtp)
-            this.clearLoginOtp(user, type);
-
-        user.failedLoginAttempts = 0;
-        await this.userRepository.save(user);
+        await this.clearLoginOtp(user, type);
+        await this.userActivityHistoryService.logEvent('login', user); 
+        await this.resetFailedAttempts(user);
         return this.buildLoginTokenResponse(user);
     }
 
@@ -845,15 +855,27 @@ export class AuthenticationService {
         }
     }
 
-    private clearLoginOtp(user: User, type: PasswordlessLoginValidateWhatSources): void {
+    private async clearLoginOtp(user: User, type: PasswordlessLoginValidateWhatSources): Promise<void> {
         if (type === PasswordlessLoginValidateWhatSources.EMAIL) {
-            user.emailVerifiedOnLoginAt = new Date();
+            const verifiedAt = new Date();
+            user.emailVerifiedOnLoginAt = verifiedAt;
             user.emailVerificationTokenOnLogin = null;
             user.emailVerificationTokenOnLoginExpiresAt = null;
+            await this.userRepository.update(user.id, {
+                emailVerifiedOnLoginAt: verifiedAt,
+                emailVerificationTokenOnLogin: null,
+                emailVerificationTokenOnLoginExpiresAt: null,
+            });
         } else {
-            user.mobileVerifiedOnLoginAt = new Date();
+            const verifiedAt = new Date();
+            user.mobileVerifiedOnLoginAt = verifiedAt;
             user.mobileVerificationTokenOnLogin = null;
             user.mobileVerificationTokenOnLoginExpiresAt = null;
+            await this.userRepository.update(user.id, {
+                mobileVerifiedOnLoginAt: verifiedAt,
+                mobileVerificationTokenOnLogin: null,
+                mobileVerificationTokenOnLoginExpiresAt: null,
+            });
         }
     }
 
@@ -1296,14 +1318,15 @@ export class AuthenticationService {
     }
 
     private async incrementFailedAttempts(user: User): Promise<void> {
-        user.failedLoginAttempts += 1;
-        await this.userRepository.save(user);
+        const nextFailedAttempts = (user.failedLoginAttempts ?? 0) + 1;
+        user.failedLoginAttempts = nextFailedAttempts;
+        await this.userRepository.update(user.id, { failedLoginAttempts: nextFailedAttempts });
     }
 
     private async resetFailedAttempts(user: User): Promise<void> {
         if (user.failedLoginAttempts === 0) return;
         user.failedLoginAttempts = 0;
-        await this.userRepository.save(user);
+        await this.userRepository.update(user.id, { failedLoginAttempts: 0 });
     }
 
     //FIXME - Pending implementation

package/src/services/chatter-message.service.ts

@@ -1,3 +1,4 @@
+import { LocalDateTimeTransformer, serializeDate } from 'src/transformers/typeorm/local-date-time-transformer';
 import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
@@ -89,13 +90,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         return savedMessage;
     }
 
-    async postAuditMessageOnInsert(entity: any, metadata: EntityMetadata, messageQueue: boolean = false) {
+    async postAuditMessageOnInsert(entity: any, modelName: string, messageQueue: boolean = false) {
         if (!entity) {
             return;
         }
         const model = await this.modelMetadataRepo.findOne({
             where: {
-                singularName: lowerFirst(metadata.name)
+                singularName: lowerFirst(modelName)
             },
             relations: {
                 fields: true,
@@ -141,6 +142,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
                 messageDetail.chatterMessage = savedMessage;
                 messageDetail.fieldName = field.name;
                 messageDetail.fieldDisplayName = field.displayName;
+                messageDetail.fieldType = field.type;
                 messageDetail.oldValue = null;
                 messageDetail.oldValueDisplay = null;
                 messageDetail.newValue = this.formatFieldValue(field, fieldValue);
@@ -150,13 +152,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }
     }
 
-    async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEntity: any, updatedColumns: any[] = [], messageQueue: boolean = false) {
+    async postAuditMessageOnUpdate(entity: any, modelName: string, databaseEntity: any, updatedColumns: any[] = [], messageQueue: boolean = false) {
         if (!databaseEntity || !entity) {
             return;
         }
         const model = await this.modelMetadataRepo.findOne({
             where: {
-                singularName: lowerFirst(metadata.name)
+                singularName: lowerFirst(modelName)
             },
             relations: {
                 fields: true,
@@ -202,6 +204,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         const changedRelationFields = [];
         if (potentialRelationFields.length > 0) {
+            const metadata = this.entityManager.connection.entityMetadatas.find(m => m.name === modelName);
             const populatedOldEntity = await this.populateRelationFields(databaseEntity, potentialRelationFields, metadata);
 
             for (const field of potentialRelationFields) {
@@ -257,6 +260,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             messageDetail.chatterMessage = savedMessage;
             messageDetail.fieldName = field.name;
             messageDetail.fieldDisplayName = field.displayName;
+            messageDetail.fieldType = field.type;
             messageDetail.oldValue = this.formatFieldValue(field, oldValue);
             messageDetail.newValue = this.formatFieldValue(field, newValue);
             messageDetail.oldValueDisplay = await this.formatFieldValueDisplay(field, oldValue);
@@ -265,13 +269,12 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }
     }
 
-    async postAuditMessageOnDelete(entity: any, metadata: EntityMetadata, databaseEntity: any, messageQueue: boolean = false) {
+    async postAuditMessageOnDelete(modelName: string, databaseEntity: any, messageQueue: boolean = false) {
         const model = await this.modelMetadataRepo.findOne({
             where: {
-                singularName: lowerFirst(metadata.name)
+                singularName: lowerFirst(modelName)
             },
             relations: {
-                fields: true,
                 module: true,
                 userKeyField: true
             }
@@ -281,13 +284,29 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             return;
         }
 
+        const modelFields = await this.modelMetadataHelperService.loadFieldHierarchy(model.singularName);
+
+        const auditFields = modelFields.filter(field =>
+            field.enableAuditTracking &&
+            !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
+            !(field.type === 'relation' && field.relationType === 'one-to-many')
+        );
+
+        // Populate relation fields so display values (e.g. names) are resolvable.
+        // The related entities themselves still exist in the DB after a delete.
+        const relationFields = auditFields.filter(field => field.type === 'relation');
+        const entityMetadata = this.entityManager.connection.entityMetadatas.find(m => m.name === modelName);
+        const populatedEntity = relationFields.length > 0 && entityMetadata
+            ? await this.populateRelationFields(databaseEntity, relationFields, entityMetadata)
+            : { ...databaseEntity };
+
         const chatterMessage = new ChatterMessage();
         chatterMessage.messageType = CHATTER_MESSAGE_TYPE.AUDIT;
         chatterMessage.messageSubType = CHATTER_MESSAGE_SUBTYPE.AUDIT_DELETE;
         chatterMessage.coModelEntityId = databaseEntity?.id;
         chatterMessage.coModelName = model?.singularName;
         chatterMessage.modelDisplayName = model?.displayName;
-        chatterMessage.modelUserKey = entity[model?.userKeyField?.name];
+        chatterMessage.modelUserKey = databaseEntity[model?.userKeyField?.name];
         chatterMessage.messageBody = `${model?.displayName} deleted`;
 
         const activeUser = this.requestContextService.getActiveUser();
@@ -299,7 +318,23 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             chatterMessage.user = null;
         }
 
-        await this.repo.save(chatterMessage);
+        const savedMessage = await this.repo.save(chatterMessage);
+
+        for (const field of auditFields) {
+            const fieldValue = populatedEntity[field.name];
+            if (fieldValue !== undefined && fieldValue !== null && fieldValue !== '') {
+                const messageDetail = new ChatterMessageDetails();
+                messageDetail.chatterMessage = savedMessage;
+                messageDetail.fieldName = field.name;
+                messageDetail.fieldDisplayName = field.displayName;
+                messageDetail.fieldType = field.type;
+                messageDetail.oldValue = this.formatFieldValue(field, fieldValue);
+                messageDetail.oldValueDisplay = await this.formatFieldValueDisplay(field, fieldValue);
+                messageDetail.newValue = null;
+                messageDetail.newValueDisplay = null;
+                await this.chatterMessageDetailsRepo.save(messageDetail);
+            }
+        }
     }
 
     private formatFieldValue(field: any, value: any): string {
@@ -320,6 +355,9 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             }
         }
 
+        if (value instanceof Date) {
+            return serializeDate(value);
+        }
 
         return value.toString();
     }
@@ -333,6 +371,10 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             return `${value}`;
         }
 
+        if (['date', 'datetime', 'time'].includes(field.type)) {
+            return null;
+        }
+
         if (field.type === 'relation') {
             if (field.relationType === "many-to-one") {
                 if (value.name) {
@@ -618,6 +660,22 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         const [entities, count] = await qb.getManyAndCount();
         this.logHeapUsed('getChatterMessages-entitiesLoaded');
 
+        // Convert date strings in message details to ISO format for consistent handling on the frontend
+        const DATE_FIELD_TYPES = ['date', 'datetime', 'time'];
+        for (const entity of entities) {
+            for (const detail of entity.chatterMessageDetails ?? []) {
+                if (!detail.fieldType || !DATE_FIELD_TYPES.includes(detail.fieldType)) continue;
+                if (detail.oldValue) {
+                    const d = LocalDateTimeTransformer.from(detail.oldValue);
+                    if (d) detail.oldValue = d.toISOString();
+                }
+                if (detail.newValue) {
+                    const d = LocalDateTimeTransformer.from(detail.newValue);
+                    if (d) detail.newValue = d.toISOString();
+                }
+            }
+        }
+
         if (populateMedia && populateMedia.length > 0) {
             const normalizedPopulateMedia = this.crudHelperService.normalize(populateMedia);
             this.logHeapUsed('getChatterMessages-beforePopulateMedia');

package/src/services/computed-fields/entity/sequence-num-computed-field-provider.ts

@@ -1,20 +1,28 @@
+import { classify } from "@angular-devkit/core/src/utils/strings";
 import { Injectable } from "@nestjs/common";
 import { InjectDataSource } from "@nestjs/typeorm";
+import { ComputedFieldTriggerOperation } from "src/dtos/create-field-metadata.dto";
 import { ComputedFieldProvider } from "src/decorators/computed-field-provider.decorator";
 import { CommonEntity } from "src/entities/common.entity";
 import { ModelSequence } from "src/entities/model-sequence.entity";
 import { ComputedFieldMetadata } from "src/helpers/solid-registry";
-import { IEntityPreComputeFieldProvider } from "src/interfaces";
-import { DataSource, EntityTarget } from "typeorm";
+import { IEntityPostComputeFieldProvider } from "src/interfaces";
+import { DataSource, EntityManager } from "typeorm";
 
 
 export interface SequenceNumComputedFieldContext {
-    sequenceName: string; // The separator to use between concatenated values
+    sequenceName: string;
+    /**
+     * - `'counter'` (default): increments the sequence's `currentValue` and uses it as the number.
+     * - `'entityId'`: uses the entity's own `id` as the number; does not update the counter.
+     *   Only valid on `afterInsert` events.
+     */
+    mode?: 'counter' | 'entityId';
 }
 
 @ComputedFieldProvider()
 @Injectable()
-export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, SequenceNumComputedFieldContext> {
+export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements IEntityPostComputeFieldProvider<T, SequenceNumComputedFieldContext> {
     constructor(
         @InjectDataSource()
         private readonly dataSource: DataSource
@@ -25,23 +33,21 @@ export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements
     }
 
     help(): string {
-        return "Computed field provider used to create fields whose value is based on some prefix, padding & sequence number.";
+        return "Computed field provider used to create fields whose value is based on some prefix, padding & sequence number. " +
+            "Use mode='counter' (default) to auto-increment the sequence's currentValue. " +
+            "Use mode='entityId' to use the entity's own id as the number (afterInsert only, does not update the counter).";
     }
 
-    async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<SequenceNumComputedFieldContext>) {
-        const { sequenceName } =
-            computedFieldMetadata.computedFieldValueProviderCtxt ?? {};
-
-        if (!sequenceName) {
-            throw new Error("sequenceName is required for sequence computation");
-        }
+    private buildSequenceString(modelSequence: ModelSequence, numericValue: number): string {
+        const prefix = modelSequence.prefix ?? "";
+        const separator = modelSequence.separator ?? "";
+        const padded = String(numericValue).padStart(modelSequence.padding ?? 5, "0");
+        return `${prefix}${separator}${padded}`;
+    }
 
-        await this.dataSource.transaction(async (manager) => {
-            /**
-             * 1️⃣ Lock sequence row (prevents race conditions)
-             */
-            // 1️⃣ Fetch sequence row
-            const modelSequenceRepo = manager.getRepository(ModelSequence)
+    private async generateCounterSequenceValue(sequenceName: string, manager?: EntityManager): Promise<{ sequenceString: string; currentValue: number; modelSingularName: string }> {
+        const run = async (mgr: EntityManager) => {
+            const modelSequenceRepo = mgr.getRepository(ModelSequence);
             const modelSequence = await modelSequenceRepo.findOne({
                 where: { sequenceName },
                 lock: { mode: "pessimistic_write" }
@@ -51,36 +57,69 @@ export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements
                 throw new Error(`ModelSequence not found for ${sequenceName}`);
             }
 
-            // 2️⃣ Generate next sequence value
             const nextValue = modelSequence.currentValue + 1;
+            const sequenceString = this.buildSequenceString(modelSequence, nextValue);
 
-            const paddedValue = String(nextValue).padStart(modelSequence.padding ?? 5, "0");
+            modelSequence.currentValue = nextValue;
+            await modelSequenceRepo.save(modelSequence);
 
-            const prefix = modelSequence.prefix ?? "";
-            const separator = modelSequence.separator ?? "";
+            // Load model relation in a separate query to avoid FOR UPDATE on joined relation.
+            const modelSequenceWithModel = await modelSequenceRepo.findOne({
+                where: { id: modelSequence.id },
+                relations: { model: true },
+            });
+            const modelSingularName = modelSequenceWithModel?.model?.singularName;
+            if (!modelSingularName) {
+                throw new Error(`Model singularName not found for sequence ${sequenceName}`);
+            }
 
-            const sequenceString = `${prefix}${separator}${paddedValue}`;
+            return { sequenceString, currentValue: nextValue, modelSingularName };
+        };
 
-            // 3️⃣ Duplicate check on TARGET ENTITY (extra safety)
-            const entityRepo = manager.getRepository(triggerEntity.constructor as any);
+        return manager ? run(manager) : this.dataSource.transaction(run);
+    }
 
-            const existing = await entityRepo.findOne({
-                where: {
-                    [computedFieldMetadata.fieldName]: sequenceString,
-                },
-            });
+    private async generateEntityIdSequenceValue(sequenceName: string, entityId: number): Promise<{ sequenceString: string; modelSingularName: string }> {
+        const modelSequenceRepo = this.dataSource.manager.getRepository(ModelSequence);
+        const modelSequence = await modelSequenceRepo.findOne({
+            where: { sequenceName },
+            relations: { model: true },
+        });
 
-            if (existing) {
-                throw new Error(`Duplicate Sequence generated: ${sequenceString}`);
-            }
+        if (!modelSequence) {
+            throw new Error(`ModelSequence not found for ${sequenceName}`);
+        }
 
-            // 4️⃣ set the computed field on the entity
-            (triggerEntity as any)[computedFieldMetadata.fieldName] = sequenceString;
+        const modelSingularName = modelSequence.model?.singularName;
+        if (!modelSingularName) {
+            throw new Error(`Model singularName not found for sequence ${sequenceName}`);
+        }
 
-            // 5️⃣ Persist updated sequence current value
-            modelSequence.currentValue = nextValue;
-            await modelSequenceRepo.save(modelSequence);
-        });
+        return { sequenceString: this.buildSequenceString(modelSequence, entityId), modelSingularName };
     }
 
-}
+    async postComputeAndSaveValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<SequenceNumComputedFieldContext>): Promise<void> {
+        const { sequenceName, mode = 'counter' } = computedFieldMetadata.computedFieldValueProviderCtxt ?? {};
+
+        if (!sequenceName) {
+            throw new Error("sequenceName is required for sequence computation");
+        }
+
+        let sequenceString: string;
+        let modelSingularName: string;
+
+        if (mode === 'entityId') {
+            const eventType = computedFieldMetadata.eventContext?.eventType;
+            if (eventType !== ComputedFieldTriggerOperation.afterInsert) {
+                throw new Error(`SequenceNumComputedFieldProvider with mode='entityId' only supports "${ComputedFieldTriggerOperation.afterInsert}" events, but received "${eventType}"`);
+            }
+            ({ sequenceString, modelSingularName } = await this.generateEntityIdSequenceValue(sequenceName, triggerEntity.id));
+        } else {
+            ({ sequenceString, modelSingularName } = await this.generateCounterSequenceValue(sequenceName));
+        }
+
+        const entityName = classify(modelSingularName);
+        const entityRepo = this.dataSource.manager.getRepository(entityName);
+        await entityRepo.update(triggerEntity.id, { [computedFieldMetadata.fieldName]: sequenceString });
+    }
+}

package/src/services/crud.service.ts

@@ -432,7 +432,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 //     dataSource: string; // The name of the selection provider
                 //     filterSchema : json // This is a custom json object that every data source will handle accordingly. We could validate the query against the selection provider
                 //     values : string[]; // The values returned by the selection provider
-                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: fieldMetadata.selectionDynamicProviderCtxt, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService, isMultiSelect: fieldMetadata.isMultiSelect };
+                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: JSON.parse(fieldMetadata.selectionDynamicProviderCtxt), selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService, isMultiSelect: fieldMetadata.isMultiSelect };
                 return new SelectionDynamicFieldCrudManager(options);
             }
             case SolidFieldType.uuid: {

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

@@ -0,0 +1,111 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { DashboardLayout } from 'src/entities/dashboard-layout.entity';
+import { DashboardLayoutRepository } from 'src/repository/dashboard-layout.repository';
+import { CreateDashboardLayoutDto } from 'src/dtos/create-dashboard-layout.dto';
+import { RequestContextService } from './request-context.service';
+
+
+@Injectable()
+export class DashboardLayoutService extends CRUDService<DashboardLayout> {
+  private readonly logger = new Logger(this.constructor.name);
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    readonly repo: DashboardLayoutRepository,
+    readonly requestContextService: RequestContextService,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(entityManager, repo, 'dashboardLayout', 'solid-core', moduleRef);
+  }
+
+  async upsertUserDashboardLayout(createDtos: CreateDashboardLayoutDto) {
+    const activeUser = this.requestContextService.getActiveUser();
+
+    if (!activeUser) {
+      throw new Error('User not found');
+    }
+
+    let userId = null;
+    if (activeUser.roles.includes('Admin')) {
+      userId = null;
+    } else {
+      userId = activeUser?.sub;
+    }
+    const existingLayout = await this.repo.findOne({
+      where: {
+        user: { id: userId },
+        dashboard: {
+          id: createDtos.dashboardId
+        }
+      },
+      relations: {
+        user: true,
+        dashboard: true,
+      }
+    });
+
+    if (existingLayout) {
+      return super.update(existingLayout.id, { layout: createDtos.layout }, [], true);
+    } else {
+      const createDto = {
+        layout: createDtos.layout,
+        dashboardId: createDtos.dashboardId,
+        uesrId: userId
+      }
+      return super.create(createDto, []);
+    }
+  }
+
+  async getUserDashboardLayoutByDashboardId(dashboardId: any) {
+    const activeUser = this.requestContextService.getActiveUser();
+
+    if (!activeUser) {
+      throw new Error('User not found');
+    }
+    const userId = activeUser?.sub;
+    const existingUserLayout = await this.repo.findOne({
+      where: {
+        user: { id: userId },
+        dashboard: {
+          id: dashboardId
+        }
+      },
+      relations: {
+        user: true,
+        dashboard: true,
+      }
+    });
+    if (existingUserLayout) {
+      // if dahsboard for userid exists 
+      return existingUserLayout;
+    }
+
+    // if not then check for default dashboard
+    const defaultLayout = await this.repo.findOne({
+      where: {
+        user: { id: null },
+        dashboard: {
+          id: dashboardId
+        }
+      },
+      relations: {
+        user: true,
+        dashboard: true,
+      }
+    });
+    if (defaultLayout) {
+      // if default layout exists return it
+      return defaultLayout;
+    } else {
+      // if default layout does not exist return empty layout 
+      return {
+        layout: null
+      }
+    }
+  }
+}

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

@@ -11,15 +11,18 @@ import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DashboardQuestion } from '../entities/dashboard-question.entity';
 import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
 import { DashboardQuestionRepository } from 'src/repository/dashboard-question.repository';
+import { QuestionSqlDataProviderContext } from 'src';
 
 enum SOURCE_TYPE {
   SQL = 'sql',
   PROVIDER = 'provider',
 }
 
-const CHARTJS_SQL_DATA_PROVIDER_NAME = 'ChartJsSqlDataProvider';
-const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlDataProvider';
-const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
+export const CHARTJS_SQL_DATA_PROVIDER_NAME = 'ChartJsSqlDataProvider';
+export const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlDataProvider';
+export const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
+
+export const INBUILT_SQL_DATA_PROVIDERS = [CHARTJS_SQL_DATA_PROVIDER_NAME, PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME, PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME];
 
 @Injectable()
 export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
@@ -50,22 +53,38 @@ export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
 
     // Try to resolve the dataProvider based on a combination of sourceType and visualisedAs
     let dataProvider = null;
+    let context = {};
 
+    // Decide which data provider to use based on the question visualisation type if sourceType is SQL. 
     if (question.sourceType === SOURCE_TYPE.SQL && ['bar', 'pie', 'line', 'donut'].includes(question.visualisedAs)) {
       dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(CHARTJS_SQL_DATA_PROVIDER_NAME);
+      context = {
+        expressions,
+      } as QuestionSqlDataProviderContext;
     }
     if (question.sourceType === SOURCE_TYPE.SQL && ['prime-meter-group'].includes(question.visualisedAs)) {
       dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME);
+            context = {
+        expressions,
+      } as QuestionSqlDataProviderContext;
     }
     if (question.sourceType === SOURCE_TYPE.SQL && ['prime-datatable'].includes(question.visualisedAs)) {
       dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME);
+      context = {
+        expressions,
+      } as QuestionSqlDataProviderContext;
+    }
+
+    // If a custom provider is specified, use that one instead
+    if (question.sourceType === SOURCE_TYPE.PROVIDER) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(question.providerName);
     }
 
     if (!dataProvider) {
       throw new NotImplementedException(`Invalid data source type ${question.sourceType}`);
     }
 
-    return await dataProvider.getData(question, expressions);
+    return await dataProvider.getData(question, context);
 
   }