@solidstarters/solid-core 1.2.56 → 1.2.58

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-helper.service.ts

@@ -52,7 +52,8 @@ export class CrudHelperService {
                     return;
                 }
                 else { // Recursively call the applyFilters method to handle nested conditions
-                    selectQb.leftJoin(`${alias}.${key}`, key);
+                    const joinField = `${alias}.${key}`;
+                    if (!this.isRelationJoined(selectQb, joinField)) selectQb.leftJoin(joinField, key);
                     this.applyFilters(qb, primaryFilterObj, key, selectQb);
                 }
             });
@@ -150,6 +151,11 @@ export class CrudHelperService {
         return queryBuilder.expressionMap.joinAttributes.some(join => join.entityOrProperty === joinProperty);
     }
 
+    private hasJoins(queryBuilder: SelectQueryBuilder<any>): boolean {
+        return queryBuilder.expressionMap.joinAttributes.length > 0;
+    }
+
+
     buildFilterQuery(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string): SelectQueryBuilder<any> { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
         const { fields, sort, groupBy, populate = [] } = basicFilterDto;
@@ -163,6 +169,11 @@ export class CrudHelperService {
             throw new Error('buildFilterQuery: Only 1 Group by field is supported currently');
         }
 
+        // Depending upon the populate option, apply the join clause
+        if (normalizedPopulate && normalizedPopulate.length) {
+            this.buildPopulateQuery(normalizedPopulate, entityAlias, qb);
+        }
+
         if (filters) {
             qb.where(new Brackets(whereQb => {
                 this.applyFilters(whereQb, filters, entityAlias, qb);
@@ -177,15 +188,6 @@ export class CrudHelperService {
             }));
         }
 
-        // Depending upon the populate option, apply the join clause
-        if (normalizedPopulate && normalizedPopulate.length) {
-            normalizedPopulate.forEach((relation) => {
-                // Check if the relation is already joined, if not then join it
-                const joinProperty = `${entityAlias}.${relation}`;
-                if (!this.isRelationJoined(qb, joinProperty)) qb.leftJoinAndSelect(joinProperty, relation);
-            });
-        }
-
         // Depending upon the order option, apply the order by clause
         if (normalizedSort && normalizedSort.length) {
             const orderOptions = this.orderOptions(normalizedSort);
@@ -214,9 +216,33 @@ export class CrudHelperService {
                 qb.addGroupBy(`${entityAlias}.${field}`);
             });
         }
-        // Apply the pagination options
-        if (limit) qb.limit(limit);
-        if (offset) qb.offset(offset);
+        
+        // Apply the pagination options & handle the case when the query has joins
+        if (limit) this.hasJoins(qb) ? qb.take(limit) : qb.limit(limit);
+        if (offset) this.hasJoins(qb) ? qb.skip(offset): qb.offset(offset);
+        return qb;
+    }
+
+    private buildPopulateQuery(normalizedPopulate: string[], entityAlias: string, qb: SelectQueryBuilder<any>) {
+        normalizedPopulate.forEach((relation) => {
+            this.buildJoinQueryForRelation(qb, entityAlias, relation);
+        });
+        return qb;
+    }
+
+    private buildJoinQueryForRelation(qb: SelectQueryBuilder<any>, entityAlias: string, relation: string) {
+        // We split the joinProperty to get the alias of the entity we are joining
+        const relationParts = relation.split('.');
+        let parentAlias = entityAlias;
+        relationParts.forEach((part, i) => {
+            const joinProperty = `${parentAlias}.${part}`;
+            // Check if the relation is already joined, if not then join it
+            if (!this.isRelationJoined(qb, joinProperty)) {
+                const joinAlias = relationParts.slice(0, i + 1).join('_');
+                qb.leftJoinAndSelect(joinProperty, joinAlias); 
+            }
+            parentAlias = part; // Update the parent alias for the next iteration
+        });
         return qb;
     }
 

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');
             }
