@solidstarters/solid-core 1.2.57 → 1.2.59

package/src/services/authentication.service.ts

@@ -39,6 +39,7 @@ import {
     RegistrationValidationSource,
     TransactionalRegistrationValidationSource
 } from "../constants";
+import { SettingService } from './setting.service';
 import { CreateUserDto } from 'src/dtos/create-user.dto';
 
 enum LoginProvider {
@@ -71,6 +72,7 @@ export class AuthenticationService {
         private readonly mailService: SMTPEMailService,
         private readonly smsService: Msg91OTPService,
         private readonly eventEmitter: EventEmitter2,
+        private readonly settingService: SettingService,
     ) { }
 
     async resolveUser(username: string, email: string) {
@@ -108,7 +110,7 @@ export class AuthenticationService {
 
     async signUp(signUpDto: SignUpDto, activeUser: ActiveUserData = null): Promise<User> {
         // If public registrations are disabled and no activeUser is present when invoking signUp then we throw an exception.
-        if (!this.iamConfiguration.allowPublicRegistration && !activeUser) {
+        if (!(await this.settingService.getConfigValue('allowPublicRegistration')) && !activeUser) {
             throw new BadRequestException('Public registrations are disabled.');
         }
 
@@ -278,7 +280,7 @@ export class AuthenticationService {
                 user = this.createUser(signUpDto);
                 this.populateVerificationTokens(finalRegistrationVerificationSources, user);
                 await this.userRepository.save(user);
-                await this.userService.addRoleToUser(user.username, this.iamConfiguration.defaultRole);
+                await this.userService.addRoleToUser(user.username, await this.settingService.getConfigValue('defaultRole'));
             }
             else {
                 this.populateVerificationTokens(finalRegistrationVerificationSources, user);
@@ -397,7 +399,7 @@ export class AuthenticationService {
             user.emailVerifiedOnRegistrationAt = new Date();
             user.emailVerificationTokenOnRegistration = null;
             user.emailVerificationTokenOnRegistrationExpiresAt = null;
-            user.active = this.iamConfiguration.activateUserOnRegistration && this.areRegistrationValidationSourcesVerified(user);
+            user.active = await this.settingService.getConfigValue('activateUserOnRegistration') && this.areRegistrationValidationSourcesVerified(user);
             const savedUser: User = await this.userRepository.save(user);
             this.triggerRegistrationEvent(savedUser);
             return { active: savedUser.active, message: `User registration verified for ${confirmSignUpDto.type}` }
@@ -419,7 +421,7 @@ export class AuthenticationService {
             user.mobileVerifiedOnRegistrationAt = new Date();
             user.mobileVerificationTokenOnRegistration = null;
             user.mobileVerificationTokenOnRegistrationExpiresAt = null;
-            user.active = this.iamConfiguration.activateUserOnRegistration && this.areRegistrationValidationSourcesVerified(user);
+            user.active = await this.settingService.getConfigValue('activateUserOnRegistration') && this.areRegistrationValidationSourcesVerified(user);
             const savedUser: User = await this.userRepository.save(user);
             this.triggerRegistrationEvent(savedUser);
             return { active: savedUser.active, message: `User registration verified for ${confirmSignUpDto.type}` }
@@ -976,8 +978,8 @@ export class AuthenticationService {
 
     }
 
-    private isPasswordlessRegistrationEnabled() {
-        return this.iamConfiguration.passwordlessRegistration;
+    private async isPasswordlessRegistrationEnabled() {
+        return this.settingService.getConfigValue('passwordlessRegistration');
     }
 
     //FIXME - Pending implementation

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef  } from "@nestjs/core";
+import { EntityManager, Repository, In } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from 'src/services/file.service';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+
+import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
+import { UserContextService } from './user-context.service';
+
+@Injectable()
+export class ChatterMessageDetailsService extends CRUDService<ChatterMessageDetails>{
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ChatterMessageDetails, 'default')
+    readonly repo: Repository<ChatterMessageDetails>,
+    readonly moduleRef: ModuleRef,
+    readonly userContextService: UserContextService
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'chatterMessageDetails', 'solid-core', moduleRef, userContextService);
+  }
+}

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

@@ -0,0 +1,301 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef  } from "@nestjs/core";
+import { EntityManager, Repository, EntityMetadata } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from 'src/services/file.service';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { PostChatterMessageDto } from 'src/dtos/post-chatter-message.dto';
+import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
+import { ChatterMessage } from '../entities/chatter-message.entity';
+import { getMediaStorageProvider } from './mediaStorageProviders';
+import { MediaStorageProviderType } from '../dtos/create-media-storage-provider-metadata.dto';
+import { ChatterMessageDetails } from '../entities/chatter-message-details.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { UserContextService } from './user-context.service';
+@Injectable()
+export class ChatterMessageService extends CRUDService<ChatterMessage>{
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(ChatterMessage, 'default')
+    readonly repo: Repository<ChatterMessage>,
+    @InjectRepository(ChatterMessageDetails, 'default')
+    readonly chatterMessageDetailsRepo: Repository<ChatterMessageDetails>,
+    readonly moduleRef: ModuleRef,
+    @InjectRepository(ModelMetadata)
+    private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    readonly userContextService: UserContextService
+ ) {
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'chatterMessage', 'solid-core', moduleRef, userContextService);
+ }
+
+ async postMessage(postDto: PostChatterMessageDto, solidRequestContext: SolidRequestContextDto, files: Express.Multer.File[] = []) {
+    const chatterMessage = new ChatterMessage();
+    chatterMessage.messageType = 'custom';
+    chatterMessage.messageSubType = postDto.messageSubType || 'general';
+    chatterMessage.messageBody = postDto.messageBody;
+    chatterMessage.coModelEntityId = postDto.coModelEntityId;
+    chatterMessage.coModelName = postDto.coModelName;
+    
+    const userId = typeof solidRequestContext.activeUser === 'object' 
+        ? solidRequestContext.activeUser.sub 
+        : solidRequestContext.activeUser;
+    
+    chatterMessage.user = { id: userId } as any;
+
+    const savedMessage = await this.repo.save(chatterMessage);
+
+    if (files && files.length > 0) {
+      const model = await this.modelMetadataService.findOneBySingularName('chatterMessage', {
+        fields: {
+          model: true,
+          mediaStorageProvider: true,
+        },
+        module: true,
+      });
+
+      const mediaFields = model.fields.filter(field => field.type === 'mediaSingle' || field.type === 'mediaMultiple');
+
+      for (const mediaField of mediaFields) {
+        const media = files.filter(multerFile => multerFile.fieldname === mediaField.name);
+        if (media.length > 0) {
+          const storageProviderMetadata = mediaField.mediaStorageProvider;
+          const storageProviderType = storageProviderMetadata.type as MediaStorageProviderType;
+          const storageProvider = await getMediaStorageProvider(this.moduleRef, storageProviderType);
+          await storageProvider.store(media, savedMessage, mediaField);
+        }
+      }
+    }
+
+    return savedMessage;
+ }
+
+ async postAuditMessageOnInsert(entity: any, metadata: EntityMetadata, activeUser: any, messageQueue: boolean = false) {
+    const model = await this.modelMetadataRepo.findOne({
+        where: {
+            displayName: metadata.name
+        },
+        relations: {
+            fields: true,
+            module: true
+        }
+    });
+
+    if (!model || !model.enableAuditTracking) {
+        return;
+    }
+
+    const auditFields = model.fields.filter(field => 
+        field.enableAuditTracking && 
+        !['oneToMany', 'mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type)
+    );
+
+    const chatterMessage = new ChatterMessage();
+    chatterMessage.messageType = 'audit';
+    chatterMessage.messageSubType = 'insert';
+    chatterMessage.coModelEntityId = entity.id;
+    chatterMessage.coModelName = model.singularName;
+    chatterMessage.messageBody = `New ${model.displayName} created`;
+    
+    if (activeUser) {
+        const userId = typeof activeUser === 'object' ? activeUser.sub : activeUser;
+        chatterMessage.user = { id: userId } as any;
+    } else {
+        chatterMessage.user = null;
+    }
+
+    const savedMessage = await this.repo.save(chatterMessage);
+
+    for (const field of auditFields) {
+        const fieldValue = entity[field.name];
+        if (fieldValue !== undefined && fieldValue !== null) {
+            const messageDetail = new ChatterMessageDetails();
+            messageDetail.chatterMessage = savedMessage;
+            messageDetail.fieldName = field.name;
+            messageDetail.oldValue = null;
+            messageDetail.oldValueDisplay = null;
+            messageDetail.newValue = this.formatFieldValue(field, fieldValue);
+            messageDetail.newValueDisplay = this.formatFieldValueDisplay(field, fieldValue);
+            await this.chatterMessageDetailsRepo.save(messageDetail);
+        }
+    }
+}
+
+async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEntity: any, activeUser: any, messageQueue: boolean = false) {
+    const model = await this.modelMetadataRepo.findOne({
+        where: {
+            displayName: metadata.name
+        },
+        relations: {
+            fields: true,
+            module: true
+        }
+    });
+
+    if (!model || !model.enableAuditTracking) {
+        return;
+    }
+
+    const auditFields = model.fields.filter(field => 
+        field.enableAuditTracking && 
+        !['oneToMany', 'mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type)
+    );
+
+    const relationFields = auditFields.filter(field => 
+        field.type === 'relation'
+    );
+    if (relationFields.length > 0) {
+        const populatedEntity = await this.entityManager.findOne(metadata.target, {
+            where: { id: databaseEntity.id },
+            relations: relationFields.map(field => field.name)
+        });
+        if (populatedEntity) {
+            databaseEntity = populatedEntity;
+        }
+    }
+
+    const changedFields = auditFields.filter(field => {
+        const newValue = entity[field.name];
+        const oldValue = databaseEntity[field.name];
+        return this.hasValueChanged(newValue, oldValue);
+    });
+
+    if (changedFields.length === 0) {
+        return;
+    }
+
+    const chatterMessage = new ChatterMessage();
+    chatterMessage.messageType = 'audit';
+    chatterMessage.messageSubType = 'update';
+    chatterMessage.coModelEntityId = entity.id;
+    chatterMessage.coModelName = model.singularName;
+    chatterMessage.messageBody = `${model.displayName} updated`;
+    
+    if (activeUser) {
+        const userId = typeof activeUser === 'object' ? activeUser.sub : activeUser;
+        chatterMessage.user = { id: userId } as any;
+    } else {
+        chatterMessage.user = null;
+    }
+
+    const savedMessage = await this.repo.save(chatterMessage);
+
+    for (const field of changedFields) {
+        const messageDetail = new ChatterMessageDetails();
+        messageDetail.chatterMessage = savedMessage;
+        messageDetail.fieldName = field.name;
+        messageDetail.oldValue = this.formatFieldValue(field, databaseEntity[field.name]);
+        messageDetail.newValue = this.formatFieldValue(field, entity[field.name]);
+        messageDetail.oldValueDisplay = this.formatFieldValueDisplay(field, databaseEntity[field.name]);
+        messageDetail.newValueDisplay = this.formatFieldValueDisplay(field, entity[field.name]);
+        await this.chatterMessageDetailsRepo.save(messageDetail);
+    }
+}
+
+async postAuditMessageOnDelete(entity: any, metadata: EntityMetadata, databaseEntity: any, activeUser: any, messageQueue: boolean = false) {
+    const model = await this.modelMetadataRepo.findOne({
+        where: {
+            displayName: metadata.name
+        },
+        relations: {
+            fields: true,
+            module: true
+        }
+    });
+
+    if (!model || !model.enableAuditTracking) {
+        return;
+    }
+
+    const chatterMessage = new ChatterMessage();
+    chatterMessage.messageType = 'audit';
+    chatterMessage.messageSubType = 'delete';
+    chatterMessage.coModelEntityId = databaseEntity.id;
+    chatterMessage.coModelName = model.singularName;
+    chatterMessage.messageBody = `${model.displayName} deleted`;
+    
+    if (activeUser) {
+        const userId = typeof activeUser === 'object' ? activeUser.sub : activeUser;
+        chatterMessage.user = { id: userId } as any;
+    } else {
+        chatterMessage.user = null;
+    }
+
+    await this.repo.save(chatterMessage);
+}
+
+private formatFieldValue(field: any, value: any): string {
+    if (value === null || value === undefined) {
+        return '';
+    }
+
+    if (field.type === 'selectionStatic' || field.type === 'selectionDynamic') {
+        return `${value}`;
+    }
+
+    if (field.type === 'relation') {
+        if (field.relationType === "many-to-one") {
+            return value.id;
+        }
+        if (field.relationType === 'manyToMany') {
+            return value.map(item => item.id).join(', ');
+        }
+    }
+
+
+    return value.toString();
+}
+
+private formatFieldValueDisplay(field: any, value: any): string {
+    if (value === null || value === undefined) {
+        return '';
+    }
+
+    if (field.type === 'selectionStatic' || field.type === 'selectionDynamic') {
+        return `${value}`;
+    }
+
+    if (field.type === 'relation') {
+        if (field.relationType === "many-to-one") {
+            return value.name;
+        }
+        if (field.relationType === 'many-toMany') {
+            return value.map(item => item.name).join(', ');
+        }
+    }
+
+
+    return value.toString();
+}
+
+private hasValueChanged(newValue: any, oldValue: any): boolean {
+    if (newValue === oldValue) {
+        return false;
+    }
+
+    if (newValue === null && oldValue === null) {
+        return false;
+    }
+
+    if (newValue === undefined && oldValue === undefined) {
+        return false;
+    }
+
+    if (Array.isArray(newValue) && Array.isArray(oldValue)) {
+        return JSON.stringify(newValue) !== JSON.stringify(oldValue);
+    }
+
+    return true;
+}
+}

package/src/services/crud.service.ts

@@ -34,7 +34,8 @@ import { FileService } from "./file.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
-
+import { UserContextService } from "./user-context.service";
+import { Optional } from "@nestjs/common";
 const DEFAULT_LIMIT = 10;
 const DEFAULT_OFFSET = 0;
 export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDto, so we get the proper types in our service
@@ -50,7 +51,8 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         readonly repo: Repository<T>,
         readonly modelName: string,
         readonly moduleName: string,
-        readonly moduleRef: ModuleRef
+        readonly moduleRef: ModuleRef,
+        @Optional() readonly userContextService?: UserContextService
         //We can just have the Model Entity here
     ) { }
 
@@ -66,6 +68,9 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // Check wheather user has create permission for model
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasCreatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            if (this.userContextService) {
+                this.userContextService.setUser(solidRequestContext.activeUser);
+            }
             if (!hasPermission) {
                 throw new BadRequestException('Forbidden');
             }
@@ -160,6 +165,9 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasUpdatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            if (this.userContextService) {
+                this.userContextService.setUser(solidRequestContext.activeUser);
+            }
             if (!hasPermission) {
                 throw new BadRequestException('Forbidden');
             }

package/src/services/setting.service.ts

@@ -38,31 +38,88 @@ export class SettingService extends CRUDService<Setting> {
     );
   }
 
-  async wrapSettings(): Promise<Record<string, any>> {
-    const settingsArray: any[] = await this.repo.find();
+  async seedDefaultSettings(): Promise<void> {
+    const settingsSeederData = {
+      allowPublicRegistration: this.iamConfiguration.allowPublicRegistration,
+      iamPasswordRegistrationEnabled: this.iamConfiguration.iamPasswordRegistrationEnabled,
+      passwordlessRegistration: this.iamConfiguration.passwordlessRegistration,
+      activateUserOnRegistration: this.iamConfiguration.activateUserOnRegistration,
+      iamGoogleOAuthEnabled: false,
+      authPagesLayout: "center",
+      authPagesTheme: "light",
+      appTitle: process.env.SOLID_APP_NAME || "Solid App",
+      appLogo: "",
+      appDescription: "",
+      appTnc: "",
+      appPrivacyPolicy: "",
+      defaultRole: this.iamConfiguration.defaultRole,
+      shouldQueueEmails: this.commonConfiguration.shouldQueueEmails,
+      shouldQueueSms: this.commonConfiguration.shouldQueueSms
+    };
 
-    if (!settingsArray || settingsArray.length === 0) {
-      return this.getDefaultSettings();
+    const existingSettings = await this.repo.find();
+    const existingKeys = new Set(existingSettings.map(s => s.key));
+
+    const settingsToInsert: Setting[] = [];
+    for (const [key, value] of Object.entries(settingsSeederData)) {
+      if (!existingKeys.has(key)) {
+        const setting = new Setting();
+        setting.key = key;
+        setting.value = typeof value === 'boolean' ? value.toString() : 
+                        Array.isArray(value) ? value.join(',') : 
+                        value === null || value === undefined ? '' : String(value);
+        settingsToInsert.push(setting);
+      }
     }
 
-    const settings = settingsArray[0];
+    if (settingsToInsert.length > 0) {
+      await this.repo.save(settingsToInsert);
+    }
+  }
 
+  async wrapSettings(): Promise<Record<string, any>> {
+    const settingsArray: Setting[] = await this.repo.find();
+    
+    if (!settingsArray || settingsArray.length === 0) {
+      return this.getDefaultSettings();
+    }
+    
+    const settingsMap: Record<string, any> = {};
+    for (const setting of settingsArray) {
+      if (setting.key && setting.value !== undefined && setting.value !== null) {
+        let value = setting.value;
+        
+        if (value === 'true' || value === 'false') {
+          settingsMap[setting.key] = value === 'true';
+        }
+        else if (!isNaN(Number(value)) && value.trim() !== '') {
+          settingsMap[setting.key] = Number(value);
+        }
+        else if (value.includes(',')) {
+          settingsMap[setting.key] = value.split(',').map(item => item.trim());
+        }
+        else {
+          settingsMap[setting.key] = value;
+        }
+      }
+    }
+    
     const defaultSettings = this.getDefaultSettings();
-
+    
     const mergedSettings = Object.keys(defaultSettings).reduce((acc, key) => {
-      acc[key] = settings[key] !== null && settings[key] !== undefined ? settings[key] : defaultSettings[key];
+      acc[key] = settingsMap[key] !== undefined ? settingsMap[key] : defaultSettings[key];
       return acc;
     }, {} as Record<string, any>);
-
+    
     return mergedSettings;
   }
-
+  
   private getDefaultSettings(): Record<string, any> {
     return {
-      iamAllowPublicRegistration: this.iamConfiguration.allowPublicRegistration,
-      iamPasswordRegistrationEnabled: false,
-      iamPasswordLessRegistrationEnabled: this.iamConfiguration.passwordlessRegistration,
-      iamActivateUserOnRegistration: this.iamConfiguration.activateUserOnRegistration,
+      allowPublicRegistration: this.iamConfiguration.allowPublicRegistration,
+      iamPasswordRegistrationEnabled: this.iamConfiguration.iamPasswordRegistrationEnabled,
+      passwordlessRegistration: this.iamConfiguration.passwordlessRegistration,
+      activateUserOnRegistration: this.iamConfiguration.activateUserOnRegistration,
       iamGoogleOAuthEnabled: false,
       authPagesLayout: "center",
       authPagesTheme: "light",
@@ -71,10 +128,102 @@ export class SettingService extends CRUDService<Setting> {
       appDescription: "",
       appTnc: "",
       appPrivacyPolicy: "",
-      iamDefaultRole: this.iamConfiguration.defaultRole,
+      defaultRole: this.iamConfiguration.defaultRole,
       shouldQueueEmails: this.commonConfiguration.shouldQueueEmails,
       shouldQueueSms: this.commonConfiguration.shouldQueueSms
     };
   }
 
+  async getConfigValue(settingKey: string) {
+    try {
+        const settingsArray: Setting[] = await this.repo.find();
+        const settingEntry = settingsArray.find(setting => setting.key === settingKey);
+        
+        if (settingEntry && settingEntry.value !== null && settingEntry.value !== undefined) {
+            const value = settingEntry.value;
+            
+            if (value === 'true' || value === 'false') {
+                return value === 'true';
+            }
+            else if (!isNaN(Number(value)) && value.trim() !== '') {
+                return Number(value);
+            }
+            else if (value.includes(',')) {
+                return value.split(',').map(item => item.trim());
+            }
+            else {
+                return value;
+            }
+        }
+        
+        const defaultSettings = this.getDefaultSettings();
+        return defaultSettings[settingKey];
+    } catch (error) {
+        const defaultSettings = this.getDefaultSettings();
+        return defaultSettings[settingKey];
+    }
+  }
+
+  async updateSettings(settings: Record<string, any>): Promise<Setting[]> {
+    const existingSettings = await this.repo.find();
+    const existingKeys = new Set(existingSettings.map(s => s.key));
+    
+    const settingsToUpdate: Setting[] = [];
+    const settingsToCreate: Setting[] = [];
+    
+    for (const [key, value] of Object.entries(settings)) {
+      const stringValue = typeof value === 'boolean' ? value.toString() : 
+                         Array.isArray(value) ? value.join(',') : 
+                         value === null || value === undefined ? '' : String(value);
+
+      if (existingKeys.has(key)) {
+        const existingSetting = existingSettings.find(s => s.key === key);
+        if (existingSetting) {
+          existingSetting.value = stringValue;
+          settingsToUpdate.push(existingSetting);
+        }
+      } else {
+        const newSetting = new Setting();
+        newSetting.key = key;
+        newSetting.value = stringValue;
+        settingsToCreate.push(newSetting);
+      }
+    }
+    
+    if (settingsToUpdate.length > 0) {
+      await this.repo.save(settingsToUpdate);
+    }
+    
+    if (settingsToCreate.length > 0) {
+      await this.repo.save(settingsToCreate);
+    }
+    
+    return [...settingsToUpdate, ...settingsToCreate];
+  }
+
+  async getAllSettings(): Promise<Record<string, any>> {
+    const settingsArray = await this.repo.find();
+    const settingsMap: Record<string, any> = {};
+    
+    for (const setting of settingsArray) {
+      if (setting.key && setting.value !== undefined && setting.value !== null) {
+        const value = setting.value;
+        
+        if (value === 'true' || value === 'false') {
+          settingsMap[setting.key] = value === 'true';
+        }
+        else if (!isNaN(Number(value)) && value.trim() !== '') {
+          settingsMap[setting.key] = Number(value);
+        }
+        else if (value.includes(',')) {
+          settingsMap[setting.key] = value.split(',').map(item => item.trim());
+        }
+        else {
+          settingsMap[setting.key] = value;
+        }
+      }
+    }
+    
+    return settingsMap;
+  }
 }

package/src/services/user-context.service.ts

@@ -0,0 +1,31 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+
+@Injectable()
+export class UserContextService {
+    private readonly logger = new Logger(UserContextService.name);
+    private static currentUser: any = null;
+
+    setUser(user: any) {
+        this.logger.debug(`Setting user: ${JSON.stringify(user)}`);
+        UserContextService.currentUser = user;
+    }
+
+    getUser() {
+        return UserContextService.currentUser;
+    }
+
+    runWithUser<T>(user: any, callback: () => T): T {
+        const previousUser = this.getUser();
+        try {
+            this.setUser(user);
+            return callback();
+        } finally {
+            this.setUser(previousUser);
+        }
+    }
+
+    getCurrentUser(): ActiveUserData | null {
+        return this.getUser();
+    }
+}