file loging and email sending is working

Author: sourcecode71

src/logger/domain/interfaces/log-repository.interface.ts

@@ -0,0 +1,14 @@
+export interface ILogRepository {
+  saveLog(log: {
+    level: string;
+    message: string;
+    trace?: string;
+    metadata?: {
+      recipient?: string;
+      notificationType?: string;
+      mediaType?: string;
+      context?: string;
+    };
+    timestamp: Date;
+  }): Promise<void>;
+}

src/logger/infrastructure/persistence/mongoose/logger.schema.ts

@@ -0,0 +1,27 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+
+@Schema({ collection: 'logger', timestamps: true })
+export class Logger extends Document {
+  @Prop({ required: true, enum: ['info', 'error'] })
+  level: string;
+
+  @Prop({ required: true })
+  message: string;
+
+  @Prop()
+  trace?: string;
+
+  @Prop({ type: Object })
+  metadata?: {
+    recipient?: string;
+    notificationType?: string;
+    mediaType?: string;
+    context?: string;
+  };
+
+  @Prop({ default: Date.now })
+  timestamp: Date;
+}
+
+export const LoggerSchema = SchemaFactory.createForClass(Logger);

src/logger/infrastructure/repositories/log.repository.ts

@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { ILogRepository } from '../../domain/interfaces/log-repository.interface';
+import { Logger } from '../persistence/mongoose/logger.schema';
+
+@Injectable()
+export class LogRepository implements ILogRepository {
+  constructor(
+    @InjectModel(Logger.name)
+    private readonly loggerModel: Model<Logger>,
+  ) {}
+
+  async saveLog(log: {
+    level: string;
+    message: string;
+    trace?: string;
+    metadata?: {
+      recipient?: string;
+      notificationType?: string;
+      mediaType?: string;
+      context?: string;
+    };
+    timestamp: Date;
+  }): Promise<void> {
+    const logEntry = new this.loggerModel(log);
+    await logEntry.save();
+  }
+}

src/logger/logger.module.ts

@@ -1,8 +1,24 @@
 import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
 import { LoggerService } from './services/logger.service';
+import { LogRepository } from './infrastructure/repositories/log.repository';
+import {
+  Logger,
+  LoggerSchema,
+} from './infrastructure/persistence/mongoose/logger.schema';
 
 @Module({
-  providers: [LoggerService],
-  exports: [LoggerService],
+  imports: [
+    MongooseModule.forFeature([{ name: Logger.name, schema: LoggerSchema }]),
+  ],
+  providers: [
+    LoggerService,
+    LogRepository,
+    {
+      provide: 'ILogRepository',
+      useClass: LogRepository,
+    },
+  ],
+  exports: [LoggerService, 'ILogRepository', LogRepository],
 })
 export class LoggerModule {}

src/main.ts

@@ -2,14 +2,25 @@ import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { AllExceptionsFilter } from './filters/all-exceptions.filter';
 import { LoggerService } from './logger/services/logger.service';
+import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   const logger = app.get(LoggerService);
   app.useGlobalFilters(new AllExceptionsFilter(logger));
+
+  // Configure Swagger
+  const config = new DocumentBuilder()
+    .setTitle('SmartEduHub Utility API')
+    .setDescription('API for sending notifications via email or SMS')
+    .setVersion('1.0')
+    .build();
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('api', app, document);
+
   await app.listen(3000);
   logger.log('Application run successfully');
 }
 bootstrap().catch((error) => {
-  console.error('Error during application bootstrap:', error);
+  console.log('Error during application bootstrap:', error);
 });

src/notification/application/factories/common/notification.factory.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { NotificationChannel } from '../../../config/notification.config';
+import { INotificationStrategy } from '../../domain/interfaces/notification-strategy.interface';
+import { EmailNotificationStrategy } from '../strategies/email-notification.strategy';
+import { SMSNotificationStrategy } from '../strategies/sms-notification.strategy';
+import { UnsupportedMediaTypeError } from '../../domain/errors/unsupported-media-type.error';
+
+@Injectable()
+export class NotificationFactory {
+  constructor(
+    private readonly emailStrategy: EmailNotificationStrategy,
+    private readonly smsStrategy: SMSNotificationStrategy,
+  ) {}
+
+  createStrategy(mediaType: NotificationChannel): INotificationStrategy {
+    switch (mediaType) {
+      case NotificationChannel.EMAIL:
+        return this.emailStrategy;
+      case NotificationChannel.SMS:
+        return this.smsStrategy;
+      default:
+        throw new UnsupportedMediaTypeError(mediaType);
+    }
+  }
+}

src/notification/application/factories/notification.factory.ts

@@ -1,5 +1,5 @@
-import { INotificationStrategy } from '../../domain/interfaces/common/notification-strategy.interface';
-import { Notification } from '../../domain/entities/common/notification.entity';
+import { INotificationStrategy } from '../../domain/interfaces/notification-strategy.interface';
+import { Notification } from '../../domain/entities/notification.entity';
 
 export class EmailNotificationStrategy implements INotificationStrategy {
   constructor(private emailClient?: any) {

src/notification/application/strategies/email-notification.strategy.ts

@@ -1,5 +1,5 @@
-import { INotificationStrategy } from '../../domain/interfaces/common/notification-strategy.interface';
-import { Notification } from '../../domain/entities/common/notification.entity';
+import { INotificationStrategy } from '../../domain/interfaces/notification-strategy.interface';
+import { Notification } from '../../domain/entities/notification.entity';
 
 export class SMSNotificationStrategy implements INotificationStrategy {
   constructor(private smsClient?: any) {

src/notification/application/strategies/sms-notification.strategy.ts

@@ -1,10 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { Notification } from '../../domain/entities/common/notification.entity';
-import { INotificationStrategy } from '../../domain/interfaces/common/notification-strategy.interface';
+import { Notification } from '../../domain/entities/notification.entity';
+import { INotificationStrategy } from '../../domain/interfaces/notification-strategy.interface';
 import { NotificationFactory } from '../../infrastructure/factories/notification.factory';
 import { NotificationChannel } from '../../../config/notification.config';
 import { NotificationRepository } from '../../infrastructure/repositories/notification.repository';
 import { NotificationValidator } from '../validators/notification.validator';
+import { NotificationType } from '../../presentation/dtos/send-notification.dto';
 
 @Injectable()
 export class SendNotificationUseCase {
@@ -25,6 +26,7 @@ export class SendNotificationUseCase {
         subject,
         body,
         mediaType,
+        notificationType: NotificationType.ADMISSION_ID,
       });
     // Check for validation errors
     const error = validationResult.error;