@solidxai/core 0.1.6-beta.1 → 0.1.6-beta.10

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,14 +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.clearLoginOtp(user, type);
         await this.userActivityHistoryService.logEvent('login', user); 
-        await this.userRepository.save(user);
+        await this.resetFailedAttempts(user);
         return this.buildLoginTokenResponse(user);
     }
 
@@ -846,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,
+            });
         }
     }
 
@@ -1297,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';
@@ -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);
@@ -257,6 +259,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);
@@ -320,6 +323,9 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             }
         }
 
+        if (value instanceof Date) {
+            return serializeDate(value);
+        }
 
         return value.toString();
     }
@@ -333,6 +339,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 +628,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/alpha-num-external-id-computed-field-provider.ts

@@ -31,6 +31,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
   async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<AlphaNumExternalIdContext>) {
     const { prefix, length, dynamicFieldPrefix } = computedFieldMetadata.computedFieldValueProviderCtxt;
     const eventContext = computedFieldMetadata.eventContext;
+    const manager = eventContext?.manager ?? this.entityManager;
     const entityName = eventContext?.metadataName ?? eventContext.databaseEntity?.constructor?.name ?? '';
 
     const codeLength = length || 5;
@@ -45,7 +46,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
       }
     }
 
-    const uniqueCode = await this.generateUniqueExternalId(resolvedPrefix, codeLength, computedFieldMetadata.fieldName, entityName);
+    const uniqueCode = await this.generateUniqueExternalId(manager, resolvedPrefix, codeLength, computedFieldMetadata.fieldName, entityName);
     const finalExternalId = resolvedPrefix ? `${resolvedPrefix}-${uniqueCode}` : uniqueCode;
 
     triggerEntity[computedFieldMetadata.fieldName] = finalExternalId;
@@ -60,8 +61,8 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return result;
   }
 
-  private async isExternalIdUnique(externalId: string, fieldName: string, entityName: string): Promise<boolean> {
-    const count = await this.entityManager.count(entityName as any,
+  private async isExternalIdUnique(manager: EntityManager, externalId: string, fieldName: string, entityName: string): Promise<boolean> {
+    const count = await manager.count(entityName as any,
       {
         where: { [fieldName]: externalId },
       }
@@ -69,7 +70,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
     return count === 0;
   }
 
-  private async generateUniqueExternalId(resolvedPrefix: string, codeLength: number, fieldName: string, entityName: string): Promise<string> {
+  private async generateUniqueExternalId(manager: EntityManager, resolvedPrefix: string, codeLength: number, fieldName: string, entityName: string): Promise<string> {
     const maxAttempts = 10;
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
@@ -78,7 +79,7 @@ export class AlphaNumExternalIdComputationProvider<T extends CommonEntity> imple
 
       const fullId = resolvedPrefix ? `${resolvedPrefix}-${newId}` : newId;
 
-      const isUnique = await this.isExternalIdUnique(fullId, fieldName, entityName);
+      const isUnique = await this.isExternalIdUnique(manager, fullId, fieldName, entityName);
 
       if (isUnique) {
         return newId;

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

@@ -5,7 +5,7 @@ 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 { DataSource, EntityManager } from "typeorm";
 
 
 export interface SequenceNumComputedFieldContext {
@@ -36,11 +36,10 @@ export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements
             throw new Error("sequenceName is required for sequence computation");
         }
 
-        await this.dataSource.transaction(async (manager) => {
-            /**
-             * 1️⃣ Lock sequence row (prevents race conditions)
-             */
-            // 1️⃣ Fetch sequence row
+        const contextManager = computedFieldMetadata.eventContext?.manager;
+
+        const compute = async (manager: EntityManager) => {
+            // Lock sequence row to avoid duplicate sequence numbers under concurrency.
             const modelSequenceRepo = manager.getRepository(ModelSequence)
             const modelSequence = await modelSequenceRepo.findOne({
                 where: { sequenceName },
@@ -61,26 +60,22 @@ export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements
 
             const sequenceString = `${prefix}${separator}${paddedValue}`;
 
-            // 3️⃣ Duplicate check on TARGET ENTITY (extra safety)
-            const entityRepo = manager.getRepository(triggerEntity.constructor as any);
-
-            const existing = await entityRepo.findOne({
-                where: {
-                    [computedFieldMetadata.fieldName]: sequenceString,
-                },
-            });
-
-            if (existing) {
-                throw new Error(`Duplicate Sequence generated: ${sequenceString}`);
-            }
-
-            // 4️⃣ set the computed field on the entity
+            // Set the computed field on the trigger entity.
             (triggerEntity as any)[computedFieldMetadata.fieldName] = sequenceString;
 
-            // 5️⃣ Persist updated sequence current value
+            // Persist updated sequence current value.
             modelSequence.currentValue = nextValue;
             await modelSequenceRepo.save(modelSequence);
+        };
+
+        if (contextManager?.queryRunner?.isTransactionActive) {
+            await compute(contextManager);
+            return;
+        }
+
+        await this.dataSource.transaction(async (manager) => {
+            await compute(manager);
         });
     }
 
-}
+}

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);
 
   }
 

package/src/services/dashboard.service.ts

@@ -15,6 +15,7 @@ import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DashboardMapper } from 'src/mappers/dashboard-mapper';
 import { DashboardRepository } from 'src/repository/dashboard.repository';
 import { Dashboard } from '../entities/dashboard.entity';
+import { CreateDashboardDto } from 'src/dtos/create-dashboard.dto';
 
 
 export const SQL_DYNAMIC_PROVIDER_NAME = 'DashboardVariableSQLDynamicProvider';
@@ -33,6 +34,12 @@ export class DashboardService extends CRUDService<Dashboard> {
     super(entityManager, repo, 'dashboard', 'solid-core', moduleRef);
   }
 
+
+  async create(createDto: CreateDashboardDto, files: Express.Multer.File[]) {
+    createDto.name = createDto.name.trim().replace(/\s+/g, '-').toLowerCase();
+    return super.create(createDto, files);
+  }
+
   async getSelectionDynamicValues(query: DashboardVariableSelectionDynamicQueryDto) {
     // Get the dashboard variable repo
     const dashboardVariable = await this.loadDashboardVariable(query.variableId);