@@ -99,20 +104,6 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    private async loadInverseRelationFields() {
-        const fieldMetadataRepo = this.entityManager.getRepository(FieldMetadata);
-        // Since the fields in the dto could be a result of being on a inverse side of a relation, we need to get the field configuration from the inverse side to process it
-        const inverseRelationFields = await fieldMetadataRepo.find({
-            where: {
-                type: 'relation',
-                relationCoModelSingularName: this.modelName,
-                relationCreateInverse: true,
-            },
-            relations: ['model'],
-        });
-        return inverseRelationFields;
-    }
-
     private async loadModel() {
         return await this.modelMetadataService.findOneBySingularName(this.modelName, {
             fields: {
@@ -174,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');
             }
@@ -414,28 +408,22 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         const alias = 'entity';
         // Extract the required keys from the input query
         let { limit, offset, populateMedia, populateGroup, groupFilter } = basicFilterDto;
-        const model = await this.loadModel();
+        const {singularName} = await this.loadModel();
         // Check wheather user has update permission for model
         if (solidRequestContext.activeUser) {
-            const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, singularName);
             if (!hasPermission) {
                 throw new BadRequestException('Forbidden');
             }
         }
 
-        // Exclude one-to-many and many-to-one relations from the initial filter query, since they will be queried separately
-        const relationsExcludedFromInitialQuery = this.relationsExcludedFromInitialQuery(model, basicFilterDto.populate);
-        basicFilterDto = this.getRevisedFilterDto(basicFilterDto, relationsExcludedFromInitialQuery);
-        
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
         qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
         
         if (basicFilterDto.groupBy) {
-            const relationsExcludedFromInitialQuery = this.relationsExcludedFromInitialQuery(model, groupFilter.populate);
-            groupFilter = this.getRevisedFilterDto(groupFilter, relationsExcludedFromInitialQuery);
             // Get the records and the count
-            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia, relationsExcludedFromInitialQuery);
+            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia);
             return {
                 groupMeta,
                 groupRecords,
@@ -443,7 +431,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
         else {
             // Get the records and the count
-            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias, relationsExcludedFromInitialQuery);
+            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias);
             return {
                 meta,
                 records,
@@ -451,28 +439,9 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
-    private getRevisedFilterDto(basicFilterDto: BasicFilterDto, relationsExcludedFromInitialQuery: string[]): BasicFilterDto {
-        const normalizedPopulate = this.crudHelperService.normalize(basicFilterDto.populate);
-        if (normalizedPopulate.length === 0 || relationsExcludedFromInitialQuery.length === 0) return basicFilterDto;
-        return  { ...basicFilterDto, populate: normalizedPopulate.filter(populate => !relationsExcludedFromInitialQuery.includes(populate)) };
-    }
-
-    private relationsExcludedFromInitialQuery(model: ModelMetadata, relationsToBePopulated: string[] = []): string[] {
-        const  relationToBeExcluded =
-         model.fields
-        .filter(field => field.type === 'relation' && [RelationType.manyTomany, RelationType.oneToMany].includes(field.relationType as RelationType))
-        .map(field => field.name);
-        return relationsToBePopulated.filter(relation => relationToBeExcluded.includes(relation));
-    }
-
-    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number, alias: string, relationsExcludedFromInitialQuery: string[]) {
+    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number, alias: string) {
         const [entities, count] = await qb.getManyAndCount();
 
-        // Populate the excluded relations for the entities
-        if (relationsExcludedFromInitialQuery.length > 0) {
-            await this.populateExcludedRelations(entities, relationsExcludedFromInitialQuery, alias);
-        }
-
         // Populate the entity with the media
         if (populateMedia && populateMedia.length > 0) {
             await this.handlePopulateMedia(populateMedia, entities);
@@ -481,36 +450,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         return this.wrapFindResponse(offset, limit, count, entities);
     }
 
-    private async populateExcludedRelations(entities: T[], relationsExcludedFromInitialQuery: string[], alias: string) {
-        //@ts-ignore
-        const ids = entities.map(entity => entity.id);
-
-        // Fire a query to get the records from the relation entity which match the ids
-        // Create a map with key as the entity id and value as the qb records
-        const relationEntitiesMap = {};
-        for (const relation of relationsExcludedFromInitialQuery) {
-            const qb = this.repo.createQueryBuilder(`${alias}`)
-                .leftJoinAndSelect(`${alias}.${relation}`, relation)
-                .where(`${alias}.id IN (:...ids)`, { ids })
-                // .limit(DEFAULT_LIMIT)
-                // .offset(DEFAULT_OFFSET);
-            const relationEntities = await qb.getMany();
-            relationEntitiesMap[relation] = relationEntities;
-        }
-
-        // Iterate over the map and assign the relation entities to the entity
-        for (const relation of relationsExcludedFromInitialQuery) {
-            for (const entity of entities) {
-                const entityRelations = relationEntitiesMap[relation]
-                    //@ts-ignore
-                    .filter((joinedEntity: T) => joinedEntity.id === entity.id)
-                    .flatMap((joinedEntity: T) => joinedEntity[relation]);
-                entity[relation] = entityRelations;
-            }
-        }
-    }
-
-    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[], relationsExcludedFromInitialQuery: string[]) {
+    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -523,11 +463,6 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
 
-                // Populate the excluded relations for the entities
-                if (relationsExcludedFromInitialQuery.length > 0) {
-                    await this.populateExcludedRelations(entities, relationsExcludedFromInitialQuery, alias);
-                }
-
                 // Populate the entity with the media
                 if (populateMedia && populateMedia.length > 0) {
                     await this.handlePopulateMedia(populateMedia, entities);

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

package/src/solid-core.module.ts

@@ -154,7 +154,14 @@ import { RequestContextService } from './services/request-context.service';
 import { SecurityRuleRepository } from './repository/security-rule.repository';
 import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ListOfValuesController } from './controllers/list-of-values.controller';
-
+import { ChatterMessage } from './entities/chatter-message.entity';
+import { ChatterMessageService } from './services/chatter-message.service';
+import { ChatterMessageController } from './controllers/chatter-message.controller';
+import { ChatterMessageDetails } from './entities/chatter-message-details.entity';
+import { ChatterMessageDetailsService } from './services/chatter-message-details.service';
+import { ChatterMessageDetailsController } from './controllers/chatter-message-details.controller';
+import { AuditSubscriber } from './subscribers/audit.subscriber';
+import { UserContextService } from './services/user-context.service';
 
 @Global()
 @Module({
@@ -203,6 +210,8 @@ import { ListOfValuesController } from './controllers/list-of-values.controller'
     TypeOrmModule.forFeature([SecurityRule]),
     TypeOrmModule.forFeature([SavedFilters]),
     TypeOrmModule.forFeature([ListOfValues]),
+    TypeOrmModule.forFeature([ChatterMessage]),
+    TypeOrmModule.forFeature([ChatterMessageDetails]),
     // TypeOrmModule.forFeature([User]),
   ],
   controllers: [
@@ -232,7 +241,9 @@ import { ListOfValuesController } from './controllers/list-of-values.controller'
     UserViewMetadataController,
     SecurityRuleController,
     SavedFiltersController,
-    ListOfValuesController
+    ListOfValuesController,
+    ChatterMessageController,
+    ChatterMessageDetailsController
   ],
   providers: [
     {
@@ -333,7 +344,11 @@ import { ListOfValuesController } from './controllers/list-of-values.controller'
     SecurityRuleRepository,
     SecurityRuleSubscriber,
     RequestContextService,
-    SavedFiltersService
+    SavedFiltersService,
+    ChatterMessageService,
+    ChatterMessageDetailsService,
+    AuditSubscriber,
+    UserContextService,
   ],
   exports: [
     ModuleMetadataService,