feat: add profile update notification handling for child users

- Implemented logic to skip notifications for child users (roles.JUNIOR) when their profiles are updated, preventing unnecessary notifications to both child and parent. - Enhanced logging to indicate when notifications are skipped for child users.
feat: enhance card service and transaction notification for shared account handling
2026-03-10 18:41:46 +00:00 · 2026-02-01 14:44:42 +03:00 · 2026-01-20 16:27:32 +03:00 · 2026-01-20 15:20:58 +03:00 · 2026-01-20 14:40:16 +03:00 · 2026-01-14 16:56:22 +03:00
47 changed files with 2829 additions and 199 deletions
--- a/src/auth/dtos/request/junior-login.request.dto.ts
+++ b/src/auth/dtos/request/junior-login.request.dto.ts
@ -23,4 +23,13 @@ export class JuniorLoginRequestDto {
  @IsOptional()
  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.fcmToken' }) })
  fcmToken?: string;
+
+  @ApiProperty({
+    example: 'Asia/Riyadh',
+    description: 'Device timezone (auto-detected from device OS)',
+    required: false,
+  })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.timezone' }) })
+  timezone?: string;
 }
--- a/src/auth/dtos/request/login.request.dto.ts
+++ b/src/auth/dtos/request/login.request.dto.ts
@ -35,4 +35,13 @@ export class LoginRequestDto {
  @IsOptional()
  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.fcmToken' }) })
  fcmToken?: string;
+
+  @ApiProperty({
+    example: 'Asia/Riyadh',
+    description: 'Device timezone (auto-detected from device OS)',
+    required: false,
+  })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.timezone' }) })
+  timezone?: string;
 }
--- a/src/auth/dtos/request/verify-user.request.dto.ts
+++ b/src/auth/dtos/request/verify-user.request.dto.ts
@ -115,4 +115,13 @@ export class VerifyUserRequestDto {
  @IsOptional()
  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.fcmToken' }) })
  fcmToken?: string;
+
+  @ApiProperty({
+    example: 'Asia/Riyadh',
+    description: 'Device timezone (auto-detected from device OS)',
+    required: false,
+  })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.timezone' }) })
+  timezone?: string;
 }
