@solidstarters/solid-core 1.2.57 → 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.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/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,

package/src/subscribers/audit.subscriber.ts

@@ -0,0 +1,73 @@
+import { Connection, EntitySubscriberInterface, EventSubscriber, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
+import { ChatterMessageService } from '../services/chatter-message.service';
+import { EntityMetadata } from 'typeorm';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ModelMetadata } from '../entities/model-metadata.entity';
+import { Repository } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+import { UserContextService } from '../services/user-context.service';
+@Injectable()
+@EventSubscriber()
+export class AuditSubscriber implements EntitySubscriberInterface {
+    
+    constructor(
+        private readonly connection: Connection,    
+        private readonly chatterMessageService: ChatterMessageService,
+        @InjectRepository(ModelMetadata)
+        private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        private readonly userContextService: UserContextService
+    ) {
+        connection.subscribers.push(this);
+    }
+
+    private async shouldTrackAudit(entity: any, metadata: EntityMetadata): Promise<boolean> {
+        const model = await this.modelMetadataRepo.findOne({
+            where: {
+                displayName: metadata.name
+            },
+            relations: {
+                fields: true,
+                module: true
+            }
+        });
+
+        if (!model || !model.enableAuditTracking) {
+            return false;
+        }
+
+        const auditFields = model.fields.filter(field => 
+            field.enableAuditTracking && 
+            !['oneToMany', 'mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(field.type)
+        );
+
+        if (auditFields.length === 0) {
+            return false;
+        }
+
+        return auditFields.some(field => {
+            const fieldValue = entity[field.name];
+            return fieldValue !== undefined && fieldValue !== null;
+        });
+    }
+
+    async afterInsert(event: InsertEvent<any>) {
+        if (await this.shouldTrackAudit(event.entity, event.metadata)) {
+            const activeUser = this.userContextService.getUser();
+            await this.chatterMessageService.postAuditMessageOnInsert(event.entity, event.metadata, activeUser);
+        }
+    }
+
+    async afterUpdate(event: UpdateEvent<any>) {
+        if (await this.shouldTrackAudit(event.entity, event.metadata)) {
+            const activeUser = this.userContextService.getUser();
+            await this.chatterMessageService.postAuditMessageOnUpdate(event.entity, event.metadata, event.databaseEntity, activeUser);
+        }
+    }
+
+    async afterRemove(event: RemoveEvent<any>) {
+        if (await this.shouldTrackAudit(event.entity, event.metadata)) {
+            const activeUser = this.userContextService.getUser();
+            await this.chatterMessageService.postAuditMessageOnDelete(event.entity, event.metadata, event.databaseEntity, activeUser);
+        }
+    }
+}