--- a/src/auth/services/auth.service.ts
+++ b/src/auth/services/auth.service.ts
@ -87,9 +87,9 @@ export class AuthService {
    const tokens = await this.generateAuthToken(user);
    this.logger.log(`User with phone number ${user.fullPhoneNumber} verified successfully`);

-    // Register/update device with FCM token if provided
+    // Register/update device with FCM token and timezone if provided
    if (verifyUserDto.fcmToken && verifyUserDto.deviceId) {
-      await this.registerDeviceToken(user.id, verifyUserDto.deviceId, verifyUserDto.fcmToken);
+      await this.registerDeviceToken(user.id, verifyUserDto.deviceId, verifyUserDto.fcmToken, verifyUserDto.timezone);
    }

    return [tokens, user];
@ -278,9 +278,9 @@ export class AuthService {
    const tokens = await this.generateAuthToken(user);
    this.logger.log(`Password validated successfully for user`);

-    // Register/update device with FCM token if provided
+    // Register/update device with FCM token and timezone if provided
    if (loginDto.fcmToken && loginDto.deviceId) {
-      await this.registerDeviceToken(user.id, loginDto.deviceId, loginDto.fcmToken);
+      await this.registerDeviceToken(user.id, loginDto.deviceId, loginDto.fcmToken, loginDto.timezone);
    }

    return [tokens, user];
@ -304,43 +304,67 @@ export class AuthService {
    const tokens = await this.generateAuthToken(user);
    this.logger.log(`Password validated successfully for user`);

-    // Register/update device with FCM token if provided
+    // Register/update device with FCM token and timezone if provided
    if (juniorLoginDto.fcmToken && juniorLoginDto.deviceId) {
-      await this.registerDeviceToken(user.id, juniorLoginDto.deviceId, juniorLoginDto.fcmToken);
+      await this.registerDeviceToken(user.id, juniorLoginDto.deviceId, juniorLoginDto.fcmToken, juniorLoginDto.timezone);
    }

    return [tokens, user];
  }

  /**
-   * Register or update device with FCM token
-   * This method handles both new device registration and existing device updates
+   * Register or update device with FCM token and timezone
+   * This method handles:
+   * 1. Device already exists for this user → Update FCM token and timezone
+   * 2. Device exists for different user → Transfer device to new user
+   * 3. Device doesn't exist → Create new device
   */
-  private async registerDeviceToken(userId: string, deviceId: string, fcmToken: string): Promise<void> {
+  private async registerDeviceToken(userId: string, deviceId: string, fcmToken: string, timezone?: string): Promise<void> {
    try {
      this.logger.log(`Registering/updating device ${deviceId} with FCM token for user ${userId}`);

-      // Check if device already exists for this user
-      const existingDevice = await this.deviceService.findUserDeviceById(deviceId, userId);
+      // Step 1: Check if device already exists for this user
+      const existingDeviceForUser = await this.deviceService.findUserDeviceById(deviceId, userId);

-      if (existingDevice) {
-        // Update existing device with new FCM token and last access time
+      if (existingDeviceForUser) {
+        // Device exists for this user → Update FCM token, timezone, and last access time
        await this.deviceService.updateDevice(deviceId, {
          fcmToken,
          userId,
+          timezone, // Update timezone if provided
          lastAccessOn: new Date(),
        });
-        this.logger.log(`Device ${deviceId} updated with new FCM token for user ${userId}`);
-      } else {
-        // Create new device
-        await this.deviceService.createDevice({
-          deviceId,
+        this.logger.log(`Device ${deviceId} updated with new FCM token and timezone for user ${userId}`);
+        return;
+      }
+
+      // Step 2: Check if device exists for any user (different user scenario)
+      const existingDevice = await this.deviceService.findByDeviceId(deviceId);
+
+      if (existingDevice) {
+        // Device exists for different user → Transfer device to new user
+        this.logger.log(
+          `Device ${deviceId} exists for user ${existingDevice.userId}, transferring to user ${userId}`
+        );
+        await this.deviceService.updateDevice(deviceId, {
          userId,
          fcmToken,
+          timezone, // Update timezone if provided
          lastAccessOn: new Date(),
        });
-        this.logger.log(`New device ${deviceId} registered with FCM token for user ${userId}`);
+        this.logger.log(`Device ${deviceId} transferred from user ${existingDevice.userId} to user ${userId}`);
+        return;
      }
+
+      // Step 3: Device doesn't exist → Create new device
+      await this.deviceService.createDevice({
+        deviceId,
+        userId,
+        fcmToken,
+        timezone, // Store timezone if provided
+        lastAccessOn: new Date(),
+      });
+      this.logger.log(`New device ${deviceId} registered with FCM token for user ${userId}`);
    } catch (error) {
      // Log error but don't fail the login/signup process
      const errorMessage = error instanceof Error ? error.message : String(error);
--- a/src/card/card.module.ts
+++ b/src/card/card.module.ts
@ -27,7 +27,7 @@ import { TransactionService } from './services/transaction.service';
    AccountService,
    AccountRepository,
  ],
-  exports: [CardService, TransactionService],
+  exports: [CardService, TransactionService, AccountService],
  controllers: [CardsController],
 })
 export class CardModule {}
--- a/src/card/services/card.service.ts
+++ b/src/card/services/card.service.ts
@ -1,6 +1,9 @@
 import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import Decimal from 'decimal.js';
 import { Transactional } from 'typeorm-transactional';
+import { NOTIFICATION_EVENTS } from '~/common/modules/notification/constants/event-names.constant';
+import { ICardBlockedEvent, ICardCreatedEvent } from '~/common/modules/notification/interfaces/notification-events.interface';
 import { AccountCardStatusChangedWebhookRequest } from '~/common/modules/neoleap/dtos/requests';
 import { NeoLeapService } from '~/common/modules/neoleap/services';
 import { Customer } from '~/customer/entities';
@ -8,7 +11,7 @@ import { KycStatus } from '~/customer/enums';
 import { CustomerService } from '~/customer/services';
 import { OciService } from '~/document/services';
 import { Card } from '../entities';
-import { CardColors } from '../enums';
+import { CardColors, CardStatus } from '../enums';
 import { CardStatusMapper } from '../mappers/card-status.mapper';
 import { CardRepository } from '../repositories';
 import { AccountService } from './account.service';
@ -24,6 +27,7 @@ export class CardService {
    @Inject(forwardRef(() => TransactionService)) private readonly transactionService: TransactionService,
    @Inject(forwardRef(() => NeoLeapService)) private readonly neoleapService: NeoLeapService,
    @Inject(forwardRef(() => CustomerService)) private readonly customerService: CustomerService,
+    private readonly eventEmitter: EventEmitter2,
  ) {}

  @Transactional()
@ -58,7 +62,16 @@ export class CardService {
    const account = await this.accountService.createAccount(data);
    const createdCard = await this.cardRepository.createCard(customerId, account.id, data);

-    return this.getCardById(createdCard.id);
+    const cardWithRelations = await this.getCardById(createdCard.id);
+    
+    const event: ICardCreatedEvent = {
+      card: cardWithRelations,
+      timestamp: new Date(),
+    };
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.CARD_CREATED, event);
+    this.logger.log(`Emitted CARD_CREATED event for card ${cardWithRelations.id}`);
+
+    return cardWithRelations;
  }

  async getChildCards(guardianId: string): Promise<Card[]> {
@ -77,7 +90,16 @@ export class CardService {
      parentCustomer.id,
    );

-    return this.getCardById(createdCard.id);
+    const cardWithRelations = await this.getCardById(createdCard.id);
+    
+    const event: ICardCreatedEvent = {
+      card: cardWithRelations,
+      timestamp: new Date(),
+    };
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.CARD_CREATED, event);
+    this.logger.log(`Emitted CARD_CREATED event for child card ${cardWithRelations.id}`);
+
+    return cardWithRelations;
  }

  async getCardByChildId(guardianId: string, childId: string): Promise<Card> {
@ -128,9 +150,24 @@ export class CardService {

  async updateCardStatus(body: AccountCardStatusChangedWebhookRequest) {
    const card = await this.getCardByVpan(body.cardId);
+    const previousStatus = card.status;
    const { description, status } = CardStatusMapper[body.newStatus] || CardStatusMapper['99'];

-    return this.cardRepository.updateCardStatus(card.id, status, description);
+    await this.cardRepository.updateCardStatus(card.id, status, description);
+
+    if (status === CardStatus.BLOCKED) {
+      const updatedCard = await this.getCardById(card.id);
+      const event: ICardBlockedEvent = {
+        card: updatedCard,
+        previousStatus,
+        blockReason: description,
+        timestamp: new Date(),
+      };
+      this.eventEmitter.emit(NOTIFICATION_EVENTS.CARD_BLOCKED, event);
+      this.logger.log(`Emitted CARD_BLOCKED event for card ${updatedCard.id}`);
+    }
+
+    return { id: card.id, status, description };
  }

  async getEmbossingInformation(customerId: string) {
@ -179,13 +216,64 @@ export class CardService {
      throw new BadRequestException('CARD.INSUFFICIENT_BALANCE');
    }

-    const finalAmount = Decimal(amount).plus(card.limit);
-    await Promise.all([
-      this.neoleapService.updateCardControl(card.cardReference, finalAmount.toNumber()),
-      this.updateCardLimit(card.id, finalAmount.toNumber()),
-      this.accountService.increaseReservedBalance(fundingAccount, amount),
-      this.transactionService.createInternalChildTransaction(card.id, amount),
-    ]);
+    // Validate card reference exists
+    if (!card.cardReference) {
+      this.logger.error(`Card ${card.id} does not have a cardReference`);
+      throw new BadRequestException('CARD.INVALID_CARD_REFERENCE');
+    }
+
+    // Validate card limit is a valid number
+    const cardLimit = card.limit || 0;
+    if (isNaN(cardLimit) || cardLimit < 0) {
+      this.logger.error(`Card ${card.id} has invalid limit: ${cardLimit}`);
+      throw new BadRequestException('CARD.INVALID_CARD_LIMIT');
+    }
+
+    const finalAmount = Decimal(amount).plus(cardLimit);
+    const finalAmountNumber = finalAmount.toNumber();
+
+    // Validate final amount is positive
+    if (finalAmountNumber <= 0 || !isFinite(finalAmountNumber)) {
+      this.logger.error(`Invalid final amount calculated: ${finalAmountNumber} (amount: ${amount}, limit: ${cardLimit})`);
+      throw new BadRequestException('CARD.INVALID_AMOUNT');
+    }
+
+    this.logger.debug(`Updating card control - cardReference: ${card.cardReference}, finalAmount: ${finalAmountNumber}`);
+    
+    // Check if child and parent share the same account
+    const isSharedAccount = card.parentId && card.account.id === fundingAccount.id;
+    
+    this.logger.debug(
+      `Account structure - Child account: ${card.account.id}, Parent account: ${fundingAccount.id}, ` +
+      `Shared: ${isSharedAccount ? 'YES' : 'NO'}`
+    );
+    
+    // First, ensure all external operations succeed before creating transaction
+    if (isSharedAccount) {
+      // Shared account: Only update card limit and reserved balance
+      // Money is already in the shared account, just allocate it to the child
+      this.logger.debug(`Shared account detected - only updating card limit and reserved balance`);
+      await Promise.all([
+        this.neoleapService.updateCardControl(card.cardReference, finalAmountNumber),
+        this.updateCardLimit(card.id, finalAmountNumber),
+        this.accountService.increaseReservedBalance(fundingAccount, amount),
+      ]);
+    } else {
+      // Separate accounts: Transfer money from parent to child
+      this.logger.debug(`Separate accounts - transferring money from parent to child`);
+      await Promise.all([
+        this.neoleapService.updateCardControl(card.cardReference, finalAmountNumber),
+        this.updateCardLimit(card.id, finalAmountNumber),
+        this.accountService.increaseReservedBalance(fundingAccount, amount),
+        // Increase child account balance
+        this.accountService.creditAccountBalance(card.account.accountReference, amount),
+        // Decrease parent account balance
+        this.accountService.decreaseAccountBalance(fundingAccount.accountReference, amount),
+      ]);
+    }
+
+    // Only create transaction and emit event after all operations succeed
+    await this.transactionService.createInternalChildTransaction(card.id, amount);

    return finalAmount.toNumber();
  }
--- a/src/card/services/transaction.service.ts
+++ b/src/card/services/transaction.service.ts
@ -62,11 +62,10 @@ export class TransactionService {
      await this.accountService.decreaseAccountBalance(card.account.accountReference, total.toNumber());
    }

-    // Emit event for notification system
    const event: ITransactionCreatedEvent = {
      transaction,
-      card, // Pass card with all relations loaded
-      isTopUp: false, // Card transactions are spending
+      card,
+      isTopUp: false,
      isChildSpending: card.customerType === CustomerType.CHILD,
      timestamp: new Date(),
    };
@ -88,21 +87,17 @@ export class TransactionService {
    const transaction = await this.transactionRepository.createAccountTransaction(account, body);
    await this.accountService.creditAccountBalance(account.accountReference, body.amount);

-    // Get card for notification system by account ID
-    // Account transactions are top-ups, so we get the first card associated with the account
    const accountWithCards = await this.accountService.getAccountByAccountNumber(body.accountId);
    const card = accountWithCards.cards?.[0] 
      ? await this.cardService.getCardById(accountWithCards.cards[0].id)
      : null;

-    // Only emit event if card exists (we need card for user info)
    if (card) {
-      // Emit event for notification system
      const event: ITransactionCreatedEvent = {
        transaction,
-        card, // Pass card with all relations loaded
-        isTopUp: true, // Account transactions are top-ups
-        isChildSpending: false, // Top-ups are typically not from children
+        card,
+        isTopUp: true,
+        isChildSpending: false,
        timestamp: new Date(),
      };
      this.eventEmitter.emit(NOTIFICATION_EVENTS.TRANSACTION_CREATED, event);
@ -115,15 +110,20 @@ export class TransactionService {
    const card = await this.cardService.getCardById(cardId);
    const transaction = await this.transactionRepository.createInternalChildTransaction(card, amount);
    
-    // Emit event for notification system
+    // Reload card to get updated account balance after the transfer
+    const cardWithUpdatedBalance = await this.cardService.getCardById(cardId);
+    
    const event: ITransactionCreatedEvent = {
      transaction,
-      card, // Pass card with all relations loaded
-      isTopUp: true, // Internal child transaction is a top-up to child's card
-      isChildSpending: true, // Child's card is being topped up
+      card: cardWithUpdatedBalance, // Use card with updated balance
+      isTopUp: true,
+      isChildSpending: true,
      timestamp: new Date(),
    };
+    
+    console.log(`[TransactionService] Emitting TRANSACTION_CREATED event for transaction ${transaction.id}`);
    this.eventEmitter.emit(NOTIFICATION_EVENTS.TRANSACTION_CREATED, event);
+    console.log(`[TransactionService] Event emitted successfully`);
    
    return transaction;
  }
--- a/src/common/modules/neoleap/services/neoleap.service.ts
+++ b/src/common/modules/neoleap/services/neoleap.service.ts
@ -427,10 +427,18 @@ export class NeoLeapService {
      });
    } catch (error: any) {
      if (error.status === 400) {
-        console.error('Error sending request to NeoLeap:', error);
-        throw new BadRequestException(error.response?.data?.ResponseHeader?.ResponseDescription || error.message);
+        const errorMessage = error.response?.data?.ResponseHeader?.ResponseDescription || 
+                            error.response?.data?.message || 
+                            error.message;
+        const errorCode = error.response?.data?.ResponseHeader?.ResponseCode || 'UNKNOWN';
+        this.logger.error(
+          `NeoLeap API returned 400 error for endpoint ${endpoint}. ` +
+          `Error Code: ${errorCode}, Message: ${errorMessage}. ` +
+          `Payload: ${JSON.stringify(payload)}`
+        );
+        throw new BadRequestException(errorMessage || 'Request failed with status code 400');
      }
-      console.error('Error sending request to NeoLeap:', error);
+      this.logger.error(`Error sending request to NeoLeap endpoint ${endpoint}:`, error);
      throw new InternalServerErrorException('Error communicating with NeoLeap service');
    }
  }
--- a/src/common/modules/notification/constants/event-names.constant.ts
+++ b/src/common/modules/notification/constants/event-names.constant.ts
@ -5,6 +5,28 @@
 export const NOTIFICATION_EVENTS = {
  // Transaction events
  TRANSACTION_CREATED: 'notification.transaction.created',
+  
+  // Money Request events
+  MONEY_REQUEST_CREATED: 'notification.money-request.created',
+  MONEY_REQUEST_APPROVED: 'notification.money-request.approved',
+  MONEY_REQUEST_DECLINED: 'notification.money-request.declined',
+  
+  // KYC Update events
+  KYC_APPROVED: 'notification.kyc.approved',
+  KYC_REJECTED: 'notification.kyc.rejected',
+  
+  // Card Status events
+  CARD_CREATED: 'notification.card.created',
+  CARD_BLOCKED: 'notification.card.blocked',
+  CARD_REISSUED: 'notification.card.reissued',
+  
+  // Profile Update events
+  PROFILE_UPDATED: 'notification.profile.updated',
+  
+  // System Alert events
+  MAINTENANCE_ALERT: 'notification.system.maintenance',
+  TRANSACTION_FAILED: 'notification.system.transaction-failed',
+  SUSPICIOUS_LOGIN: 'notification.system.suspicious-login',
 } as const;

 export type NotificationEventName = 
--- a/src/common/modules/notification/dtos/response/notifications.response.dto.ts
+++ b/src/common/modules/notification/dtos/response/notifications.response.dto.ts
@ -23,6 +23,17 @@ export class NotificationsResponseDto {
    this.title = notification.title;
    this.body = notification.message;
    this.status = notification.status!;
-    this.createdAt = notification.createdAt;
+    
+    // Use event timestamp from data if available, otherwise use notification creation time
+    // This ensures notifications show when the event occurred, not when notification was saved
+    // Note: Timestamps are stored in UTC. The client should convert to the user's local timezone.
+    if (notification.data?.timestamp) {
+      // Parse the ISO string timestamp (which is in UTC)
+      // The client should convert this to the user's local timezone based on their device settings
+      this.createdAt = new Date(notification.data.timestamp);
+    } else {
+      // Use notification creation time (also in UTC)
+      this.createdAt = notification.createdAt;
+    }
  }
 }
--- a/src/common/modules/notification/enums/notification-scope.enum.ts
+++ b/src/common/modules/notification/enums/notification-scope.enum.ts
@ -6,11 +6,62 @@ export enum NotificationScope {
  OTP = 'OTP',
  USER_INVITED = 'USER_INVITED',

-  // Transaction notifications - Top-up
+  // Transaction notifications - Top-up (external funds)
  CHILD_TOP_UP = 'CHILD_TOP_UP',
  PARENT_TOP_UP_CONFIRMATION = 'PARENT_TOP_UP_CONFIRMATION',

+  // Transaction notifications - Internal Transfer (parent to child)
+  CHILD_INTERNAL_TRANSFER = 'CHILD_INTERNAL_TRANSFER',
+  PARENT_INTERNAL_TRANSFER = 'PARENT_INTERNAL_TRANSFER',
+
  // Transaction notifications - Spending
  CHILD_SPENDING = 'CHILD_SPENDING',
  PARENT_SPENDING_ALERT = 'PARENT_SPENDING_ALERT',
+
+  // Money Request notifications
+  MONEY_REQUEST_CREATED = 'MONEY_REQUEST_CREATED',
+  MONEY_REQUEST_APPROVED = 'MONEY_REQUEST_APPROVED',
+  MONEY_REQUEST_DECLINED = 'MONEY_REQUEST_DECLINED',
+
+  // KYC Update notifications
+  KYC_APPROVED = 'KYC_APPROVED',
+  KYC_REJECTED = 'KYC_REJECTED',
+
+  // Card Status notifications
+  CARD_CREATED = 'CARD_CREATED',
+  CARD_BLOCKED = 'CARD_BLOCKED',
+  CARD_REISSUED = 'CARD_REISSUED',
+
+  // Profile Update notifications
+  PROFILE_UPDATED = 'PROFILE_UPDATED',
+
+  // System Alert notifications
+  MAINTENANCE_ALERT = 'MAINTENANCE_ALERT',
+  TRANSACTION_FAILED = 'TRANSACTION_FAILED',
+  SUSPICIOUS_LOGIN = 'SUSPICIOUS_LOGIN',
+}
+
+/**
+ * Critical notification scopes that require guaranteed delivery
+ * These will use RabbitMQ/Kafka instead of Redis PubSub when configured
+ * 
+ * Add scopes here when you need guaranteed delivery for specific notification types
+ * Examples:
+ * - ACCOUNT_LOCKED
+ * - SUSPICIOUS_ACTIVITY
+ * - LARGE_TRANSACTION_ALERT
+ * - PAYMENT_FAILED
+ */
+export const CRITICAL_NOTIFICATION_SCOPES = new Set<NotificationScope>([
+  // Add critical scopes here as needed
+  // Example: NotificationScope.ACCOUNT_LOCKED,
+]);
+
+/**
+ * Check if a notification scope requires guaranteed delivery
+ * @param scope - Notification scope to check
+ * @returns true if the scope requires guaranteed delivery
+ */
+export function requiresGuaranteedDelivery(scope: NotificationScope): boolean {
+  return CRITICAL_NOTIFICATION_SCOPES.has(scope);
 }
--- a/src/common/modules/notification/interfaces/index.ts
+++ b/src/common/modules/notification/interfaces/index.ts
@ -1,2 +1,3 @@
 export * from './notification-page-meta.interface';
 export * from './notification-events.interface';
+export * from './messaging-system.interface';
--- a/src/common/modules/notification/interfaces/messaging-system.interface.ts
+++ b/src/common/modules/notification/interfaces/messaging-system.interface.ts
@ -0,0 +1,25 @@
+/**
+ * Interface for messaging systems (Redis PubSub, RabbitMQ, Kafka, etc.)
+ * Allows switching between different messaging systems based on notification requirements
+ */
+export interface IMessagingSystem {
+  /**
+   * Publish a notification event
+   * @param channel - Channel/topic name
+   * @param payload - Notification payload
+   */
+  publish(channel: string, payload: any): Promise<void>;
+  
+  /**
+   * Subscribe to a channel
+   * @param channel - Channel/topic name
+   * @param handler - Message handler function
+   */
+  subscribe(channel: string, handler: (message: any) => Promise<void>): Promise<void>;
+  
+  /**
+   * Get system name (for logging)
+   */
+  getName(): string;
+}
+
--- a/src/common/modules/notification/interfaces/notification-events.interface.ts
+++ b/src/common/modules/notification/interfaces/notification-events.interface.ts
@ -1,5 +1,8 @@
 import { Transaction } from '~/card/entities/transaction.entity';
 import { Card } from '~/card/entities/card.entity';
+import { MoneyRequest } from '~/money-request/entities/money-request.entity';
+import { Customer } from '~/customer/entities';
+import { KycStatus } from '~/customer/enums';

 /**
 * Event payload for when a transaction is created
@ -22,3 +25,197 @@ export interface ITransactionCreatedEvent {
  timestamp: Date;
 }

+/**
+ * Event payload for when a money request is created
+ * Used to notify parents when their child requests money
+ */
+export interface IMoneyRequestCreatedEvent {
+  /** The money request that was created */
+  moneyRequest: MoneyRequest;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when a money request is approved
+ * Used to notify children when their money request is approved
+ */
+export interface IMoneyRequestApprovedEvent {
+  /** The money request that was approved */
+  moneyRequest: MoneyRequest;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when a money request is declined
+ * Used to notify children when their money request is declined
+ */
+export interface IMoneyRequestDeclinedEvent {
+  /** The money request that was declined */
+  moneyRequest: MoneyRequest;
+  
+  /** Rejection reason provided by parent */
+  rejectionReason?: string;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when KYC is approved
+ * Used to notify users when their KYC verification is approved
+ */
+export interface IKycApprovedEvent {
+  /** The customer whose KYC was approved */
+  customer: Customer;
+  
+  /** Previous KYC status */
+  previousStatus: KycStatus;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when KYC is rejected
+ * Used to notify users when their KYC verification is rejected
+ */
+export interface IKycRejectedEvent {
+  /** The customer whose KYC was rejected */
+  customer: Customer;
+  
+  /** Previous KYC status */
+  previousStatus: KycStatus;
+  
+  /** Rejection reason (if provided) */
+  rejectionReason?: string;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when a card is created
+ * Used to notify users when their card is successfully created
+ */
+export interface ICardCreatedEvent {
+  /** The card that was created */
+  card: Card;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when a card is blocked
+ * Used to notify users when their card is blocked
+ */
+export interface ICardBlockedEvent {
+  /** The card that was blocked */
+  card: Card;
+  
+  /** Previous card status */
+  previousStatus: string;
+  
+  /** Block reason/description */
+  blockReason?: string;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when a card is reissued
+ * Used to notify users when their card is reissued
+ */
+export interface ICardReissuedEvent {
+  /** The new card that was issued */
+  card: Card;
+  
+  /** The old card that was replaced */
+  oldCardId?: string;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for when a user profile is updated
+ * Used to notify users when their profile information is changed
+ */
+export interface IProfileUpdatedEvent {
+  /** The user whose profile was updated */
+  user: any;
+  
+  /** Fields that were updated */
+  updatedFields: string[];
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for system maintenance alerts
+ * Used to notify users about scheduled or unscheduled maintenance
+ */
+export interface IMaintenanceAlertEvent {
+  /** User ID to notify (null for broadcast to all users) */
+  userId: string | null;
+  
+  /** Maintenance message */
+  message: string;
+  
+  /** Scheduled start time */
+  startTime?: Date;
+  
+  /** Scheduled end time */
+  endTime?: Date;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for failed transaction alerts
+ * Used to notify users when a transaction fails
+ */
+export interface ITransactionFailedEvent {
+  /** The user whose transaction failed */
+  userId: string;
+  
+  /** Transaction details */
+  transactionId?: string;
+  
+  /** Failure reason */
+  reason: string;
+  
+  /** Transaction amount (if applicable) */
+  amount?: number;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
+
+/**
+ * Event payload for suspicious login detection
+ * Used to notify users about suspicious login attempts
+ */
+export interface ISuspiciousLoginEvent {
+  /** The user whose account had suspicious activity */
+  userId: string;
+  
+  /** IP address of the login attempt */
+  ipAddress?: string;
+  
+  /** Location of the login attempt */
+  location?: string;
+  
+  /** Device information */
+  device?: string;
+  
+  /** When the event occurred */
+  timestamp: Date;
+}
--- a/src/common/modules/notification/listeners/card-notification.listener.ts
+++ b/src/common/modules/notification/listeners/card-notification.listener.ts
@ -0,0 +1,162 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { I18nService } from 'nestjs-i18n';
+import { NotificationFactory, NotificationPreferences } from '../services/notification-factory.service';
+import { UserService } from '~/user/services/user.service';
+import { NOTIFICATION_EVENTS } from '../constants/event-names.constant';
+import { ICardBlockedEvent, ICardCreatedEvent } from '../interfaces/notification-events.interface';
+import { NotificationScope } from '../enums/notification-scope.enum';
+import { User } from '~/user/entities';
+import { UserLocale } from '~/core/enums/user-locale.enum';
+
+@Injectable()
+export class CardNotificationListener {
+  private readonly logger = new Logger(CardNotificationListener.name);
+
+  constructor(
+    private readonly notificationFactory: NotificationFactory,
+    private readonly userService: UserService,
+    private readonly i18n: I18nService,
+  ) {}
+
+  @OnEvent(NOTIFICATION_EVENTS.CARD_CREATED)
+  async handleCardCreated(event: ICardCreatedEvent): Promise<void> {
+    try {
+      const { card } = event;
+      const user = card?.customer?.user;
+
+      if (!user) {
+        this.logger.warn(`No user found for card ${card.id}, skipping card created notification`);
+        return;
+      }
+
+      const locale = this.getUserLocale(user);
+      const lastFourDigits = card.lastFourDigits;
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.CARD_CREATED_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.CARD_CREATED_MESSAGE', {
+          lang: locale,
+          args: {
+            lastFourDigits: lastFourDigits,
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[CardNotificationListener] i18n error for user ${user.id}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'Card Created';
+        message = `Your card ending in ${lastFourDigits} has been created successfully. You can start using it once it's activated.`;
+      }
+
+      this.logger.debug(
+        `Notifying user (user ${user.id}): Card created - ${lastFourDigits}`
+      );
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message,
+        scope: NotificationScope.CARD_CREATED,
+        preferences: this.getUserPreferences(user),
+        data: {
+          cardId: card.id,
+          lastFourDigits: lastFourDigits,
+          cardReference: card.cardReference,
+          status: card.status,
+          timestamp: event.timestamp.toISOString(),
+          action: 'VIEW_CARD',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${user.id} about card creation`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process card created notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  @OnEvent(NOTIFICATION_EVENTS.CARD_BLOCKED)
+  async handleCardBlocked(event: ICardBlockedEvent): Promise<void> {
+    try {
+      const { card, blockReason } = event;
+      const user = card?.customer?.user;
+
+      if (!user) {
+        this.logger.warn(`No user found for card ${card.id}, skipping card blocked notification`);
+        return;
+      }
+
+      const locale = this.getUserLocale(user);
+      const lastFourDigits = card.lastFourDigits;
+      const reason = blockReason || 'Card has been blocked';
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.CARD_BLOCKED_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.CARD_BLOCKED_MESSAGE', {
+          lang: locale,
+          args: {
+            lastFourDigits: lastFourDigits,
+            reason: reason,
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[CardNotificationListener] i18n error for user ${user.id}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'Card Blocked';
+        message = `Your card ending in ${lastFourDigits} has been blocked. Reason: ${reason}. Please contact support for assistance.`;
+      }
+
+      this.logger.debug(
+        `Notifying user (user ${user.id}): Card blocked - ${lastFourDigits}, reason: ${reason}`
+      );
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message,
+        scope: NotificationScope.CARD_BLOCKED,
+        preferences: this.getUserPreferences(user),
+        data: {
+          cardId: card.id,
+          lastFourDigits: lastFourDigits,
+          cardReference: card.cardReference,
+          status: card.status,
+          blockReason: reason,
+          timestamp: event.timestamp.toISOString(),
+          action: 'CONTACT_SUPPORT',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${user.id} about card being blocked`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process card blocked notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  private getUserPreferences(user: User): NotificationPreferences {
+    return {
+      isPushEnabled: user.isPushEnabled,
+      isEmailEnabled: user.isEmailEnabled,
+      isSmsEnabled: user.isSmsEnabled,
+    };
+  }
+
+  private getUserLocale(user: User): UserLocale {
+    return UserLocale.ENGLISH;
+  }
+}
--- a/src/common/modules/notification/listeners/index.ts
+++ b/src/common/modules/notification/listeners/index.ts
@ -1,2 +1,7 @@
 export * from './notification-created.listener';
 export * from './transaction-notification.listener';
+export * from './money-request-notification.listener';
+export * from './kyc-notification.listener';
+export * from './card-notification.listener';
+export * from './profile-notification.listener';
+export * from './system-alert-notification.listener';
--- a/src/common/modules/notification/listeners/kyc-notification.listener.ts
+++ b/src/common/modules/notification/listeners/kyc-notification.listener.ts
@ -0,0 +1,233 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { I18nService } from 'nestjs-i18n';
+import { NotificationFactory, NotificationPreferences } from '../services/notification-factory.service';
+import { UserService } from '~/user/services/user.service';
+import { NOTIFICATION_EVENTS } from '../constants/event-names.constant';
+import {
+  IKycApprovedEvent,
+  IKycRejectedEvent,
+} from '../interfaces/notification-events.interface';
+import { NotificationScope } from '../enums/notification-scope.enum';
+import { User } from '~/user/entities';
+import { UserLocale } from '~/core/enums/user-locale.enum';
+
+/**
+ * KycNotificationListener
+ * 
+ * Handles notifications for KYC update events.
+ * Notifies users when their KYC verification is approved or rejected.
+ * 
+ * Responsibilities:
+ * - Listen for KYC approval/rejection events
+ * - Determine notification recipient (the user whose KYC was updated)
+ * - Construct appropriate messages with rejection reason if applicable
+ * - Fetch user preferences
+ * - Call NotificationFactory to send
+ */
+@Injectable()
+export class KycNotificationListener {
+  private readonly logger = new Logger(KycNotificationListener.name);
+
+  constructor(
+    private readonly notificationFactory: NotificationFactory,
+    private readonly userService: UserService,
+    private readonly i18n: I18nService,
+  ) {}
+
+  /**
+   * Handle KYC approved event
+   * Notifies user when their KYC verification is approved
+   */
+  @OnEvent(NOTIFICATION_EVENTS.KYC_APPROVED)
+  async handleKycApproved(event: IKycApprovedEvent): Promise<void> {
+    try {
+      const { customer } = event;
+
+      this.logger.log(
+        `Processing KYC approved notification for customer ${customer.id}`
+      );
+
+      await this.notifyUserOfKycApproval(customer);
+
+      this.logger.log(
+        `KYC approved notification processed successfully for customer ${customer.id}`
+      );
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process KYC approved notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Handle KYC rejected event
+   * Notifies user when their KYC verification is rejected
+   */
+  @OnEvent(NOTIFICATION_EVENTS.KYC_REJECTED)
+  async handleKycRejected(event: IKycRejectedEvent): Promise<void> {
+    try {
+      const { customer, rejectionReason } = event;
+
+      this.logger.log(
+        `Processing KYC rejected notification for customer ${customer.id} - Reason: ${rejectionReason || 'Not provided'}`
+      );
+
+      await this.notifyUserOfKycRejection(customer, rejectionReason);
+
+      this.logger.log(
+        `KYC rejected notification processed successfully for customer ${customer.id}`
+      );
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process KYC rejected notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Notify user when their KYC is approved
+   */
+  private async notifyUserOfKycApproval(customer: any): Promise<void> {
+    try {
+      const user = customer?.user;
+      if (!user) {
+        this.logger.warn(`No user found for customer ${customer.id}, skipping notification`);
+        return;
+      }
+
+      const locale = this.getUserLocale(user);
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.KYC_APPROVED_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.KYC_APPROVED_MESSAGE', {
+          lang: locale,
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[KycNotificationListener] i18n error for user ${user.id}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'KYC Verification Approved';
+        message = 'Your KYC verification has been approved. You can now use all features of the app.';
+      }
+
+      this.logger.debug(
+        `Notifying user (user ${user.id}): KYC approved`
+      );
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message,
+        scope: NotificationScope.KYC_APPROVED,
+        preferences: this.getUserPreferences(user),
+        data: {
+          customerId: customer.id,
+          kycStatus: 'APPROVED',
+          timestamp: new Date().toISOString(),
+          type: 'KYC_APPROVED',
+          action: 'VIEW_PROFILE',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${user.id} about KYC approval`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify user of KYC approval: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Notify user when their KYC is rejected
+   */
+  private async notifyUserOfKycRejection(customer: any, rejectionReason?: string): Promise<void> {
+    try {
+      const user = customer?.user;
+      if (!user) {
+        this.logger.warn(`No user found for customer ${customer.id}, skipping notification`);
+        return;
+      }
+
+      const locale = this.getUserLocale(user);
+      const reason = rejectionReason || customer.rejectionReason || 'KYC verification failed';
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.KYC_REJECTED_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.KYC_REJECTED_MESSAGE', {
+          lang: locale,
+          args: {
+            reason: reason,
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[KycNotificationListener] i18n error for user ${user.id}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'KYC Verification Rejected';
+        message = `Your KYC verification has been rejected. Reason: ${reason}. Please review your information and try again.`;
+      }
+
+      this.logger.debug(
+        `Notifying user (user ${user.id}): KYC rejected - ${reason}`
+      );
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message,
+        scope: NotificationScope.KYC_REJECTED,
+        preferences: this.getUserPreferences(user),
+        data: {
+          customerId: customer.id,
+          kycStatus: 'REJECTED',
+          rejectionReason: reason,
+          timestamp: new Date().toISOString(),
+          type: 'KYC_REJECTED',
+          action: 'RETRY_KYC',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${user.id} about KYC rejection`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify user of KYC rejection: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Extract user preferences from User entity
+   * Converts User properties to NotificationPreferences interface
+   */
+  private getUserPreferences(user: User): NotificationPreferences {
+    return {
+      isPushEnabled: user.isPushEnabled,
+      isEmailEnabled: user.isEmailEnabled,
+      isSmsEnabled: user.isSmsEnabled,
+    };
+  }
+
+  /**
+   * Get user locale for i18n translations
+   * Defaults to English if not specified
+   * TODO: Add locale field to User entity in the future
+   */
+  private getUserLocale(user: User): UserLocale {
+    // For now, default to English
+    // In the future, this can read from user.locale or user.preferences.locale
+    return UserLocale.ENGLISH;
+  }
+}
--- a/src/common/modules/notification/listeners/money-request-notification.listener.ts
+++ b/src/common/modules/notification/listeners/money-request-notification.listener.ts
@ -0,0 +1,335 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { I18nService } from 'nestjs-i18n';
+import { NotificationFactory, NotificationPreferences } from '../services/notification-factory.service';
+import { UserService } from '~/user/services/user.service';
+import { NOTIFICATION_EVENTS } from '../constants/event-names.constant';
+import {
+  IMoneyRequestApprovedEvent,
+  IMoneyRequestCreatedEvent,
+  IMoneyRequestDeclinedEvent,
+} from '../interfaces/notification-events.interface';
+import { NotificationScope } from '../enums/notification-scope.enum';
+import { User } from '~/user/entities';
+import { MoneyRequest } from '~/money-request/entities/money-request.entity';
+import { UserLocale } from '~/core/enums/user-locale.enum';
+import { formatCurrencyAmount, getCurrency } from '~/common/utils/currency.util';
+
+/**
+ * MoneyRequestNotificationListener
+ * 
+ * Handles notifications for money request events.
+ * Notifies parents when children request money, and children when requests are approved/declined.
+ * 
+ * Responsibilities:
+ * - Listen for money request events (created, approved, declined)
+ * - Determine notification recipients (parent or child)
+ * - Construct appropriate messages
+ * - Fetch user preferences
+ * - Call NotificationFactory to send
+ */
+@Injectable()
+export class MoneyRequestNotificationListener {
+  private readonly logger = new Logger(MoneyRequestNotificationListener.name);
+
+  constructor(
+    private readonly notificationFactory: NotificationFactory,
+    private readonly userService: UserService,
+    private readonly i18n: I18nService,
+  ) {}
+
+  /**
+   * Handle money request created event
+   * Notifies parent when child requests money
+   */
+  @OnEvent(NOTIFICATION_EVENTS.MONEY_REQUEST_CREATED)
+  async handleMoneyRequestCreated(event: IMoneyRequestCreatedEvent): Promise<void> {
+    try {
+      const { moneyRequest } = event;
+
+      this.logger.log(
+        `Processing money request notification for request ${moneyRequest.id} - ` +
+        `Amount: $${moneyRequest.amount}, Reason: ${moneyRequest.reason}`
+      );
+
+      await this.notifyParentOfMoneyRequest(moneyRequest);
+
+      this.logger.log(
+        `Money request notification processed successfully for request ${moneyRequest.id}`
+      );
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process money request notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Handle money request approved event
+   * Notifies child when their money request is approved
+   */
+  @OnEvent(NOTIFICATION_EVENTS.MONEY_REQUEST_APPROVED)
+  async handleMoneyRequestApproved(event: IMoneyRequestApprovedEvent): Promise<void> {
+    try {
+      const { moneyRequest } = event;
+
+      this.logger.log(
+        `Processing money request approved notification for request ${moneyRequest.id}`
+      );
+
+      await this.notifyChildOfApproval(moneyRequest);
+
+      this.logger.log(
+        `Money request approved notification processed successfully for request ${moneyRequest.id}`
+      );
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process money request approved notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Handle money request declined event
+   * Notifies child when their money request is declined
+   */
+  @OnEvent(NOTIFICATION_EVENTS.MONEY_REQUEST_DECLINED)
+  async handleMoneyRequestDeclined(event: IMoneyRequestDeclinedEvent): Promise<void> {
+    try {
+      const { moneyRequest, rejectionReason } = event;
+
+      this.logger.log(
+        `Processing money request declined notification for request ${moneyRequest.id}`
+      );
+
+      await this.notifyChildOfRejection(moneyRequest, rejectionReason);
+
+      this.logger.log(
+        `Money request declined notification processed successfully for request ${moneyRequest.id}`
+      );
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process money request declined notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Notify parent when child requests money
+   */
+  private async notifyParentOfMoneyRequest(moneyRequest: any): Promise<void> {
+    try {
+      const guardian = moneyRequest?.guardian;
+      const parentUser = guardian?.customer?.user;
+      
+      if (!parentUser) {
+        this.logger.warn(`No parent user found for money request ${moneyRequest.id}, skipping notification`);
+        return;
+      }
+
+      const child = moneyRequest?.junior;
+      const childUser = child?.customer?.user;
+      const childName = childUser?.firstName || 'Your child';
+      const amount = typeof moneyRequest.amount === 'string' ? parseFloat(moneyRequest.amount) : moneyRequest.amount;
+      const reason = moneyRequest.reason || 'No reason provided';
+      const accountCurrency = child?.customer?.cards?.[0]?.account?.currency;
+      const currency = getCurrency(accountCurrency, null, 'SAR');
+      const formattedAmount = formatCurrencyAmount(amount, currency);
+
+      const locale = this.getUserLocale(parentUser);
+
+      this.logger.debug(
+        `Notifying parent (user ${parentUser.id}): ${childName} requested ${formattedAmount} ${currency} for ${reason}`
+      );
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.MONEY_REQUEST_CREATED_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.MONEY_REQUEST_CREATED_MESSAGE', {
+          lang: locale,
+          args: {
+            childName: childName,
+            amount: formattedAmount,
+            currency: currency,
+            reason: reason,
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[MoneyRequestNotificationListener] i18n error for parent ${parentUser.id}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'Money Request';
+        message = `${childName} has requested ${formattedAmount} ${currency} for ${reason}.`;
+      }
+
+      await this.notificationFactory.send({
+        userId: parentUser.id,
+        title,
+        message,
+        scope: NotificationScope.MONEY_REQUEST_CREATED,
+        preferences: this.getUserPreferences(parentUser),
+        data: {
+          moneyRequestId: moneyRequest.id,
+          childId: childUser?.id,
+          childName: childName,
+          amount: formattedAmount,
+          currency: currency,
+          reason: reason,
+          timestamp: moneyRequest.createdAt.toISOString(),
+          type: 'MONEY_REQUEST',
+          action: 'VIEW_MONEY_REQUEST',
+        },
+      });
+
+      this.logger.log(`✅ Notified parent ${parentUser.id} about money request ${moneyRequest.id}`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify parent of money request: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Notify child when their money request is approved
+   */
+  private async notifyChildOfApproval(moneyRequest: any): Promise<void> {
+    try {
+      const child = moneyRequest?.junior;
+      const childUser = child?.customer?.user;
+      
+      if (!childUser) {
+        this.logger.warn(`No child user found for money request ${moneyRequest.id}, skipping notification`);
+        return;
+      }
+
+      const amount = typeof moneyRequest.amount === 'string' ? parseFloat(moneyRequest.amount) : moneyRequest.amount;
+      const accountCurrency = child?.customer?.cards?.[0]?.account?.currency;
+      const currency = getCurrency(accountCurrency, null, 'SAR');
+      const formattedAmount = formatCurrencyAmount(amount, currency);
+
+      this.logger.debug(
+        `Notifying child (user ${childUser.id}): Money request of ${formattedAmount} ${currency} was approved`
+      );
+
+      await this.notificationFactory.send({
+        userId: childUser.id,
+        title: 'Money Request Approved',
+        message: `Your request for ${formattedAmount} ${currency} has been approved. The money has been added to your account.`,
+        scope: NotificationScope.MONEY_REQUEST_APPROVED,
+        preferences: this.getUserPreferences(childUser),
+        data: {
+          moneyRequestId: moneyRequest.id,
+          amount: formattedAmount,
+          currency: currency,
+          timestamp: moneyRequest.updatedAt.toISOString(),
+          type: 'MONEY_REQUEST_APPROVED',
+          action: 'VIEW_MONEY_REQUEST',
+        },
+      });
+
+      this.logger.log(`✅ Notified child ${childUser.id} about approved money request ${moneyRequest.id}`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify child of approval: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Notify child when their money request is declined
+   */
+  private async notifyChildOfRejection(moneyRequest: any, rejectionReason?: string): Promise<void> {
+    try {
+      const child = moneyRequest?.junior;
+      const childUser = child?.customer?.user;
+      
+      if (!childUser) {
+        this.logger.warn(`No child user found for money request ${moneyRequest.id}, skipping notification`);
+        return;
+      }
+
+      const amount = typeof moneyRequest.amount === 'string' ? parseFloat(moneyRequest.amount) : moneyRequest.amount;
+      const accountCurrency = child?.customer?.cards?.[0]?.account?.currency;
+      const currency = getCurrency(accountCurrency, null, 'SAR');
+      const formattedAmount = formatCurrencyAmount(amount, currency);
+      const reason = rejectionReason || 'No reason provided';
+      const locale = this.getUserLocale(childUser);
+
+      this.logger.debug(
+        `Notifying child (user ${childUser.id}): Money request of ${formattedAmount} ${currency} was declined`
+      );
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.MONEY_REQUEST_DECLINED_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.MONEY_REQUEST_DECLINED_MESSAGE', {
+          lang: locale,
+          args: {
+            amount: formattedAmount,
+            currency: currency,
+            reason: reason,
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[MoneyRequestNotificationListener] i18n error for child ${childUser.id}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'Money Request Declined';
+        message = `Your request for ${formattedAmount} ${currency} has been declined. Reason: ${reason}`;
+      }
+
+      await this.notificationFactory.send({
+        userId: childUser.id,
+        title,
+        message,
+        scope: NotificationScope.MONEY_REQUEST_DECLINED,
+        preferences: this.getUserPreferences(childUser),
+        data: {
+          moneyRequestId: moneyRequest.id,
+          amount: formattedAmount,
+          currency: currency,
+          rejectionReason: reason,
+          timestamp: moneyRequest.updatedAt.toISOString(),
+          type: 'MONEY_REQUEST_DECLINED',
+          action: 'VIEW_MONEY_REQUEST',
+        },
+      });
+
+      this.logger.log(`✅ Notified child ${childUser.id} about declined money request ${moneyRequest.id}`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify child of rejection: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  /**
+   * Extract user preferences from User entity
+   * Converts User properties to NotificationPreferences interface
+   */
+  private getUserPreferences(user: User): NotificationPreferences {
+    return {
+      isPushEnabled: user.isPushEnabled,
+      isEmailEnabled: user.isEmailEnabled,
+      isSmsEnabled: user.isSmsEnabled,
+    };
+  }
+
+  private getUserLocale(user: User): UserLocale {
+    // For now, default to English
+    // In the future, this can read from user.locale or user.preferences.locale
+    return UserLocale.ENGLISH;
+  }
+}
--- a/src/common/modules/notification/listeners/notification-created.listener.ts
+++ b/src/common/modules/notification/listeners/notification-created.listener.ts
@ -6,6 +6,7 @@ import { EventType, NotificationChannel, NotificationScope } from '~/common/modu
 import { FirebaseService, TwilioService } from '~/common/modules/notification/services';
 import { IEventInterface } from '~/common/redis/interface';
 import { DeviceService } from '~/user/services';
+import { UserService } from '~/user/services/user.service';

@Injectable()
 export class NotificationCreatedListener {
@ -16,6 +17,7 @@ export class NotificationCreatedListener {
    private readonly deviceService: DeviceService,
    private readonly mailerService: MailerService,
    private readonly firebaseService: FirebaseService,
+    private readonly userService: UserService,
  ) {}

  /**
@ -60,26 +62,48 @@ export class NotificationCreatedListener {
    body: string,
    data?: Record<string, any>,
  ) {
-    this.logger.log(`Sending push notification to user ${userId}`);
-    const tokens = await this.deviceService.getTokens(userId);
+    try {
+      // Check if user has push notifications enabled
+      const user = await this.userService.findUser({ id: userId });
+      if (!user) {
+        this.logger.warn(`User ${userId} not found, skipping push notification`);
+        return;
+      }

-    if (!tokens.length) {
-      this.logger.log(`No device tokens found for user ${userId}, but notification was created in the DB.`);
-      return;
+      if (!user.isPushEnabled) {
+        this.logger.log(
+          `Push notifications disabled for user ${userId}, notification saved to DB but push not sent`
+        );
+        return;
+      }
+
+      this.logger.log(`Sending push notification to user ${userId}`);
+      const tokens = await this.deviceService.getTokens(userId);
+
+      if (!tokens.length) {
+        this.logger.log(`No device tokens found for user ${userId}, but notification was created in the DB.`);
+        return;
+      }
+
+      // Convert data to string values (Firebase requires string values in data payload)
+      const stringData: Record<string, string> | undefined = data
+        ? Object.entries(data).reduce(
+            (acc, [key, value]) => {
+              acc[key] = String(value);
+              return acc;
+            },
+            {} as Record<string, string>,
+          )
+        : undefined;
+
+      return this.firebaseService.sendNotification(tokens, title, body, stringData);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to send push notification to user ${userId}: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+      // Don't throw - notification is already saved to DB
    }
-
-    // Convert data to string values (Firebase requires string values in data payload)
-    const stringData: Record<string, string> | undefined = data
-      ? Object.entries(data).reduce(
-          (acc, [key, value]) => {
-            acc[key] = String(value);
-            return acc;
-          },
-          {} as Record<string, string>,
-        )
-      : undefined;
-
-    return this.firebaseService.sendNotification(tokens, title, body, stringData);
  }

  private async sendSMS(to: string, body: string) {
--- a/src/common/modules/notification/listeners/profile-notification.listener.ts
+++ b/src/common/modules/notification/listeners/profile-notification.listener.ts
@ -0,0 +1,158 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { I18nService } from 'nestjs-i18n';
+import { Roles } from '~/auth/enums';
+import { NotificationFactory, NotificationPreferences } from '../services/notification-factory.service';
+import { UserService } from '~/user/services/user.service';
+import { NOTIFICATION_EVENTS } from '../constants/event-names.constant';
+import { IProfileUpdatedEvent } from '../interfaces/notification-events.interface';
+import { NotificationScope } from '../enums/notification-scope.enum';
+import { User } from '~/user/entities';
+import { UserLocale } from '~/core/enums/user-locale.enum';
+
+@Injectable()
+export class ProfileNotificationListener {
+  private readonly logger = new Logger(ProfileNotificationListener.name);
+
+  constructor(
+    private readonly notificationFactory: NotificationFactory,
+    private readonly userService: UserService,
+    private readonly i18n: I18nService,
+  ) {}
+
+  @OnEvent(NOTIFICATION_EVENTS.PROFILE_UPDATED)
+  async handleProfileUpdated(event: IProfileUpdatedEvent): Promise<void> {
+    try {
+      const { user, updatedFields } = event;
+
+      // Do not notify when a child updates their profile (no notification to child or parent)
+      if (user?.roles?.includes(Roles.JUNIOR)) {
+        this.logger.log(
+          `Skipping profile updated notification for child user ${user.id} - no notification sent`
+        );
+        return;
+      }
+
+      this.logger.log(
+        `Processing profile updated notification for user ${user.id} - Updated fields: ${updatedFields.join(', ')}`
+      );
+
+      await this.notifyUserOfProfileUpdate(user, updatedFields);
+
+      this.logger.log(
+        `Profile updated notification processed successfully for user ${user.id}`
+      );
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process profile updated notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  private async notifyUserOfProfileUpdate(user: any, updatedFields: string[]): Promise<void> {
+    try {
+      if (!user) {
+        this.logger.warn(`No user found, skipping profile update notification`);
+        return;
+      }
+
+      const locale = this.getUserLocale(user);
+      const isEmailUpdate = updatedFields.includes('email');
+      const isPasswordUpdate = updatedFields.includes('password');
+      const isProfilePictureUpdate = updatedFields.includes('profilePictureId');
+      const isNameUpdate = updatedFields.includes('firstName') || updatedFields.includes('lastName');
+
+      let title: string;
+      let message: string;
+
+      try {
+        if (isEmailUpdate) {
+          title = this.i18n.t('app.NOTIFICATION.PROFILE_EMAIL_UPDATED_TITLE', { lang: locale });
+          message = this.i18n.t('app.NOTIFICATION.PROFILE_EMAIL_UPDATED_MESSAGE', {
+            lang: locale,
+            args: {
+              email: user.email || 'your email',
+            },
+          });
+        } else if (isPasswordUpdate) {
+          title = this.i18n.t('app.NOTIFICATION.PROFILE_PASSWORD_UPDATED_TITLE', { lang: locale });
+          message = this.i18n.t('app.NOTIFICATION.PROFILE_PASSWORD_UPDATED_MESSAGE', {
+            lang: locale,
+          });
+        } else if (isProfilePictureUpdate) {
+          title = this.i18n.t('app.NOTIFICATION.PROFILE_PICTURE_UPDATED_TITLE', { lang: locale });
+          message = this.i18n.t('app.NOTIFICATION.PROFILE_PICTURE_UPDATED_MESSAGE', {
+            lang: locale,
+          });
+        } else if (isNameUpdate) {
+          title = this.i18n.t('app.NOTIFICATION.PROFILE_NAME_UPDATED_TITLE', { lang: locale });
+          message = this.i18n.t('app.NOTIFICATION.PROFILE_NAME_UPDATED_MESSAGE', {
+            lang: locale,
+          });
+        } else {
+          title = this.i18n.t('app.NOTIFICATION.PROFILE_UPDATED_TITLE', { lang: locale });
+          message = this.i18n.t('app.NOTIFICATION.PROFILE_UPDATED_MESSAGE', {
+            lang: locale,
+            args: {
+              fields: updatedFields.join(', '),
+            },
+          });
+        }
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[ProfileNotificationListener] i18n error for user ${user.id}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        
+        if (isEmailUpdate) {
+          title = 'Email Updated';
+          message = `Your email has been updated to ${user.email || 'a new email'}. Please verify your new email address.`;
+        } else if (isPasswordUpdate) {
+          title = 'Password Updated';
+          message = 'Your password has been successfully updated. If you did not make this change, please contact support immediately.';
+        } else {
+          title = 'Profile Updated';
+          message = `Your profile has been updated. Changes: ${updatedFields.join(', ')}`;
+        }
+      }
+
+      this.logger.debug(
+        `Notifying user (user ${user.id}): Profile updated - ${updatedFields.join(', ')}`
+      );
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message,
+        scope: NotificationScope.PROFILE_UPDATED,
+        preferences: this.getUserPreferences(user),
+        data: {
+          updatedFields: updatedFields,
+          timestamp: new Date().toISOString(),
+          type: 'PROFILE_UPDATE',
+          action: 'VIEW_PROFILE',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${user.id} about profile update`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify user of profile update: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  private getUserPreferences(user: User): NotificationPreferences {
+    return {
+      isPushEnabled: user.isPushEnabled,
+      isEmailEnabled: user.isEmailEnabled,
+      isSmsEnabled: user.isSmsEnabled,
+    };
+  }
+
+  private getUserLocale(user: User): UserLocale {
+    return UserLocale.ENGLISH;
+  }
+}
--- a/src/common/modules/notification/listeners/system-alert-notification.listener.ts
+++ b/src/common/modules/notification/listeners/system-alert-notification.listener.ts
@ -0,0 +1,282 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { I18nService } from 'nestjs-i18n';
+import { NotificationFactory, NotificationPreferences } from '../services/notification-factory.service';
+import { UserService } from '~/user/services/user.service';
+import { NOTIFICATION_EVENTS } from '../constants/event-names.constant';
+import {
+  IMaintenanceAlertEvent,
+  ISuspiciousLoginEvent,
+  ITransactionFailedEvent,
+} from '../interfaces/notification-events.interface';
+import { NotificationScope } from '../enums/notification-scope.enum';
+import { User } from '~/user/entities';
+import { UserLocale } from '~/core/enums/user-locale.enum';
+
+@Injectable()
+export class SystemAlertNotificationListener {
+  private readonly logger = new Logger(SystemAlertNotificationListener.name);
+
+  constructor(
+    private readonly notificationFactory: NotificationFactory,
+    private readonly userService: UserService,
+    private readonly i18n: I18nService,
+  ) {}
+
+  @OnEvent(NOTIFICATION_EVENTS.MAINTENANCE_ALERT)
+  async handleMaintenanceAlert(event: IMaintenanceAlertEvent): Promise<void> {
+    try {
+      const { userId, message, startTime, endTime } = event;
+
+      this.logger.log(
+        `Processing maintenance alert notification - User: ${userId || 'ALL'}, Message: ${message}`
+      );
+
+      if (userId) {
+        await this.notifyUserOfMaintenance(userId, message, startTime, endTime);
+      } else {
+        this.logger.warn('Broadcast maintenance alerts to all users not yet implemented');
+      }
+
+      this.logger.log(`Maintenance alert notification processed successfully`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process maintenance alert notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  @OnEvent(NOTIFICATION_EVENTS.TRANSACTION_FAILED)
+  async handleTransactionFailed(event: ITransactionFailedEvent): Promise<void> {
+    try {
+      const { userId, transactionId, reason, amount } = event;
+
+      this.logger.log(
+        `Processing transaction failed notification for user ${userId} - Transaction: ${transactionId}, Reason: ${reason}`
+      );
+
+      await this.notifyUserOfTransactionFailure(userId, transactionId, reason, amount);
+
+      this.logger.log(`Transaction failed notification processed successfully for user ${userId}`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process transaction failed notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  @OnEvent(NOTIFICATION_EVENTS.SUSPICIOUS_LOGIN)
+  async handleSuspiciousLogin(event: ISuspiciousLoginEvent): Promise<void> {
+    try {
+      const { userId, ipAddress, location, device } = event;
+
+      this.logger.log(
+        `Processing suspicious login notification for user ${userId} - IP: ${ipAddress}, Location: ${location}`
+      );
+
+      await this.notifyUserOfSuspiciousLogin(userId, ipAddress, location, device);
+
+      this.logger.log(`Suspicious login notification processed successfully for user ${userId}`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to process suspicious login notification: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  private async notifyUserOfMaintenance(
+    userId: string,
+    message: string,
+    startTime?: Date,
+    endTime?: Date,
+  ): Promise<void> {
+    try {
+      const user = await this.userService.findUserOrThrow({ id: userId });
+      const locale = this.getUserLocale(user);
+
+      let title: string;
+      let notificationMessage: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.MAINTENANCE_ALERT_TITLE', { lang: locale });
+        notificationMessage = this.i18n.t('app.NOTIFICATION.MAINTENANCE_ALERT_MESSAGE', {
+          lang: locale,
+          args: {
+            message: message,
+            startTime: startTime ? startTime.toLocaleString() : '',
+            endTime: endTime ? endTime.toLocaleString() : '',
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[SystemAlertNotificationListener] i18n error for user ${userId}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'Scheduled Maintenance';
+        notificationMessage = message || 'The system will be under maintenance. Please check back later.';
+        if (startTime && endTime) {
+          notificationMessage += ` Scheduled from ${startTime.toLocaleString()} to ${endTime.toLocaleString()}.`;
+        }
+      }
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message: notificationMessage,
+        scope: NotificationScope.MAINTENANCE_ALERT,
+        preferences: this.getUserPreferences(user),
+        data: {
+          message: message,
+          startTime: startTime?.toISOString(),
+          endTime: endTime?.toISOString(),
+          timestamp: new Date().toISOString(),
+          type: 'MAINTENANCE',
+          action: 'VIEW_STATUS',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${userId} about maintenance`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify user of maintenance: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  private async notifyUserOfTransactionFailure(
+    userId: string,
+    transactionId: string | undefined,
+    reason: string,
+    amount?: number,
+  ): Promise<void> {
+    try {
+      const user = await this.userService.findUserOrThrow({ id: userId });
+      const locale = this.getUserLocale(user);
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.TRANSACTION_FAILED_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.TRANSACTION_FAILED_MESSAGE', {
+          lang: locale,
+          args: {
+            reason: reason,
+            amount: amount ? amount.toString() : '',
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[SystemAlertNotificationListener] i18n error for user ${userId}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'Transaction Failed';
+        message = `Your transaction could not be completed. Reason: ${reason}.`;
+        if (amount) {
+          message += ` Amount: ${amount}`;
+        }
+        message += ' Please try again or contact support if the issue persists.';
+      }
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message,
+        scope: NotificationScope.TRANSACTION_FAILED,
+        preferences: this.getUserPreferences(user),
+        data: {
+          transactionId: transactionId,
+          reason: reason,
+          amount: amount,
+          timestamp: new Date().toISOString(),
+          type: 'TRANSACTION_FAILED',
+          action: 'RETRY_TRANSACTION',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${userId} about failed transaction`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify user of transaction failure: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  private async notifyUserOfSuspiciousLogin(
+    userId: string,
+    ipAddress?: string,
+    location?: string,
+    device?: string,
+  ): Promise<void> {
+    try {
+      const user = await this.userService.findUserOrThrow({ id: userId });
+      const locale = this.getUserLocale(user);
+
+      let title: string;
+      let message: string;
+
+      try {
+        title = this.i18n.t('app.NOTIFICATION.SUSPICIOUS_LOGIN_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.SUSPICIOUS_LOGIN_MESSAGE', {
+          lang: locale,
+          args: {
+            location: location || 'unknown location',
+            device: device || 'unknown device',
+            ipAddress: ipAddress || 'unknown IP',
+          },
+        });
+      } catch (i18nError: any) {
+        this.logger.error(
+          `[SystemAlertNotificationListener] i18n error for user ${userId}: ${i18nError?.message || 'Unknown i18n error'}. Falling back to English.`,
+          i18nError?.stack
+        );
+        title = 'Suspicious Login Detected';
+        message = `We detected a login attempt from ${location || 'an unknown location'} (${ipAddress || 'unknown IP'})`;
+        if (device) {
+          message += ` using ${device}`;
+        }
+        message += '. If this was not you, please change your password immediately and contact support.';
+      }
+
+      await this.notificationFactory.send({
+        userId: user.id,
+        title,
+        message,
+        scope: NotificationScope.SUSPICIOUS_LOGIN,
+        preferences: this.getUserPreferences(user),
+        data: {
+          ipAddress: ipAddress,
+          location: location,
+          device: device,
+          timestamp: new Date().toISOString(),
+          type: 'SUSPICIOUS_LOGIN',
+          action: 'CHANGE_PASSWORD',
+        },
+      });
+
+      this.logger.log(`✅ Notified user ${userId} about suspicious login`);
+    } catch (error: any) {
+      this.logger.error(
+        `Failed to notify user of suspicious login: ${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    }
+  }
+
+  private getUserPreferences(user: User): NotificationPreferences {
+    return {
+      isPushEnabled: user.isPushEnabled,
+      isEmailEnabled: user.isEmailEnabled,
+      isSmsEnabled: user.isSmsEnabled,
+    };
+  }
+
+  private getUserLocale(user: User): UserLocale {
+    return UserLocale.ENGLISH;
+  }
+}
--- a/src/common/modules/notification/listeners/transaction-notification.listener.ts
+++ b/src/common/modules/notification/listeners/transaction-notification.listener.ts
@ -1,13 +1,18 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { OnEvent } from '@nestjs/event-emitter';
+import { I18nService } from 'nestjs-i18n';
 import { NotificationFactory, NotificationPreferences } from '../services/notification-factory.service';
 import { UserService } from '~/user/services/user.service';
+import { AccountService } from '~/card/services/account.service';
+import { CardService } from '~/card/services/card.service';
 import { NOTIFICATION_EVENTS } from '../constants/event-names.constant';
 import { ITransactionCreatedEvent } from '../interfaces/notification-events.interface';
 import { NotificationScope } from '../enums/notification-scope.enum';
 import { Transaction } from '~/card/entities/transaction.entity';
 import { Card } from '~/card/entities/card.entity';
 import { User } from '~/user/entities';
+import { UserLocale } from '~/core/enums/user-locale.enum';
+import { formatCurrencyAmount, getCurrency, numericToCurrencyCode } from '~/common/utils/currency.util';

 /**
 * TransactionNotificationListener
@ -29,6 +34,11 @@ export class TransactionNotificationListener {
  constructor(
    private readonly notificationFactory: NotificationFactory,
    private readonly userService: UserService,
+    private readonly i18n: I18nService,
+    @Inject(forwardRef(() => AccountService))
+    private readonly accountService: AccountService,
+    @Inject(forwardRef(() => CardService))
+    private readonly cardService: CardService,
  ) {}

  /**
@ -38,6 +48,7 @@ export class TransactionNotificationListener {
  @OnEvent(NOTIFICATION_EVENTS.TRANSACTION_CREATED)
  async handleTransactionCreated(event: ITransactionCreatedEvent): Promise<void> {
    try {
+      console.log(`[TransactionNotificationListener] Event received: ${NOTIFICATION_EVENTS.TRANSACTION_CREATED}`);
      const { transaction, card, isTopUp, isChildSpending } = event;

      this.logger.log(
@ -45,16 +56,14 @@ export class TransactionNotificationListener {
        `isTopUp: ${isTopUp}, isChildSpending: ${isChildSpending}`
      );
      
-      // Notify the transaction owner (child or parent)
+      console.log(`[TransactionNotificationListener] Transaction: ${transaction.id}, Card: ${card?.id}, isTopUp: ${isTopUp}, isChildSpending: ${isChildSpending}`);
+
      await this.notifyTransactionOwner(transaction, card, isTopUp, isChildSpending);

-      // If child transaction, also notify parent
      if (isChildSpending) {
        if (isTopUp) {
-          // Parent topped up child's card - send confirmation to parent
          await this.notifyParentOfTopUp(transaction, card);
        } else {
-          // Child spent money - send spending alert to parent
          await this.notifyParentOfChildSpending(transaction, card);
        }
      }
@ -63,11 +72,11 @@ export class TransactionNotificationListener {
        `Transaction notification processed successfully for transaction ${transaction.id}`
      );
    } catch (error: any) {
+      console.error(`[TransactionNotificationListener] ERROR:`, error);
      this.logger.error(
        `Failed to process transaction notification: ${error?.message || 'Unknown error'}`,
        error?.stack
      );
-      // Don't throw - notification failures should not break the main flow
    }
  }

@ -82,52 +91,202 @@ export class TransactionNotificationListener {
    isChildSpending: boolean
  ): Promise<void> {
    try {
-      // Extract user from card
      const user = card?.customer?.user;
      if (!user) {
        this.logger.warn(`No user found for transaction ${transaction.id}, skipping notification`);
        return;
      }

-      // Determine the scope based on transaction type
-      const scope = isTopUp
-        ? NotificationScope.CHILD_TOP_UP
-        : NotificationScope.CHILD_SPENDING;
+      // Determine scope: internal transfer (parent to child) vs external top-up
+      let scope: NotificationScope;
+      if (isTopUp) {
+        scope = isChildSpending 
+          ? NotificationScope.CHILD_INTERNAL_TRANSFER  // Parent transferring to child
+          : NotificationScope.CHILD_TOP_UP;             // External top-up
+      } else {
+        scope = NotificationScope.CHILD_SPENDING;
+      }

-      // Construct title
-      const title = isTopUp ? '💰 Card Topped Up' : '💳 Purchase Successful';
-
-      // Extract data
+      const locale = this.getUserLocale(user);
      const amount = transaction.transactionAmount;
      const merchant = transaction.merchantName || 'merchant';
-      const balance = card.account?.balance || 0;
      
-      // Construct message
-      const message = isTopUp
-        ? `Your card has been topped up with $${amount.toFixed(2)}`
-        : `You spent $${amount.toFixed(2)} at ${merchant}. Balance: $${balance.toFixed(2)}`;
+      // For child notifications, show the appropriate balance based on account structure
+      let balance = 0;
+      let accountCurrency: string | undefined;
      
-      this.logger.debug(
-        `Notifying transaction owner (user ${user.id}) - Amount: $${amount}, Merchant: ${merchant}`
+      if (isTopUp && isChildSpending) {
+        // Internal transfer: For shared accounts, show card limit (child's spending power)
+        // For separate accounts, show child's account balance
+        try {
+          // Reload card to get updated data
+          const cardWithUpdatedBalance = await this.cardService.getCardById(card.id);
+          
+          // Check if child has parent (shared account scenario)
+          if (cardWithUpdatedBalance.parentId) {
+            // Likely shared account - use card limit as the child's "balance"
+            balance = cardWithUpdatedBalance.limit || card.limit || 0;
+            accountCurrency = cardWithUpdatedBalance.account?.currency || card.account?.currency;
+            this.logger.debug(
+              `[Child Internal Transfer] Shared account - using card limit: ${balance} ${accountCurrency}`
+            );
+          } else {
+            // Separate account - use child's account balance
+            if (cardWithUpdatedBalance?.account?.accountReference) {
+              const account = await this.accountService.getAccountByReferenceNumber(
+                cardWithUpdatedBalance.account.accountReference
+              );
+              balance = account.balance;
+              accountCurrency = account.currency;
+              this.logger.debug(
+                `[Child Internal Transfer] Separate account - using account balance: ${balance} ${accountCurrency}`
+              );
+            } else {
+              balance = cardWithUpdatedBalance.account?.balance || card.account?.balance || 0;
+              accountCurrency = cardWithUpdatedBalance.account?.currency || card.account?.currency;
+            }
+          }
+        } catch (error: any) {
+          this.logger.warn(
+            `[Child Internal Transfer] Could not fetch balance: ${error?.message}. Using card limit.`
+          );
+          balance = card.limit || 0;
+          accountCurrency = card.account?.currency;
+        }
+      } else if (isTopUp) {
+        // External top-up: show child's account balance
+        try {
+          const cardWithUpdatedBalance = await this.cardService.getCardById(card.id);
+          if (cardWithUpdatedBalance?.account?.accountReference) {
+            const account = await this.accountService.getAccountByReferenceNumber(
+              cardWithUpdatedBalance.account.accountReference
+            );
+            balance = account.balance;
+            accountCurrency = account.currency;
+            this.logger.debug(
+              `[Child Top-Up Notification] Fetched account by reference - balance: ${balance} ${accountCurrency}`
+            );
+          } else {
+            balance = cardWithUpdatedBalance.account?.balance || card.account?.balance || 0;
+            accountCurrency = cardWithUpdatedBalance.account?.currency || card.account?.currency;
+          }
+        } catch (error: any) {
+          this.logger.warn(
+            `[Child Top-Up Notification] Could not fetch account: ${error?.message}. Using card balance.`
+          );
+          balance = card.account?.balance || 0;
+          accountCurrency = card.account?.currency;
+        }
+      } else {
+        // For spending: show account balance
+        try {
+          // Reload card to get account reference
+          const cardWithUpdatedBalance = await this.cardService.getCardById(card.id);
+          if (cardWithUpdatedBalance?.account?.accountReference) {
+            // Fetch by reference number to get fresh balance from database
+            const account = await this.accountService.getAccountByReferenceNumber(
+              cardWithUpdatedBalance.account.accountReference
+            );
+            balance = account.balance;
+            accountCurrency = account.currency;
+            this.logger.debug(
+              `[Child Spending Notification] Fetched account by reference - balance: ${balance} ${accountCurrency}`
+            );
+          } else {
+            // Fallback: use card's account balance
+            balance = cardWithUpdatedBalance.account?.balance || card.account?.balance || 0;
+            accountCurrency = cardWithUpdatedBalance.account?.currency || card.account?.currency;
+            this.logger.debug(
+              `[Child Spending Notification] Using card account balance - balance: ${balance} ${accountCurrency}`
+            );
+          }
+        } catch (error: any) {
+          this.logger.warn(
+            `[Child Spending Notification] Could not fetch account by reference: ${error?.message}. Using card account balance.`
+          );
+          // Fallback: use card's account balance
+          balance = card.account?.balance || 0;
+          accountCurrency = card.account?.currency;
+        }
+      }
+      const currency = getCurrency(
+        accountCurrency,
+        transaction.transactionCurrency,
+        'SAR'
+      );
+      
+      this.logger.debug(
+        `[Child Notification] Account currency: ${accountCurrency}, Transaction currency: ${transaction.transactionCurrency}, Final currency: ${currency}, Balance: ${balance}, Amount: ${amount}`
+      );
+      
+      const formattedAmount = formatCurrencyAmount(amount, currency);
+      const formattedBalance = formatCurrencyAmount(balance, currency);
+
+      let title: string;
+      let message: string;
+      
+      try {
+        if (isTopUp) {
+          // Internal transfer or external top-up
+          const titleKey = isChildSpending 
+            ? 'app.NOTIFICATION.CHILD_INTERNAL_TRANSFER_TITLE'
+            : 'app.NOTIFICATION.CHILD_TOP_UP_TITLE';
+          const messageKey = isChildSpending
+            ? 'app.NOTIFICATION.CHILD_INTERNAL_TRANSFER_MESSAGE'
+            : 'app.NOTIFICATION.CHILD_TOP_UP_MESSAGE';
+          
+          title = this.i18n.t(titleKey, { lang: locale });
+          message = this.i18n.t(messageKey, {
+            lang: locale,
+            args: {
+              amount: formattedAmount,
+              currency: currency,
+              balance: formattedBalance,
+            },
+          });
+        } else {
+          // Spending
+          title = this.i18n.t('app.NOTIFICATION.CHILD_SPENDING_TITLE', { lang: locale });
+          message = this.i18n.t('app.NOTIFICATION.CHILD_SPENDING_MESSAGE', {
+            lang: locale,
+            args: {
+              amount: formattedAmount,
+              currency: currency,
+              merchant: merchant,
+            },
+          });
+        }
+      } catch (i18nError: any) {
+        console.error(`[TransactionNotificationListener] i18n error:`, i18nError);
+        this.logger.error(`i18n translation failed: ${i18nError?.message}`, i18nError?.stack);
+        // Fallback to English without i18n
+        title = isTopUp ? 'Funds Credited' : 'Purchase Successful';
+        message = isTopUp
+          ? `${formattedAmount} ${currency} has been added to your card. Total balance: ${formattedBalance} ${currency}`
+          : `You spent ${formattedAmount} ${currency} at ${merchant}`;
+      }
+
+      this.logger.debug(
+        `Notifying transaction owner (user ${user.id}) - Amount: ${amount} ${currency}, Merchant: ${merchant}`
      );

-      // Send notification
      await this.notificationFactory.send({
        userId: user.id,
        title,
        message,
        scope,
        preferences: this.getUserPreferences(user),
-        data: {
-          transactionId: transaction.id,
-          amount: amount.toString(),
-          merchant: merchant,
-          merchantCategory: transaction.merchantCategoryCode || 'OTHER',
-          balance: balance.toString(),
-          timestamp: transaction.transactionDate.toISOString(),
-          type: isTopUp ? 'TOP_UP' : 'SPENDING',
-          action: 'OPEN_TRANSACTION',
-        },
+              data: {
+                transactionId: transaction.id,
+                amount: formattedAmount,
+                currency: currency, // ISO currency code (SAR, USD, etc.)
+                merchant: merchant,
+                merchantCategory: transaction.merchantCategoryCode || 'OTHER',
+                balance: formattedBalance,
+                timestamp: transaction.transactionDate.toISOString(),
+                type: isTopUp ? 'TOP_UP' : 'SPENDING',
+                action: 'OPEN_TRANSACTION',
+              },
      });

      this.logger.log(`✅ Notified user ${user.id} for transaction ${transaction.id}`);
@ -147,7 +306,6 @@ export class TransactionNotificationListener {
    try {
      this.logger.debug(`Checking for parent to notify about child spending`);

-      // Check if child has guardian
      const customer = card?.customer;
      const parentUser = customer?.junior?.guardian?.customer?.user;
      
@ -156,30 +314,146 @@ export class TransactionNotificationListener {
        return;
      }

-      // Get child info
      const childUser = customer.user;
-      const childName = childUser?.firstName || 'Your child';
+      const locale = this.getUserLocale(parentUser);
+      const defaultChildName = this.i18n.t('app.NOTIFICATION.YOUR_CHILD', { lang: locale });
+      const childName = childUser?.firstName || defaultChildName;
      const amount = transaction.transactionAmount;
      const merchant = transaction.merchantName || 'a merchant';
      
-      this.logger.debug(
-        `Notifying parent (user ${parentUser.id}): ${childName} spent $${amount} at ${merchant}`
+      // Get parent's available balance (balance - reserved_balance) - reload to get fresh balance
+      let parentAccountBalance = 0;
+      let parentAccountReservedBalance = 0;
+      let parentAccountCurrency: string | undefined;
+      let availableBalance = 0;
+      
+      try {
+        if (card.parentId) {
+          // Get parent's card to access their account reference
+          const parentCard = await this.cardService.getCardByCustomerId(card.parentId);
+          if (parentCard?.account?.accountReference) {
+            // Fetch by reference number to get fresh balance from database
+            const parentAccount = await this.accountService.getAccountByReferenceNumber(
+              parentCard.account.accountReference
+            );
+            parentAccountBalance = parentAccount.balance;
+            parentAccountReservedBalance = parentAccount.reservedBalance;
+            availableBalance = parentAccountBalance - parentAccountReservedBalance;
+            parentAccountCurrency = parentAccount.currency;
+            this.logger.debug(
+              `[Parent Spending] Fetched parent account by reference - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+            );
+          } else {
+            // Fallback: try by customer ID
+            const parentAccount = await this.accountService.getAccountByCustomerId(card.parentId);
+            parentAccountBalance = parentAccount.balance;
+            parentAccountReservedBalance = parentAccount.reservedBalance;
+            availableBalance = parentAccountBalance - parentAccountReservedBalance;
+            parentAccountCurrency = parentAccount.currency;
+            this.logger.debug(
+              `[Parent Spending] Fetched parent account by customer ID - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+            );
+          }
+        } else {
+          const parentCustomer = customer?.junior?.guardian?.customer;
+          if (parentCustomer?.id) {
+            try {
+              const parentCard = await this.cardService.getCardByCustomerId(parentCustomer.id);
+              if (parentCard?.account?.accountReference) {
+                const parentAccount = await this.accountService.getAccountByReferenceNumber(
+                  parentCard.account.accountReference
+                );
+                parentAccountBalance = parentAccount.balance;
+                parentAccountReservedBalance = parentAccount.reservedBalance;
+                availableBalance = parentAccountBalance - parentAccountReservedBalance;
+                parentAccountCurrency = parentAccount.currency;
+                this.logger.debug(
+                  `[Parent Spending] Fetched parent account via customer relation (by reference) - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+                );
+              } else {
+                const parentAccount = await this.accountService.getAccountByCustomerId(parentCustomer.id);
+                parentAccountBalance = parentAccount.balance;
+                parentAccountReservedBalance = parentAccount.reservedBalance;
+                availableBalance = parentAccountBalance - parentAccountReservedBalance;
+                parentAccountCurrency = parentAccount.currency;
+                this.logger.debug(
+                  `[Parent Spending] Fetched parent account via customer relation - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+                );
+              }
+            } catch (error: any) {
+              this.logger.warn(
+                `[Parent Spending] Could not fetch parent account via customer: ${error?.message}. Using child account balance as fallback.`
+              );
+              availableBalance = card.account?.balance || 0;
+              parentAccountCurrency = card.account?.currency;
+            }
+          } else {
+            availableBalance = card.account?.balance || 0;
+            parentAccountCurrency = card.account?.currency;
+          }
+        }
+      } catch (error: any) {
+        this.logger.warn(`[Parent Spending] Could not fetch parent account: ${error?.message}, using child account balance as fallback`);
+        availableBalance = card.account?.balance || 0;
+        parentAccountCurrency = card.account?.currency;
+      }
+      
+      const accountCurrency = parentAccountCurrency || card.account?.currency;
+      const currency = getCurrency(
+        accountCurrency,
+        transaction.transactionCurrency,
+        'SAR'
      );
      
-      // Send notification to parent
+      this.logger.debug(
+        `[Parent Spending Notification] Parent account currency: ${parentAccountCurrency}, Account currency: ${accountCurrency}, Transaction currency: ${transaction.transactionCurrency}, Final currency: ${currency}, Parent available balance: ${availableBalance}, Amount: ${amount}`
+      );
+      
+      const formattedAmount = formatCurrencyAmount(amount, currency);
+      // Use available balance for parent spending notification
+      const formattedBalance = formatCurrencyAmount(availableBalance, currency);
+
+      this.logger.debug(
+        `Notifying parent (user ${parentUser.id}): ${childName} spent ${formattedAmount} ${currency} at ${merchant}`
+      );
+
+      let title: string;
+      let message: string;
+      
+      try {
+        title = this.i18n.t('app.NOTIFICATION.PARENT_SPENDING_TITLE', { lang: locale });
+              message = this.i18n.t('app.NOTIFICATION.PARENT_SPENDING_MESSAGE', {
+                lang: locale,
+                args: {
+                  childName: childName,
+                  amount: formattedAmount,
+                  currency: currency,
+                  merchant: merchant,
+                  balance: formattedBalance,
+                },
+              });
+      } catch (i18nError: any) {
+        console.error(`[TransactionNotificationListener] i18n error in parent spending:`, i18nError);
+        this.logger.error(`i18n translation failed: ${i18nError?.message}`, i18nError?.stack);
+        title = 'Spending Alert';
+        message = `${childName} spent ${formattedAmount} ${currency} at ${merchant}. Remaining balance: ${formattedBalance} ${currency}`;
+      }
+
      await this.notificationFactory.send({
        userId: parentUser.id,
-        title: '🚨 Child Spending Alert',
-        message: `${childName} spent $${amount.toFixed(2)} at ${merchant}`,
+        title,
+        message,
        scope: NotificationScope.PARENT_SPENDING_ALERT,
        preferences: this.getUserPreferences(parentUser),
        data: {
          transactionId: transaction.id,
          childId: childUser.id,
          childName: childName,
-          amount: amount.toString(),
+          amount: formattedAmount, // Use formatted amount instead of raw amount
+          currency: currency, // ISO currency code (SAR, USD, etc.)
          merchant: merchant,
          merchantCategory: transaction.merchantCategoryCode || 'OTHER',
+          balance: formattedBalance,
          timestamp: transaction.transactionDate.toISOString(),
          type: 'CHILD_SPENDING',
          action: 'OPEN_TRANSACTION',
@ -189,22 +463,20 @@ export class TransactionNotificationListener {
      this.logger.log(`✅ Notified parent ${parentUser.id} about child spending`);
    } catch (error: any) {
      this.logger.error(
-        `Failed to notify parent of child spending: ${error?.message || 'Unknown error'}`,
+        `Failed to notify parent of child spending: ${        error?.message || 'Unknown error'}`,
        error?.stack
      );
-      // Don't throw - parent notification failure should not break child notification
    }
  }

  /**
-   * Notify parent when they top up their child's card
+   * Notify parent when they transfer money to their child's card (internal transfer)
   * This is a confirmation notification for the parent
   */
  private async notifyParentOfTopUp(transaction: Transaction, card: Card): Promise<void> {
    try {
      this.logger.debug(`Checking for parent to notify about top-up`);

-      // Check if child has guardian
      const customer = card?.customer;
      const parentUser = customer?.junior?.guardian?.customer?.user;
      
@ -213,29 +485,147 @@ export class TransactionNotificationListener {
        return;
      }

-      // Get child info
      const childUser = customer.user;
-      const childName = childUser?.firstName || 'Your child';
+      const locale = this.getUserLocale(parentUser);
+      const defaultChildName = this.i18n.t('app.NOTIFICATION.YOUR_CHILD', { lang: locale });
+      const childName = childUser?.firstName || defaultChildName;
      const amount = transaction.transactionAmount;
-      const balance = card.account?.balance || 0;
      
-      this.logger.debug(
-        `Notifying parent (user ${parentUser.id}): Topped up ${childName}'s card with $${amount}`
+      // Fetch parent account by reference number to get fresh balance (bypasses entity cache)
+      // For parent notification, show available_balance = balance - reserved_balance
+      let parentAccountBalance = 0;
+      let parentAccountReservedBalance = 0;
+      let parentAccountCurrency: string | undefined;
+      let availableBalance = 0;
+      
+      if (card.parentId) {
+        try {
+          // Get parent's card to access their account reference
+          // card.parentId is the parent's CUSTOMER ID
+          const parentCard = await this.cardService.getCardByCustomerId(card.parentId);
+          if (parentCard?.account?.accountReference) {
+            // Fetch by reference number to get fresh balance from database
+            const parentAccount = await this.accountService.getAccountByReferenceNumber(
+              parentCard.account.accountReference
+            );
+            parentAccountBalance = parentAccount.balance;
+            parentAccountReservedBalance = parentAccount.reservedBalance;
+            availableBalance = parentAccountBalance - parentAccountReservedBalance;
+            parentAccountCurrency = parentAccount.currency;
+            this.logger.debug(
+              `[Parent Top-Up] Fetched parent account by reference - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+            );
+          } else {
+            // Fallback: try by customer ID
+            const parentAccount = await this.accountService.getAccountByCustomerId(card.parentId);
+            parentAccountBalance = parentAccount.balance;
+            parentAccountReservedBalance = parentAccount.reservedBalance;
+            availableBalance = parentAccountBalance - parentAccountReservedBalance;
+            parentAccountCurrency = parentAccount.currency;
+            this.logger.debug(
+              `[Parent Top-Up] Fetched parent account by customer ID - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+            );
+          }
+        } catch (error: any) {
+          this.logger.warn(
+            `[Parent Top-Up] Could not fetch parent account for customer ${card.parentId}: ${error?.message}. Using child account balance as fallback.`
+          );
+          availableBalance = card.account?.balance || 0;
+          parentAccountCurrency = card.account?.currency;
+        }
+      } else {
+        // If no parentId, try via customer relation
+        const parentCustomer = customer?.junior?.guardian?.customer;
+        if (parentCustomer?.id) {
+          try {
+            const parentCard = await this.cardService.getCardByCustomerId(parentCustomer.id);
+            if (parentCard?.account?.accountReference) {
+              const parentAccount = await this.accountService.getAccountByReferenceNumber(
+                parentCard.account.accountReference
+              );
+              parentAccountBalance = parentAccount.balance;
+              parentAccountReservedBalance = parentAccount.reservedBalance;
+              availableBalance = parentAccountBalance - parentAccountReservedBalance;
+              parentAccountCurrency = parentAccount.currency;
+              this.logger.debug(
+                `[Parent Top-Up] Fetched parent account via customer relation (by reference) - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+              );
+            } else {
+              const parentAccount = await this.accountService.getAccountByCustomerId(parentCustomer.id);
+              parentAccountBalance = parentAccount.balance;
+              parentAccountReservedBalance = parentAccount.reservedBalance;
+              availableBalance = parentAccountBalance - parentAccountReservedBalance;
+              parentAccountCurrency = parentAccount.currency;
+              this.logger.debug(
+                `[Parent Top-Up] Fetched parent account via customer relation - balance: ${parentAccountBalance}, reserved: ${parentAccountReservedBalance}, available: ${availableBalance} ${parentAccountCurrency}`
+              );
+            }
+          } catch (error: any) {
+            this.logger.warn(
+              `[Parent Top-Up] Could not fetch parent account via customer: ${error?.message}. Using child account balance as fallback.`
+            );
+            availableBalance = card.account?.balance || 0;
+            parentAccountCurrency = card.account?.currency;
+          }
+        } else {
+          availableBalance = card.account?.balance || 0;
+          parentAccountCurrency = card.account?.currency;
+        }
+      }
+      
+      // Use available_balance for parent notification (balance - reserved_balance)
+      const balance = availableBalance;
+      const accountCurrency = parentAccountCurrency;
+      const currency = getCurrency(
+        accountCurrency,
+        transaction.transactionCurrency,
      );
      
-      // Send notification to parent
+      this.logger.debug(
+        `[Parent Top-Up Notification] Parent account currency: ${parentAccountCurrency}, Account currency: ${accountCurrency}, Transaction currency: ${transaction.transactionCurrency}, Final currency: ${currency}, Parent balance: ${balance}, Amount: ${amount}`
+      );
+      
+      const formattedAmount = formatCurrencyAmount(amount, currency);
+      const formattedBalance = formatCurrencyAmount(balance, currency);
+
+      this.logger.debug(
+        `Notifying parent (user ${parentUser.id}): Transferred ${formattedAmount} ${currency} to ${childName}, child balance: ${formattedBalance} ${currency}`
+      );
+
+      let title: string;
+      let message: string;
+      
+      try {
+        title = this.i18n.t('app.NOTIFICATION.PARENT_INTERNAL_TRANSFER_TITLE', { lang: locale });
+        message = this.i18n.t('app.NOTIFICATION.PARENT_INTERNAL_TRANSFER_MESSAGE', {
+          lang: locale,
+          args: {
+            amount: formattedAmount,
+            currency: currency,
+            childName: childName,
+            balance: formattedBalance,
+          },
+        });
+      } catch (i18nError: any) {
+        console.error(`[TransactionNotificationListener] i18n error in parent internal transfer:`, i18nError);
+        this.logger.error(`i18n translation failed: ${i18nError?.message}`, i18nError?.stack);
+        title = 'Internal Transfer Completed';
+        message = `${formattedAmount} ${currency} has been transferred to ${childName}'s card. ${childName}'s balance is ${formattedBalance} ${currency}`;
+      }
+
      await this.notificationFactory.send({
        userId: parentUser.id,
-        title: '✅ Top-Up Confirmation',
-        message: `You topped up ${childName}'s card with $${amount.toFixed(2)}. New balance: $${balance.toFixed(2)}`,
-        scope: NotificationScope.PARENT_TOP_UP_CONFIRMATION,
+        title,
+        message,
+        scope: NotificationScope.PARENT_INTERNAL_TRANSFER,
        preferences: this.getUserPreferences(parentUser),
        data: {
          transactionId: transaction.id,
          childId: childUser.id,
          childName: childName,
-          amount: amount.toString(),
-          balance: balance.toString(),
+          amount: formattedAmount,
+          currency: currency, // ISO currency code (SAR, USD, etc.)
+          balance: formattedBalance,
          timestamp: transaction.transactionDate.toISOString(),
          type: 'TOP_UP',
          action: 'OPEN_TRANSACTION',
@ -245,10 +635,9 @@ export class TransactionNotificationListener {
      this.logger.log(`✅ Notified parent ${parentUser.id} about top-up`);
    } catch (error: any) {
      this.logger.error(
-        `Failed to notify parent of top-up: ${error?.message || 'Unknown error'}`,
+        `Failed to notify parent of top-up: ${        error?.message || 'Unknown error'}`,
        error?.stack
      );
-      // Don't throw - parent notification failure should not break child notification
    }
  }

@ -263,6 +652,17 @@ export class TransactionNotificationListener {
      isSmsEnabled: user.isSmsEnabled,
    };
  }
+
+  /**
+   * Get user locale for i18n translations
+   * Defaults to English if not specified
+   * TODO: Add locale field to User entity in the future
+   */
+  private getUserLocale(user: User): UserLocale {
+    // For now, default to English
+    // In the future, this can read from user.locale or user.preferences.locale
+    return UserLocale.ENGLISH;
+  }
 }


--- a/src/common/modules/notification/notification.module.ts
+++ b/src/common/modules/notification/notification.module.ts
@ -3,19 +3,30 @@ import { forwardRef, Module } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { TwilioModule } from 'nestjs-twilio';
+import { CardModule } from '~/card/card.module';
 import { RedisModule } from '~/common/redis/redis.module';
 import { buildMailerOptions, buildTwilioOptions } from '~/core/module-options';
 import { UserModule } from '~/user/user.module';
 import { NotificationsController } from './controllers';
 import { Notification } from './entities';
-import { NotificationCreatedListener, TransactionNotificationListener } from './listeners';
+import {
+  CardNotificationListener,
+  KycNotificationListener,
+  MoneyRequestNotificationListener,
+  NotificationCreatedListener,
+  ProfileNotificationListener,
+  SystemAlertNotificationListener,
+  TransactionNotificationListener,
+} from './listeners';
 import { NotificationsRepository } from './repositories';
 import { FirebaseService, NotificationFactory, NotificationsService, TwilioService } from './services';
+import { MessagingSystemFactory, RedisPubSubMessagingService } from './services/messaging';

@Module({
  imports: [
    forwardRef(() => RedisModule.register()),
    forwardRef(() => UserModule),
+    forwardRef(() => CardModule),
    TypeOrmModule.forFeature([Notification]),
    TwilioModule.forRootAsync({
      useFactory: buildTwilioOptions,
@ -34,6 +45,13 @@ import { FirebaseService, NotificationFactory, NotificationsService, TwilioServi
    TwilioService,
    NotificationCreatedListener,
    TransactionNotificationListener,
+    MoneyRequestNotificationListener,
+    KycNotificationListener,
+    CardNotificationListener,
+    ProfileNotificationListener,
+    SystemAlertNotificationListener,
+    RedisPubSubMessagingService,
+    MessagingSystemFactory,
  ],
  exports: [NotificationsService, NotificationFactory, NotificationCreatedListener],
  controllers: [NotificationsController],
--- a/src/common/modules/notification/services/messaging/index.ts
+++ b/src/common/modules/notification/services/messaging/index.ts
@ -0,0 +1,3 @@
+export * from './redis-pubsub-messaging.service';
+export * from './messaging-system-factory.service';
+
--- a/src/common/modules/notification/services/messaging/messaging-system-factory.service.ts
+++ b/src/common/modules/notification/services/messaging/messaging-system-factory.service.ts
@ -0,0 +1,58 @@
+import { Injectable, Logger, Optional } from '@nestjs/common';
+import { NotificationScope, requiresGuaranteedDelivery } from '../../enums/notification-scope.enum';
+import { IMessagingSystem } from '../../interfaces/messaging-system.interface';
+import { RedisPubSubMessagingService } from './redis-pubsub-messaging.service';
+
+/**
+ * Messaging System Factory
+ * 
+ * Determines which messaging system to use based on notification requirements.
+ * 
+ * - Regular notifications → Redis PubSub (fast, 2-5ms)
+ * - Critical notifications → RabbitMQ/Kafka (guaranteed delivery, 20-50ms)
+ * 
+ * Usage:
+ * ```typescript
+ * const system = factory.getMessagingSystem(NotificationScope.CHILD_SPENDING);
+ * await system.publish('NOTIFICATION_CREATED', payload);
+ * ```
+ */
+@Injectable()
+export class MessagingSystemFactory {
+  private readonly logger = new Logger(MessagingSystemFactory.name);
+
+  constructor(
+    private readonly redisPubSubService: RedisPubSubMessagingService,
+  ) {}
+
+  /**
+   * Get the appropriate messaging system based on notification scope
+   * 
+   * @param scope - Notification scope
+   * @returns Messaging system to use
+   */
+  getMessagingSystem(scope: NotificationScope): IMessagingSystem {
+    const needsGuaranteedDelivery = requiresGuaranteedDelivery(scope);
+    
+    if (needsGuaranteedDelivery) {
+      this.logger.warn(
+        `[Factory] Critical notification ${scope} requires guaranteed delivery, ` +
+        `but RabbitMQ not configured. Falling back to Redis PubSub.`
+      );
+      return this.redisPubSubService;
+    } else {
+      this.logger.debug(`[Factory] Using Redis PubSub for notification: ${scope}`);
+      return this.redisPubSubService;
+    }
+  }
+
+  /**
+   * Get default messaging system (Redis PubSub)
+   * 
+   * @returns Default messaging system
+   */
+  getDefaultMessagingSystem(): IMessagingSystem {
+    return this.redisPubSubService;
+  }
+}
+
--- a/src/common/modules/notification/services/messaging/redis-pubsub-messaging.service.ts
+++ b/src/common/modules/notification/services/messaging/redis-pubsub-messaging.service.ts
@ -0,0 +1,55 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { RedisClientType } from '@keyv/redis';
+import { IMessagingSystem } from '../../interfaces/messaging-system.interface';
+
+/**
+ * Redis PubSub Messaging System Implementation
+ * 
+ * Fast, real-time messaging for regular notifications.
+ * Uses Redis PubSub for 2-5ms latency.
+ * 
+ * Note: Messages are not persisted (fire-and-forget).
+ * Suitable for notifications that are already saved in PostgreSQL.
+ */
+@Injectable()
+export class RedisPubSubMessagingService implements IMessagingSystem {
+  private readonly logger = new Logger(RedisPubSubMessagingService.name);
+
+  constructor(
+    @Inject('REDIS_PUBLISHER') private readonly publisher: RedisClientType,
+    @Inject('REDIS_SUBSCRIBER') private readonly subscriber: RedisClientType,
+  ) {}
+
+  getName(): string {
+    return 'Redis PubSub';
+  }
+
+  async publish(channel: string, payload: any): Promise<void> {
+    try {
+      const message = JSON.stringify(payload);
+      const subscriberCount = await this.publisher.publish(channel, message);
+      
+      this.logger.debug(
+        `[Redis PubSub] Published to ${channel}, ${subscriberCount} subscriber(s) received`
+      );
+    } catch (error: any) {
+      this.logger.error(`[Redis PubSub] Failed to publish to ${channel}: ${error?.message}`);
+      throw error;
+    }
+  }
+
+  async subscribe(channel: string, handler: (message: any) => Promise<void>): Promise<void> {
+    await this.subscriber.subscribe(channel, async (message) => {
+      try {
+        const data = JSON.parse(message);
+        await handler(data);
+      } catch (error: any) {
+        this.logger.error(
+          `[Redis PubSub] Failed to process message from ${channel}: ${error?.message}`
+        );
+      }
+    });
+    
+    this.logger.log(`[Redis PubSub] Subscribed to channel: ${channel}`);
+  }
+}
--- a/src/common/modules/notification/services/notification-factory.service.ts
+++ b/src/common/modules/notification/services/notification-factory.service.ts
@ -83,13 +83,16 @@ export class NotificationFactory {
   * Send a notification to a user
   * Routes to enabled channels based on provided preferences
   * 
+   * Note: Notifications are always saved to the database (via PUSH channel)
+   * for history/audit purposes, even if push notifications are disabled.
+   * The preferences only control whether push/email/SMS are actually sent.
+   * 
   * @param payload - Notification payload including preferences
   */
  async send(payload: NotificationPayload): Promise<void> {
    try {
      this.logger.log(`Sending notification to user ${payload.userId} - ${payload.title}`);

-      // Use provided preferences or default to push-only
      const preferences = payload.preferences || {
        isPushEnabled: true,
        isEmailEnabled: false,
@ -98,36 +101,23 @@ export class NotificationFactory {

      const promises: Promise<any>[] = [];

-      // Route to enabled channels based on preferences
-      // Currently only PUSH is implemented (extensible for EMAIL, SMS later)
-      if (preferences.isPushEnabled) {
-        this.logger.debug(`Routing to PUSH channel for user ${payload.userId}`);
-        promises.push(
-          this.sendToChannel(payload, NotificationChannel.PUSH)
-        );
-      }
+      // Always create notification record in database (via PUSH channel for storage)
+      // This ensures notifications are saved for history, even if push is disabled
+      this.logger.debug(`Creating notification record for user ${payload.userId}`);
+      promises.push(
+        this.sendToChannel(payload, NotificationChannel.PUSH)
+      );

-      // Future: Add EMAIL channel
-      // if (preferences.isEmailEnabled) {
-      //   this.logger.debug(`Routing to EMAIL channel for user ${payload.userId}`);
-      //   promises.push(
-      //     this.sendToChannel(payload, NotificationChannel.EMAIL)
-      //   );
-      // }
+      // Only send via additional channels if enabled
+      // Note: PUSH channel is already added above for database storage
+      // The actual push delivery will check preferences in FirebaseService

-      // Future: Add SMS channel
-      // if (preferences.isSmsEnabled) {
-      //   this.logger.debug(`Routing to SMS channel for user ${payload.userId}`);
-      //   promises.push(
-      //     this.sendToChannel(payload, NotificationChannel.SMS)
-      //   );
-      // }
-
-      // Send all notificaetions in parallel
      await Promise.all(promises);

+      const activeChannels = preferences.isPushEnabled ? 1 : 0;
      this.logger.log(
-        `Notification sent to user ${payload.userId} via ${promises.length} channel(s)`
+        `Notification sent to user ${payload.userId} via ${activeChannels} active channel(s) ` +
+        `(saved to database regardless of preferences)`
      );
    } catch (error: any) {
      this.logger.error(
--- a/src/common/modules/notification/services/notifications.service.ts
+++ b/src/common/modules/notification/services/notifications.service.ts
@ -6,8 +6,9 @@ import { OtpType } from '../../otp/enums';
 import { ISendOtp } from '../../otp/interfaces';
 import { SendEmailRequestDto } from '../dtos/request';
 import { Notification } from '../entities';
-import { EventType, NotificationChannel, NotificationScope } from '../enums';
+import { EventType, NotificationChannel, NotificationScope, NotificationStatus } from '../enums';
 import { NotificationsRepository } from '../repositories';
+import { MessagingSystemFactory } from './messaging/messaging-system-factory.service';

@Injectable()
 export class NotificationsService {
@ -17,6 +18,7 @@ export class NotificationsService {

    @Inject(forwardRef(() => RedisPubSubService))
    private readonly redisPubSubService: RedisPubSubService,
+    private readonly messagingSystemFactory: MessagingSystemFactory,
  ) {}

  async getNotifications(userId: string, pageOptionsDto: PageOptionsRequestDto) {
@ -31,9 +33,32 @@ export class NotificationsService {
    return { notifications, count, unreadCount };
  }

-  createNotification(notification: Partial<Notification>) {
+  async createNotification(notification: Partial<Notification>) {
    this.logger.log(`Creating notification for user ${notification.userId}`);
-    return this.notificationRepository.createNotification(notification);
+    const savedNotification = await this.notificationRepository.createNotification({
+      ...notification,
+      status: notification.status || NotificationStatus.UNREAD,
+    });
+    
+    const scope = notification.scope || NotificationScope.USER_REGISTERED;
+    const messagingSystem = this.messagingSystemFactory.getMessagingSystem(scope);
+    
+    this.logger.log(
+      `Publishing ${EventType.NOTIFICATION_CREATED} event to ${messagingSystem.getName()}`
+    );
+    
+    messagingSystem.publish(EventType.NOTIFICATION_CREATED, {
+      ...savedNotification,
+      data: notification.data || savedNotification.data,
+    }).catch((error) => {
+      this.logger.error(
+        `Failed to publish notification ${savedNotification.id} to ${messagingSystem.getName()}: ` +
+        `${error?.message || 'Unknown error'}`,
+        error?.stack
+      );
+    });
+    
+    return savedNotification;
  }

  markAsRead(userId: string) {
@ -42,34 +67,25 @@ export class NotificationsService {
  }

  async sendEmailAsync(data: SendEmailRequestDto) {
-    this.logger.log(`emitting ${EventType.NOTIFICATION_CREATED} event`);
-    const notification = await this.createNotification({
+    this.logger.log(`Creating email notification for ${data.to}`);
+    await this.createNotification({
      recipient: data.to,
      title: data.subject,
      message: '',
      scope: NotificationScope.USER_INVITED,
      channel: NotificationChannel.EMAIL,
-    });
-    // return this.redisPubSubService.emit(EventType.NOTIFICATION_CREATED, notification, data.data);
-    this.redisPubSubService.publishEvent(EventType.NOTIFICATION_CREATED, {
-      ...notification,
-      data,
+      data: data.data,
    });
  }

  async sendOtpNotification(sendOtpRequest: ISendOtp, otp: string) {
    this.logger.log(`Sending OTP to ${sendOtpRequest.recipient}`);
-    const notification = await this.createNotification({
+    return this.createNotification({
      recipient: sendOtpRequest.recipient,
      title: OTP_TITLE,
      message: OTP_BODY.replace('{otp}', otp),
      scope: NotificationScope.OTP,
      channel: sendOtpRequest.otpType === OtpType.EMAIL ? NotificationChannel.EMAIL : NotificationChannel.SMS,
-    });
-
-    this.logger.log(`emitting ${EventType.NOTIFICATION_CREATED} event`);
-    return this.redisPubSubService.publishEvent(EventType.NOTIFICATION_CREATED, {
-      ...notification,
      data: { otp },
    });
  }
--- a/src/common/redis/redis.module.ts
+++ b/src/common/redis/redis.module.ts
@ -14,7 +14,15 @@ export class RedisModule {
        {
          provide: 'REDIS_PUBLISHER',
          useFactory: async (configService: ConfigService) => {
-            const publisher = createClient({ url: configService.get<string>('REDIS_URL') });
+            // Skip Redis connection during migration generation
+            if (process.env.MIGRATIONS_RUN === 'false') {
+              return null;
+            }
+            const redisUrl = configService.get<string>('REDIS_URL');
+            if (!redisUrl) {
+              return null;
+            }
+            const publisher = createClient({ url: redisUrl });
            await publisher.connect();
            return publisher;
          },
@ -24,7 +32,15 @@ export class RedisModule {
        {
          provide: 'REDIS_SUBSCRIBER',
          useFactory: async (configService: ConfigService) => {
-            const subscriber = createClient({ url: configService.get<string>('REDIS_URL') });
+            // Skip Redis connection during migration generation
+            if (process.env.MIGRATIONS_RUN === 'false') {
+              return null;
+            }
+            const redisUrl = configService.get<string>('REDIS_URL');
+            if (!redisUrl) {
+              return null;
+            }
+            const subscriber = createClient({ url: redisUrl });
            await subscriber.connect();
            return subscriber;
          },
@ -32,7 +48,11 @@ export class RedisModule {
        },
        RedisPubSubService,
      ],
-      exports: [RedisPubSubService],
+      exports: [
+        RedisPubSubService,
+        'REDIS_PUBLISHER',
+        'REDIS_SUBSCRIBER',
+      ],
      imports: [NotificationModule],
    };
  }
--- a/src/common/redis/services/redis-pubsub.service.ts
+++ b/src/common/redis/services/redis-pubsub.service.ts
@ -15,6 +15,10 @@ export class RedisPubSubService implements OnModuleInit {
  ) {}

  onModuleInit() {
+    // Skip subscription during migration generation
+    if (process.env.MIGRATIONS_RUN === 'false' || !this.subscriber) {
+      return;
+    }
    this.subscriber.subscribe(EventType.NOTIFICATION_CREATED, async (message) => {
      const data = JSON.parse(message);
      this.logger.log('Received message on NOTIFICATION_CREATED channel:', data);
--- a/src/common/utils/currency.util.ts
+++ b/src/common/utils/currency.util.ts
@ -0,0 +1,111 @@
+/**
+ * Currency utility functions
+ * Handles currency code mapping and formatting
+ */
+
+/**
+ * ISO 4217 numeric currency codes to ISO currency code mapping
+ * Common codes used in the system:
+ * - 682: SAR (Saudi Riyal)
+ * - 900: USD (US Dollar) - if used
+ * - 784: AED (UAE Dirham)
+ * - 414: KWD (Kuwaiti Dinar)
+ * - 512: OMR (Omani Rial)
+ * - 048: BHD (Bahraini Dinar)
+ * - 400: JOD (Jordanian Dinar)
+ */
+export const NUMERIC_TO_CURRENCY_CODE: Record<string, string> = {
+  '682': 'SAR',
+  '900': 'USD',
+  '784': 'AED',
+  '414': 'KWD',
+  '512': 'OMR',
+  '048': 'BHD',
+  '400': 'JOD',
+  '586': 'PKR',
+};
+
+/**
+ * Currency decimal places mapping
+ * ISO 4217 standard decimal places for each currency
+ */
+export const CURRENCY_DECIMAL_PLACES: Record<string, number> = {
+  'SAR': 2, // Saudi Riyal
+  'USD': 2, // US Dollar
+  'AED': 2, // UAE Dirham
+  'KWD': 3, // Kuwaiti Dinar
+  'OMR': 3, // Omani Rial
+  'BHD': 3, // Bahraini Dinar
+  'JOD': 3, // Jordanian Dinar
+  'PKR': 2, // Pakistani Rupee
+  'JPY': 0, // Japanese Yen (if used)
+  'KRW': 0, // South Korean Won (if used)
+};
+
+/**
+ * Convert numeric currency code to ISO currency code
+ * @param numericCode - Numeric currency code (e.g., '682')
+ * @returns ISO currency code (e.g., 'SAR') or the original code if not found
+ */
+export function numericToCurrencyCode(numericCode: string | null | undefined): string {
+  if (!numericCode) {
+    return 'SAR'; // Default fallback
+  }
+
+  // If already an ISO code (3 letters), return as is
+  if (/^[A-Z]{3}$/.test(numericCode)) {
+    return numericCode;
+  }
+
+  // Map numeric code to ISO code
+  return NUMERIC_TO_CURRENCY_CODE[numericCode] || numericCode;
+}
+
+/**
+ * Format amount based on currency decimal places
+ * @param amount - Amount to format (number or string)
+ * @param currency - ISO currency code (e.g., 'SAR', 'KWD')
+ * @returns Formatted amount string
+ */
+export function formatCurrencyAmount(amount: number | string, currency: string): string {
+  const numAmount = typeof amount === 'string' ? parseFloat(amount) : amount;
+  
+  if (isNaN(numAmount)) {
+    return '0';
+  }
+
+  const decimalPlaces = CURRENCY_DECIMAL_PLACES[currency] ?? 2;
+  return numAmount.toFixed(decimalPlaces);
+}
+
+/**
+ * Get currency from account or transaction, with fallback
+ * @param accountCurrency - Currency from account entity (may be numeric like '682')
+ * @param transactionCurrency - Currency from transaction entity (may be numeric)
+ * @param fallback - Fallback currency (default: 'SAR')
+ * @returns ISO currency code
+ */
+export function getCurrency(
+  accountCurrency?: string | null,
+  transactionCurrency?: string | null,
+  fallback: string = 'SAR'
+): string {
+  // Convert account currency first (it may be numeric like '682')
+  if (accountCurrency) {
+    const converted = numericToCurrencyCode(accountCurrency);
+    if (converted && converted !== accountCurrency) {
+      return converted; // Successfully converted from numeric to ISO
+    }
+    // If already ISO format, return as is
+    if (/^[A-Z]{3}$/.test(accountCurrency)) {
+      return accountCurrency;
+    }
+  }
+
+  // Convert transaction currency (may be numeric)
+  if (transactionCurrency) {
+    return numericToCurrencyCode(transactionCurrency);
+  }
+
+  return fallback;
+}
--- a/src/customer/services/customer.service.ts
+++ b/src/customer/services/customer.service.ts
@ -1,10 +1,16 @@
 import { BadRequestException, ConflictException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import moment from 'moment';
 import { Transactional } from 'typeorm-transactional';
 import { CountryIso } from '~/common/enums';
 import { NumericToCountryIso } from '~/common/mappers';
 import { KycWebhookRequest } from '~/common/modules/neoleap/dtos/requests';
 import { NeoLeapService } from '~/common/modules/neoleap/services';
+import { NOTIFICATION_EVENTS } from '~/common/modules/notification/constants/event-names.constant';
+import {
+  IKycApprovedEvent,
+  IKycRejectedEvent,
+} from '~/common/modules/notification/interfaces/notification-events.interface';
 import { GuardianService } from '~/guardian/services';
 import { CreateJuniorRequestDto } from '~/junior/dtos/request';
 import { User } from '~/user/entities';
@ -23,6 +29,7 @@ export class CustomerService {
    private readonly guardianService: GuardianService,
    @Inject(forwardRef(() => NeoLeapService)) private readonly neoleapService: NeoLeapService,
    private readonly metadataService: MetadataService,
+    private readonly eventEmitter: EventEmitter2,
  ) {}

  async updateCustomer(userId: string, data: Partial<Customer>): Promise<Customer> {
@ -151,6 +158,7 @@ export class CustomerService {
    }

    const customer = await this.findCustomerById(transaction.customerId);
+    const previousStatus = customer.kycStatus;

    // Update transaction record
    await this.kycTransactionRepo.updateByStateId(body.stateId, {
@ -165,8 +173,32 @@ export class CustomerService {
    await this.customerRepository.updateCustomer(customer.id, {
      kycStatus,
      neoleapExternalCustomerId: body.entity.externalId,
+      rejectionReason: kycStatus === KycStatus.REJECTED ? 'KYC verification failed' : null,
    });

+    // Reload customer with updated data
+    const updatedCustomer = await this.findCustomerById(customer.id);
+
+    // Emit notification event
+    if (kycStatus === KycStatus.APPROVED) {
+      const event: IKycApprovedEvent = {
+        customer: updatedCustomer,
+        previousStatus,
+        timestamp: new Date(),
+      };
+      this.eventEmitter.emit(NOTIFICATION_EVENTS.KYC_APPROVED, event);
+      this.logger.log(`Emitted KYC_APPROVED event for customer ${customer.id}`);
+    } else {
+      const event: IKycRejectedEvent = {
+        customer: updatedCustomer,
+        previousStatus,
+        rejectionReason: updatedCustomer.rejectionReason || 'KYC verification failed',
+        timestamp: new Date(),
+      };
+      this.eventEmitter.emit(NOTIFICATION_EVENTS.KYC_REJECTED, event);
+      this.logger.log(`Emitted KYC_REJECTED event for customer ${customer.id}`);
+    }
+
    this.logger.log(`KYC updated successfully for customer ${customer.id}, status: ${body.status}, externalId: ${body.entity.externalId}`);
  }

--- a/src/db/migrations/1768395622276-AddTimezoneFields.ts
+++ b/src/db/migrations/1768395622276-AddTimezoneFields.ts
@ -0,0 +1,18 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddTimezoneFields1768395622276 implements MigrationInterface {
+    name = 'AddTimezoneFields1768395622276'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "users" ADD "timezone" character varying(50)`);
+        await queryRunner.query(`ALTER TABLE "devices" ADD "timezone" character varying(50)`);
+        await queryRunner.query(`ALTER TABLE "users" ALTER COLUMN "is_push_enabled" SET DEFAULT true`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "users" ALTER COLUMN "is_push_enabled" SET DEFAULT false`);
+        await queryRunner.query(`ALTER TABLE "devices" DROP COLUMN "timezone"`);
+        await queryRunner.query(`ALTER TABLE "users" DROP COLUMN "timezone"`);
+    }
+
+}
--- a/src/db/migrations/index.ts
+++ b/src/db/migrations/index.ts
@ -11,3 +11,4 @@ export * from './1765804942393-AddKycFieldsAndTransactions';
 export * from './1765877128065-AddNationalIdToKycTransactions';
 export * from './1765891028260-RemoveOldCustomerColumns';
 export * from './1765975126402-RemoveAddressColumns';
+export * from './1768395622276-AddTimezoneFields';
--- a/src/i18n/ar/app.json
+++ b/src/i18n/ar/app.json
@ -110,5 +110,48 @@
    "INSUFFICIENT_BALANCE": "البطاقة لا تحتوي على رصيد كافٍ لإكمال هذا التحويل.",
    "DOES_NOT_BELONG_TO_GUARDIAN": "البطاقة لا تنتمي إلى ولي الأمر.",
    "NOT_FOUND": "لم يتم العثور على البطاقة."
+  },
+  "NOTIFICATION": {
+    "CHILD_TOP_UP_TITLE": "تم إضافة رصيد",
+    "CHILD_TOP_UP_MESSAGE": "تمت إضافة {amount} {currency} إلى بطاقتك. إجمالي الرصيد: {balance} {currency}",
+    "CHILD_INTERNAL_TRANSFER_TITLE": "تم إضافة رصيد",
+    "CHILD_INTERNAL_TRANSFER_MESSAGE": "تمت إضافة {amount} {currency} إلى بطاقتك. إجمالي الرصيد: {balance} {currency}",
+    "PARENT_INTERNAL_TRANSFER_TITLE": "اكتمل التحويل",
+    "PARENT_INTERNAL_TRANSFER_MESSAGE": "تم تحويل {amount} {currency} إلى بطاقة {childName}. رصيد {childName}: {balance} {currency}",
+    "CHILD_SPENDING_TITLE": "عملية شراء ناجحة",
+    "CHILD_SPENDING_MESSAGE": "قمت بإنفاق {amount} {currency} في {merchant}",
+    "PARENT_SPENDING_TITLE": "تنبيه صرف",
+    "PARENT_SPENDING_MESSAGE": "قام {childName} بإنفاق {amount} {currency} في {merchant}. الرصيد المتبقي: {balance} {currency}",
+    "YOUR_CHILD": "طفلك",
+    "MONEY_REQUEST_CREATED_TITLE": "طلب مبلغ مالي",
+    "MONEY_REQUEST_CREATED_MESSAGE": "طلب {childName} مبلغ {amount} {currency} لـ {reason}",
+    "MONEY_REQUEST_APPROVED_TITLE": "تمت الموافقة على طلب المال",
+    "MONEY_REQUEST_APPROVED_MESSAGE": "تمت الموافقة على طلبك بمبلغ {amount} {currency}. تمت إضافة المال إلى حسابك.",
+    "MONEY_REQUEST_DECLINED_TITLE": "تم رفض طلب المال",
+    "MONEY_REQUEST_DECLINED_MESSAGE": "تم رفض طلبك بمبلغ {amount} {currency}. السبب: {reason}",
+    "KYC_APPROVED_TITLE": "تمت الموافقة على التحقق من الهوية",
+    "KYC_APPROVED_MESSAGE": "تمت الموافقة على التحقق من هويتك. يمكنك الآن استخدام جميع ميزات التطبيق.",
+    "KYC_REJECTED_TITLE": "تم رفض التحقق من الهوية",
+    "KYC_REJECTED_MESSAGE": "تم رفض التحقق من هويتك. السبب: {reason}. يرجى مراجعة معلوماتك والمحاولة مرة أخرى.",
+    "CARD_CREATED_TITLE": "تم إنشاء البطاقة",
+    "CARD_CREATED_MESSAGE": "تم إنشاء بطاقتك التي تنتهي بـ {lastFourDigits} بنجاح. يمكنك البدء في استخدامها بمجرد تفعيلها.",
+    "CARD_BLOCKED_TITLE": "تم حظر البطاقة",
+    "CARD_BLOCKED_MESSAGE": "تم حظر بطاقتك التي تنتهي بـ {lastFourDigits}. السبب: {reason}. يرجى الاتصال بالدعم للحصول على المساعدة.",
+    "PROFILE_UPDATED_TITLE": "تم تحديث الملف الشخصي",
+    "PROFILE_UPDATED_MESSAGE": "تم تحديث ملفك الشخصي. التغييرات: {fields}",
+    "PROFILE_EMAIL_UPDATED_TITLE": "تم تحديث البريد الإلكتروني",
+    "PROFILE_EMAIL_UPDATED_MESSAGE": "تم تحديث بريدك الإلكتروني إلى {email}. يرجى التحقق من عنوان بريدك الإلكتروني الجديد.",
+    "PROFILE_PASSWORD_UPDATED_TITLE": "تم تحديث كلمة المرور",
+    "PROFILE_PASSWORD_UPDATED_MESSAGE": "تم تحديث كلمة المرور بنجاح. إذا لم تقم بهذا التغيير، يرجى الاتصال بالدعم فوراً.",
+    "PROFILE_PICTURE_UPDATED_TITLE": "تم تحديث صورة الملف الشخصي",
+    "PROFILE_PICTURE_UPDATED_MESSAGE": "تم تحديث صورة ملفك الشخصي بنجاح.",
+    "PROFILE_NAME_UPDATED_TITLE": "تم تحديث الاسم",
+    "PROFILE_NAME_UPDATED_MESSAGE": "تم تحديث اسمك بنجاح.",
+    "MAINTENANCE_ALERT_TITLE": "صيانة مجدولة",
+    "MAINTENANCE_ALERT_MESSAGE": "{message}",
+    "TRANSACTION_FAILED_TITLE": "فشلت المعاملة",
+    "TRANSACTION_FAILED_MESSAGE": "لم يتم إكمال معاملتك. السبب: {reason}. يرجى المحاولة مرة أخرى أو الاتصال بالدعم إذا استمرت المشكلة.",
+    "SUSPICIOUS_LOGIN_TITLE": "تم اكتشاف تسجيل دخول مشبوه",
+    "SUSPICIOUS_LOGIN_MESSAGE": "اكتشفنا محاولة تسجيل دخول من {location} ({ipAddress}) باستخدام {device}. إذا لم تكن أنت، يرجى تغيير كلمة المرور فوراً والاتصال بالدعم."
  }
 }
--- a/src/i18n/en/app.json
+++ b/src/i18n/en/app.json
@ -109,5 +109,48 @@
    "INSUFFICIENT_BALANCE": "The card does not have sufficient balance to complete this transfer.",
    "DOES_NOT_BELONG_TO_GUARDIAN": "The card does not belong to the guardian.",
    "NOT_FOUND": "The card was not found."
+  },
+  "NOTIFICATION": {
+    "CHILD_TOP_UP_TITLE": "Funds Credited",
+    "CHILD_TOP_UP_MESSAGE": "{amount} {currency} has been added to your card. Total balance: {balance} {currency}",
+    "CHILD_INTERNAL_TRANSFER_TITLE": "Funds Credited",
+    "CHILD_INTERNAL_TRANSFER_MESSAGE": "{amount} {currency} has been added to your card. Total balance: {balance} {currency}",
+    "PARENT_INTERNAL_TRANSFER_TITLE": "Internal Transfer Completed",
+    "PARENT_INTERNAL_TRANSFER_MESSAGE": "{amount} {currency} has been transferred to {childName}'s card. {childName}'s balance is {balance} {currency}",
+    "CHILD_SPENDING_TITLE": "Purchase Successful",
+    "CHILD_SPENDING_MESSAGE": "You spent {amount} {currency} at {merchant}",
+    "PARENT_SPENDING_TITLE": "Spending Alert",
+    "PARENT_SPENDING_MESSAGE": "{childName} spent {amount} {currency} at {merchant}. Remaining balance: {balance} {currency}",
+    "YOUR_CHILD": "Your child",
+    "MONEY_REQUEST_CREATED_TITLE": "Money Request",
+    "MONEY_REQUEST_CREATED_MESSAGE": "{childName} has requested {amount} {currency} for {reason}.",
+    "MONEY_REQUEST_APPROVED_TITLE": "Money Request Approved",
+    "MONEY_REQUEST_APPROVED_MESSAGE": "Your request for {amount} {currency} has been approved. The money has been added to your account.",
+    "MONEY_REQUEST_DECLINED_TITLE": "Money Request Declined",
+    "MONEY_REQUEST_DECLINED_MESSAGE": "Your request for {amount} {currency} has been declined. Reason: {reason}",
+    "KYC_APPROVED_TITLE": "KYC Verification Approved",
+    "KYC_APPROVED_MESSAGE": "Your KYC verification has been approved. You can now use all features of the app.",
+    "KYC_REJECTED_TITLE": "KYC Verification Rejected",
+    "KYC_REJECTED_MESSAGE": "Your KYC verification has been rejected. Reason: {reason}. Please review your information and try again.",
+    "CARD_CREATED_TITLE": "Card Created",
+    "CARD_CREATED_MESSAGE": "Your card ending in {lastFourDigits} has been created successfully. You can start using it once it's activated.",
+    "CARD_BLOCKED_TITLE": "Card Blocked",
+    "CARD_BLOCKED_MESSAGE": "Your card ending in {lastFourDigits} has been blocked. Reason: {reason}. Please contact support for assistance.",
+    "PROFILE_UPDATED_TITLE": "Profile Updated",
+    "PROFILE_UPDATED_MESSAGE": "Your profile has been updated. Changes: {fields}",
+    "PROFILE_EMAIL_UPDATED_TITLE": "Email Updated",
+    "PROFILE_EMAIL_UPDATED_MESSAGE": "Your email has been updated to {email}. Please verify your new email address.",
+    "PROFILE_PASSWORD_UPDATED_TITLE": "Password Updated",
+    "PROFILE_PASSWORD_UPDATED_MESSAGE": "Your password has been successfully updated. If you did not make this change, please contact support immediately.",
+    "PROFILE_PICTURE_UPDATED_TITLE": "Profile Picture Updated",
+    "PROFILE_PICTURE_UPDATED_MESSAGE": "Your profile picture has been updated successfully.",
+    "PROFILE_NAME_UPDATED_TITLE": "Name Updated",
+    "PROFILE_NAME_UPDATED_MESSAGE": "Your name has been updated successfully.",
+    "MAINTENANCE_ALERT_TITLE": "Scheduled Maintenance",
+    "MAINTENANCE_ALERT_MESSAGE": "{message}",
+    "TRANSACTION_FAILED_TITLE": "Transaction Failed",
+    "TRANSACTION_FAILED_MESSAGE": "Your transaction could not be completed. Reason: {reason}. Please try again or contact support if the issue persists.",
+    "SUSPICIOUS_LOGIN_TITLE": "Suspicious Login Detected",
+    "SUSPICIOUS_LOGIN_MESSAGE": "We detected a login attempt from {location} ({ipAddress}) using {device}. If this was not you, please change your password immediately and contact support."
  }
 }
--- a/src/money-request/repositories/money-requests.repository.ts
+++ b/src/money-request/repositories/money-requests.repository.ts
@ -56,7 +56,35 @@ export class MoneyRequestsRepository {
    }
    return this.moneyRequestRepository.findOne({
      where: whereCondition,
-      relations: ['junior', 'junior.customer', 'junior.customer.user', 'junior.customer.user.profilePicture'],
+      relations: [
+        'junior',
+        'junior.customer',
+        'junior.customer.user',
+        'junior.customer.user.profilePicture',
+      ],
+    });
+  }
+
+  findByIdWithAllRelations(id: string, userId?: string, role?: Roles): Promise<MoneyRequest | null> {
+    const whereCondition: any = { id };
+    if (role === Roles.JUNIOR) {
+      whereCondition.juniorId = userId;
+    } else {
+      whereCondition.guardianId = userId;
+    }
+    return this.moneyRequestRepository.findOne({
+      where: whereCondition,
+      relations: [
+        'junior',
+        'junior.customer',
+        'junior.customer.user',
+        'junior.customer.user.profilePicture',
+        'junior.customer.cards',
+        'junior.customer.cards.account',
+        'guardian',
+        'guardian.customer',
+        'guardian.customer.user',
+      ],
    });
  }

--- a/src/money-request/services/money-requests.service.ts
+++ b/src/money-request/services/money-requests.service.ts
@ -1,6 +1,13 @@
 import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import { Transactional } from 'typeorm-transactional';
 import { Roles } from '~/auth/enums';
+import { NOTIFICATION_EVENTS } from '~/common/modules/notification/constants/event-names.constant';
+import {
+  IMoneyRequestApprovedEvent,
+  IMoneyRequestCreatedEvent,
+  IMoneyRequestDeclinedEvent,
+} from '~/common/modules/notification/interfaces/notification-events.interface';
 import { OciService } from '~/document/services';
 import { Junior } from '~/junior/entities/junior.entity';
 import { JuniorService } from '~/junior/services';
@ -16,10 +23,19 @@ export class MoneyRequestsService {
    private readonly moneyRequestsRepository: MoneyRequestsRepository,
    private readonly juniorService: JuniorService,
    private readonly ociService: OciService,
+    private readonly eventEmitter: EventEmitter2,
  ) {}
  async createMoneyRequest(juniorId: string, body: CreateMoneyRequestDto) {
    const junior = await this.juniorService.findJuniorById(juniorId);
    const moneyRequest = await this.moneyRequestsRepository.createMoneyRequest(junior.id, junior.guardianId, body);
+    const moneyRequestWithRelations = await this.moneyRequestsRepository.findByIdWithAllRelations(moneyRequest.id);
+
+    const event: IMoneyRequestCreatedEvent = {
+      moneyRequest: moneyRequestWithRelations!,
+      timestamp: new Date(),
+    };
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.MONEY_REQUEST_CREATED, event);
+
    return this.findById(moneyRequest.id);
  }

@ -63,6 +79,13 @@ export class MoneyRequestsService {
        moneyRequest.guardianId,
      ),
    ]);
+
+    const updatedMoneyRequest = await this.moneyRequestsRepository.findByIdWithAllRelations(id, guardianId, Roles.GUARDIAN);
+    const event: IMoneyRequestApprovedEvent = {
+      moneyRequest: updatedMoneyRequest!,
+      timestamp: new Date(),
+    };
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.MONEY_REQUEST_APPROVED, event);
  }

  async rejectMoneyRequest(
@ -85,6 +108,14 @@ export class MoneyRequestsService {
    }

    await this.moneyRequestsRepository.rejectMoneyRequest(id, rejectionReasondto?.rejectionReason);
+
+    const updatedMoneyRequest = await this.moneyRequestsRepository.findByIdWithAllRelations(id, guardianId, Roles.GUARDIAN);
+    const event: IMoneyRequestDeclinedEvent = {
+      moneyRequest: updatedMoneyRequest!,
+      rejectionReason: rejectionReasondto?.rejectionReason,
+      timestamp: new Date(),
+    };
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.MONEY_REQUEST_DECLINED, event);
  }

  private async prepareJuniorImages(juniors: Junior[]) {
--- a/src/user/controllers/user.controller.ts
+++ b/src/user/controllers/user.controller.ts
@ -1,15 +1,15 @@
-import { Body, Controller, Get, Headers, HttpCode, HttpStatus, Patch, UseGuards } from '@nestjs/common';
+import { Body, Controller, Get, HttpCode, HttpStatus, Patch, UseGuards } from '@nestjs/common';
 import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
 import { VerifyOtpRequestDto } from '~/auth/dtos/request';
 import { UserResponseDto } from '~/auth/dtos/response';
 import { IJwtPayload } from '~/auth/interfaces';
-import { DEVICE_ID_HEADER } from '~/common/constants';
 import { AuthenticatedUser } from '~/common/decorators';
 import { AccessTokenGuard } from '~/common/guards';
 import { ApiDataResponse } from '~/core/decorators';
 import { ResponseFactory } from '~/core/utils';
 import { UpdateNotificationsSettingsRequestDto, UpdateUserRequestDto } from '../dtos/request';
 import { UpdateEmailRequestDto } from '../dtos/request/update-email.request.dto';
+import { NotificationsSettingsResponseDto } from '../dtos/response/notifications-settings.response.dto';
 import { UserService } from '../services';

@Controller('profile')
@ -45,13 +45,22 @@ export class UserController {
    return this.userService.verifyEmail(user.sub, otp);
  }

+  @Get('notifications-settings')
+  @HttpCode(HttpStatus.OK)
+  @ApiDataResponse(NotificationsSettingsResponseDto)
+  async getNotificationSettings(@AuthenticatedUser() { sub }: IJwtPayload) {
+    const user = await this.userService.findUserOrThrow({ id: sub });
+    return ResponseFactory.data(new NotificationsSettingsResponseDto({
+      isPushEnabled: user.isPushEnabled ?? true,
+    }));
+  }
+
  @Patch('notifications-settings')
  @HttpCode(HttpStatus.NO_CONTENT)
  async updateNotificationSettings(
    @AuthenticatedUser() user: IJwtPayload,
    @Body() data: UpdateNotificationsSettingsRequestDto,
-    @Headers(DEVICE_ID_HEADER) deviceId: string,
  ) {
-    return this.userService.updateNotificationSettings(user.sub, data, deviceId);
+    return this.userService.updateNotificationSettings(user.sub, data, data.deviceId);
  }
 }
--- a/src/user/dtos/request/update-notifications-settings.request.dto.ts
+++ b/src/user/dtos/request/update-notifications-settings.request.dto.ts
@ -2,23 +2,19 @@ import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsBoolean, IsOptional, IsString, ValidateIf } from 'class-validator';
 import { i18nValidationMessage as i18n } from 'nestjs-i18n';
 export class UpdateNotificationsSettingsRequestDto {
-  @ApiProperty()
-  @IsBoolean({ message: i18n('validation.IsBoolean', { path: 'general', property: 'customer.isEmailEnabled' }) })
-  @IsOptional()
-  isEmailEnabled!: boolean;
-
-  @ApiProperty()
+  @ApiPropertyOptional({ example: true, description: 'Enable/disable push notifications (default: true)', default: true })
  @IsBoolean({ message: i18n('validation.IsBoolean', { path: 'general', property: 'customer.isPushEnabled' }) })
  @IsOptional()
-  isPushEnabled!: boolean;
+  isPushEnabled?: boolean;

-  @ApiProperty()
-  @IsBoolean({ message: i18n('validation.IsBoolean', { path: 'general', property: 'customer.isSmsEnabled' }) })
-  @IsOptional()
-  isSmsEnabled!: boolean;
-
-  @ApiPropertyOptional()
+  @ApiPropertyOptional({ example: 'cXYzABC:APA91bH...', description: 'Firebase Cloud Messaging token (required if enabling push)' })
  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.fcmToken' }) })
-  @ValidateIf((o) => o.isPushEnabled)
+  @ValidateIf((o) => o.isPushEnabled !== false)
+  @IsOptional()
  fcmToken?: string;
+
+  @ApiPropertyOptional({ example: 'device-123', description: 'Device identifier (optional, will be found automatically if not provided)' })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'auth.deviceId' }) })
+  deviceId?: string;
 }
--- a/src/user/dtos/request/update-user.request.dto.ts
+++ b/src/user/dtos/request/update-user.request.dto.ts
@ -34,4 +34,12 @@ export class UpdateUserRequestDto {
  @IsDateString({}, { message: i18n('validation.IsDateString', { path: 'general', property: 'customer.dateOfBirth' }) })
  @IsOptional()
  dateOfBirth!: Date;
+
+  @ApiPropertyOptional({
+    example: 'Asia/Riyadh',
+    description: 'User preferred timezone for reports/statements (e.g., "Asia/Riyadh", "America/New_York"). Leave empty or "Auto" to use device timezone.',
+  })
+  @IsOptional()
+  @IsString({ message: i18n('validation.IsString', { path: 'general', property: 'user.timezone' }) })
+  timezone?: string;
 }
--- a/src/user/dtos/response/notifications-settings.response.dto.ts
+++ b/src/user/dtos/response/notifications-settings.response.dto.ts
@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class NotificationsSettingsResponseDto {
+  @ApiProperty({ example: true, description: 'Push notifications enabled/disabled' })
+  isPushEnabled!: boolean;
+
+  constructor(data: { isPushEnabled: boolean }) {
+    this.isPushEnabled = data.isPushEnabled;
+  }
+}
--- a/src/user/entities/device.entity.ts
+++ b/src/user/entities/device.entity.ts
@ -18,6 +18,9 @@ export class Device {
  @Column('varchar', { name: 'fcm_token', nullable: true })
  fcmToken?: string | null;

+  @Column('varchar', { name: 'timezone', nullable: true, length: 50 })
+  timezone?: string | null; // e.g., "Asia/Riyadh", "America/New_York" - auto-detected from device
+
  @Column('timestamp with time zone', { name: 'last_access_on', default: () => 'CURRENT_TIMESTAMP' })
  lastAccessOn!: Date;

--- a/src/user/entities/user.entity.ts
+++ b/src/user/entities/user.entity.ts
@ -61,12 +61,15 @@ export class User extends BaseEntity {
  @Column({ name: 'is_email_enabled', default: false })
  isEmailEnabled!: boolean;

-  @Column({ name: 'is_push_enabled', default: false })
+  @Column({ name: 'is_push_enabled', default: true })
  isPushEnabled!: boolean;

  @Column({ name: 'is_sms_enabled', default: false })
  isSmsEnabled!: boolean;

+  @Column('varchar', { name: 'timezone', nullable: true, length: 50 })
+  timezone?: string | null; // User's preferred timezone for reports/statements (e.g., "Asia/Riyadh")
+
  @Column('text', { nullable: true, array: true, name: 'roles' })
  roles!: Roles[];

--- a/src/user/repositories/device.repository.ts
+++ b/src/user/repositories/device.repository.ts
@ -11,6 +11,10 @@ export class DeviceRepository {
    return this.deviceRepository.findOne({ where: { deviceId, userId } });
  }

+  findByDeviceId(deviceId: string) {
+    return this.deviceRepository.findOne({ where: { deviceId } });
+  }
+
  createDevice(data: Partial<Device>) {
    return this.deviceRepository.save(data);
  }
@ -22,4 +26,8 @@ export class DeviceRepository {
  getTokens(userId: string) {
    return this.deviceRepository.find({ where: { userId, fcmToken: Not(IsNull()) }, select: ['fcmToken'] });
  }
+
+  findUserDevices(userId: string) {
+    return this.deviceRepository.find({ where: { userId } });
+  }
 }
--- a/src/user/services/device.service.ts
+++ b/src/user/services/device.service.ts
@ -10,6 +10,11 @@ export class DeviceService {
    return this.deviceRepository.findUserDeviceById(deviceId, userId);
  }

+  findByDeviceId(deviceId: string) {
+    this.logger.log(`Finding device with id ${deviceId} (any user)`);
+    return this.deviceRepository.findByDeviceId(deviceId);
+  }
+
  createDevice(data: Partial<Device>) {
    this.logger.log(`Creating device with data ${JSON.stringify(data)}`);
    return this.deviceRepository.createDevice(data);
@ -26,4 +31,9 @@ export class DeviceService {

    return devices.map((device) => device.fcmToken!);
  }
+
+  findUserDevices(userId: string) {
+    this.logger.log(`Finding all devices for user ${userId}`);
+    return this.deviceRepository.findUserDevices(userId);
+  }
 }
--- a/src/user/services/user.service.ts
+++ b/src/user/services/user.service.ts
@ -1,9 +1,12 @@
 import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import { ConfigService } from '@nestjs/config';
 import * as bcrypt from 'bcrypt';
 import { FindOptionsWhere } from 'typeorm';
 import { Transactional } from 'typeorm-transactional';
 import { CountryIso } from '~/common/enums';
+import { NOTIFICATION_EVENTS } from '~/common/modules/notification/constants/event-names.constant';
+import { IProfileUpdatedEvent } from '~/common/modules/notification/interfaces/notification-events.interface';
 import { NotificationsService } from '~/common/modules/notification/services';
 import { OtpScope, OtpType } from '~/common/modules/otp/enums';
 import { OtpService } from '~/common/modules/otp/services';
@ -28,6 +31,7 @@ export class UserService {
    private readonly documentService: DocumentService,
    private readonly otpService: OtpService,
    private readonly ociService: OciService,
+    private readonly eventEmitter: EventEmitter2,
  ) {}

  async findUser(where: FindOptionsWhere<User> | FindOptionsWhere<User>[], includeSignedUrl = false) {
@ -131,22 +135,55 @@ export class UserService {

  async updateNotificationSettings(userId: string, data: UpdateNotificationsSettingsRequestDto, deviceId?: string) {
    this.logger.log(`Updating notification settings for user ${userId} with data ${JSON.stringify(data)}`);
-    if (data.isPushEnabled && !data.fcmToken) {
+    
+    const isPushEnabled = data.isPushEnabled ?? true;
+    
+    if (isPushEnabled && !data.fcmToken) {
      throw new BadRequestException('USER.FCM_TOKEN_REQUIRED');
    }

-    if (data.isPushEnabled && !deviceId) {
-      throw new BadRequestException('DEVICE_ID_REQUIRED');
-    }
+    if (isPushEnabled && data.fcmToken) {
+      let targetDeviceId = deviceId;

-    if (data.isPushEnabled && deviceId && data.fcmToken) {
-      await this.deviceService.updateDevice(deviceId, { fcmToken: data.fcmToken, userId });
+      if (!targetDeviceId) {
+        const userDevices = await this.deviceService.findUserDevices(userId);
+        if (userDevices.length > 0) {
+          targetDeviceId = userDevices[0].deviceId;
+          this.logger.log(`No deviceId provided, using first device: ${targetDeviceId}`);
+        } else {
+          targetDeviceId = `device-${userId}-${Date.now()}`;
+          this.logger.log(`No device found, creating new device: ${targetDeviceId}`);
+          await this.deviceService.createDevice({
+            deviceId: targetDeviceId,
+            userId,
+            fcmToken: data.fcmToken,
+            lastAccessOn: new Date(),
+          });
+        }
+      }
+
+      if (targetDeviceId) {
+        const existingDevice = await this.deviceService.findUserDeviceById(targetDeviceId, userId);
+        if (existingDevice) {
+          await this.deviceService.updateDevice(targetDeviceId, { fcmToken: data.fcmToken, userId });
+        } else {
+          const anyDevice = await this.deviceService.findByDeviceId(targetDeviceId);
+          if (anyDevice) {
+            await this.deviceService.updateDevice(targetDeviceId, { fcmToken: data.fcmToken, userId });
+          } else {
+            await this.deviceService.createDevice({
+              deviceId: targetDeviceId,
+              userId,
+              fcmToken: data.fcmToken,
+              lastAccessOn: new Date(),
+            });
+          }
+        }
+      }
    }

    await this.userRepository.update(userId, {
-      isPushEnabled: data.isPushEnabled,
-      isEmailEnabled: data.isEmailEnabled,
-      isSmsEnabled: data.isSmsEnabled,
+      isPushEnabled: isPushEnabled,
    });
  }

@ -216,6 +253,19 @@ export class UserService {
      }
      await this.customerService.updateCustomer(userId, customerData);
    }
+
+    const updatedUser = await this.findUserOrThrow({ id: userId });
+    const updatedFields = Object.keys(data).filter(key => (data as any)[key] !== undefined);
+    
+    if (updatedFields.length > 0) {
+      const event: IProfileUpdatedEvent = {
+        user: updatedUser,
+        updatedFields,
+        timestamp: new Date(),
+      };
+      this.eventEmitter.emit(NOTIFICATION_EVENTS.PROFILE_UPDATED, event);
+      this.logger.log(`Emitted PROFILE_UPDATED event for user ${userId}, updated fields: ${updatedFields.join(', ')}`);
+    }
  }

  async updateUserEmail(userId: string, email: string) {
@ -246,6 +296,15 @@ export class UserService {
      throw new BadRequestException('USER.NOT_FOUND');
    }

+    const updatedUser = await this.findUserOrThrow({ id: userId });
+    const event: IProfileUpdatedEvent = {
+      user: updatedUser,
+      updatedFields: ['email'],
+      timestamp: new Date(),
+    };
+    this.eventEmitter.emit(NOTIFICATION_EVENTS.PROFILE_UPDATED, event);
+    this.logger.log(`Emitted PROFILE_UPDATED event for user ${userId}, updated field: email`);
+
    return this.otpService.generateAndSendOtp({
      userId,
      recipient: email,
Author	SHA1	Message	Date
Abdalhamid Alhamad	2ab9554c0c	feat: add profile update notification handling for child users - Implemented logic to skip notifications for child users (roles.JUNIOR) when their profiles are updated, preventing unnecessary notifications to both child and parent. - Enhanced logging to indicate when notifications are skipped for child users.	2026-02-01 14:44:42 +03:00
Abdalhamid Alhamad	f5c3b03264	feat: enhance card service and transaction notification for shared account handling - Updated CardService to differentiate between shared and separate accounts during card control updates, optimizing balance allocation. - Enhanced TransactionNotificationListener to accurately reflect balance based on account structure for internal transfers and top-ups. - Improved logging for better traceability of account operations and balance calculations.	2026-01-20 16:27:32 +03:00
Abdalhamid Alhamad	a09b84e475	feat: enhance transaction notification listener for internal transfer support - Updated TransactionNotificationListener to differentiate between internal transfers and external top-ups for child accounts. - Added new notification scopes and messages for internal transfers from parent to child. - Improved balance retrieval logic to ensure accurate account balances are displayed in notifications. - Enhanced localization support by adding relevant keys for internal transfer notifications in both English and Arabic.	2026-01-20 15:20:58 +03:00
Abdalhamid Alhamad	4305c4b75f	fix the messages	2026-01-20 14:40:16 +03:00
Abdalhamid Alhamad	7c9e0f0b51	feat: refine transaction notification listener for improved balance calculations - Updated TransactionNotificationListener to differentiate between child top-up and spending notifications, ensuring accurate balance retrieval. - Enhanced error handling and fallback mechanisms for both child and parent account balance fetching. - Improved logging to provide detailed insights into balance calculations, including available balance after accounting for reserved amounts.	2026-01-14 16:56:22 +03:00
Abdalhamid Alhamad	1086166e04	feat: improve transaction notification listener for accurate balance retrieval - Enhanced TransactionNotificationListener to fetch updated balances for child and parent accounts by bypassing entity cache. - Implemented error handling and fallback mechanisms to ensure reliable balance notifications. - Updated logging for better traceability of balance fetching processes.	2026-01-14 16:31:47 +03:00
Abdalhamid Alhamad	6d6dc1471f	feat: add timezone support to user and device entities - Introduced optional timezone fields in User and Device entities to store user preferences and device timezones. - Updated request DTOs for login and user updates to include timezone information. - Enhanced AuthService to handle timezone during device registration and updates. - Added migration to incorporate timezone fields in the database schema.	2026-01-14 16:12:08 +03:00
Abdalhamid Alhamad	1b0d6cb284	feat: enhance card and transaction services for balance updates - Added functionality to credit child account balance and decrease parent account balance in CardService. - Updated TransactionService to reload card details for accurate balance after transactions. - Improved TransactionNotificationListener to fetch updated balances for both child and parent accounts, ensuring accurate notifications.	2026-01-14 14:51:45 +03:00
Abdalhamid Alhamad	c963b57904	feat: enhance card service validation and notification integration - Added validation for card reference and limit in CardService to ensure data integrity. - Improved error handling with detailed logging for invalid card states. - Updated transaction notification listener to fetch parent account details and adjust balance notifications accordingly. - Enhanced notification creation process to include status management for better tracking.	2026-01-14 13:27:02 +03:00
Abdalhamid Alhamad	145e6c62b8	feat: implement KYC and card notification events - Added KycNotificationListener to handle notifications for KYC approval and rejection events. - Introduced CardNotificationListener to manage notifications for card creation and blocking events. - Enhanced CardService to emit events for card creation and blocking, integrating with the new notification system. - Updated notification constants and interfaces to include new KYC and card-related events. - Improved notification message formatting and added localization support for new events.	2026-01-14 12:31:48 +03:00
Abdalhamid Alhamad	45acf73a4a	feat: enhance transaction notification logging and error handling - Added console logging for emitted transaction creation events in TransactionService. - Improved error handling in TransactionNotificationListener for i18n translation failures, providing fallback messages. - Updated amount parsing in MoneyRequestNotificationListener to ensure consistent handling of string and numeric values.	2026-01-12 16:47:28 +03:00
Abdalhamid Alhamad	d3ff755439	refactor: standardize notification message formatting - Updated notification message arguments to use consistent object syntax for better readability. - Modified Arabic and English translation files to reflect the new argument format in notification messages.	2026-01-12 16:28:26 +03:00
Abdalhamid Alhamad	21653efc46	feat: implement money request notification system - Added MoneyRequestNotificationListener to handle notifications for money request events (created, approved, declined). - Introduced new notification event constants for money requests. - Updated notification interfaces to include money request event payloads. - Enhanced existing notification system to support money request notifications, notifying parents and children appropriately. - Updated device service to support finding devices by ID for improved functionality.	2026-01-12 16:07:48 +03:00
Abdalhamid Alhamad	63b0a42eca	feat: enhance Redis module exports for pub/sub functionality - Added 'REDIS_PUBLISHER' and 'REDIS_SUBSCRIBER' to the exports of RedisModule to improve pub/sub capabilities.	2026-01-11 14:38:59 +03:00
Abdalhamid Alhamad	b1cda5e7dc	feat: Complete Phase 2 notification system implementation - Implement messaging system factory pattern - Fix all transaction notification blockers - Complete listener logic for all notification types	2026-01-11 11:17:08 +03:00
Abdalhamid Alhamad	2c8de913f8	refactor: update notification titles and enhance notification creation process - Simplified notification titles by removing emojis for better clarity. - Modified createNotification method to include automatic publishing to Redis, improving notification delivery. - Updated email and OTP notification methods to leverage the new createNotification functionality.	2026-01-06 16:22:21 +03:00