Data Caching Implementation Example: Notifications from S/4HANA

Scenario

A Supplier Portal requires real-time notifications from SAP S/4HANA to inform users about important events such as RFQ updates, purchase order approvals, invoice payment statuses, and delivery delays. Notifications need to be delivered instantly, cached for quick access, and managed with an efficient expiry policy to prevent clutter.

---

Objective

• Cache notifications locally for quick access while maintaining real-time delivery from S/4HANA.
• Ensure notifications are stored temporarily, with an expiry policy to remove outdated items.
• Optimize notification delivery by minimizing API calls and leveraging event-driven mechanisms.

---

Steps for Implementation

Step 1: Identify Notification Types

Key notification types for the portal:

• RFQ Notifications:
  • New RFQs, updates, or cancellations.
• Purchase Order Notifications:
  • Approval, rejection, or modification of POs.
• Invoice Notifications:
  • Payment status updates (paid, overdue).
• Delivery Notifications:
  • Shipment delays, completed deliveries, or quality issues.

---

Step 2: Design the Cache Database

Define database tables to store notifications. Use an in-memory store like Redis for faster access or a local relational database for persistence.

Notifications Table:

CREATE TABLE Notifications (
    NotificationID SERIAL PRIMARY KEY,
    Type VARCHAR(50),
    Title VARCHAR(255),
    Message TEXT,
    ReferenceID VARCHAR(20),
    CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    ExpiryAt TIMESTAMP,
    IsRead BOOLEAN DEFAULT FALSE
);

---

Step 3: Fetch Notifications from S/4HANA

Use SAP Event Mesh or OData APIs to fetch notifications. Event-driven mechanisms are preferred for real-time notifications.

Event Mesh Setup:

• Configure S/4HANA to publish events to SAP Event Mesh.
• Subscribe to relevant topics (e.g., /po/approved, /invoice/paid).

API Example for Notifications:

GET /sap/opu/odata/sap/API_NOTIFICATION_SRV/A_Notifications

---

Step 4: Load Notifications into the Cache

Fetch notifications in real time or on-demand, and store them in the cache.

Example Node.js Code for Event-Driven Notifications:

const axios = require('axios');
const { Pool } = require('pg');

// Database connection pool
const pool = new Pool({
  user: 'username',
  host: 'localhost',
  database: 'supplier_portal',
  password: 'password',
  port: 5432,
});

// Mock function to simulate event listener
async function handleNotificationEvent(event) {
  const { type, title, message, referenceId, expiryAt } = event;

  const client = await pool.connect();
  try {
    await client.query(`
      INSERT INTO Notifications (Type, Title, Message, ReferenceID, ExpiryAt)
      VALUES ($1, $2, $3, $4, $5)
    `, [type, title, message, referenceId, expiryAt]);
  } catch (error) {
    console.error('Error inserting notification:', error.message);
  } finally {
    client.release();
  }
}

// Simulate receiving a notification event
const event = {
  type: 'Purchase Order',
  title: 'Purchase Order Approved',
  message: 'Your PO #12345 has been approved.',
  referenceId: 'PO12345',
  expiryAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
};
handleNotificationEvent(event);

---

Step 5: Schedule Expiry and Cleanup Jobs

Set up a periodic job to remove expired notifications and prevent clutter.

Example Cleanup Job in Node.js:

async function cleanupExpiredNotifications() {
  const client = await pool.connect();
  try {
    await client.query(`
      DELETE FROM Notifications WHERE ExpiryAt < NOW();
    `);
  } catch (error) {
    console.error('Error cleaning up notifications:', error.message);
  } finally {
    client.release();
  }
}

// Schedule cleanup job (e.g., every hour)
setInterval(cleanupExpiredNotifications, 60 * 60 * 1000); // Run every hour

---

Step 6: Monitor and Validate Notifications

1. Monitoring:
   • Log notification delivery and cache updates.
   • Track errors in event handling or API calls.
2. Validation:
   • Periodically verify that cached notifications match S/4HANA records.
   • Check that expired notifications are removed correctly.

---

Best Practices

1. Use Event-Driven Mechanisms:
   • Prefer real-time notifications through SAP Event Mesh or message brokers (e.g., Kafka).
   • Example: Trigger an event when a PO is approved to notify suppliers instantly.
2. Set Expiry Policies:
   • Define TTL for each notification type to ensure timely removal.
   • Example: Notifications for payment reminders expire after 7 days.
3. Prioritize Unread Notifications:
   • Display unread notifications prominently in the portal.
   • Example: Highlight unread notifications with a badge or alert.
4. Implement Categorization:
   • Tag notifications by type (e.g., RFQ, PO, Invoice) for easier filtering and sorting.
5. Secure Sensitive Notifications:
   • Encrypt sensitive notification messages and apply access controls.

---

Example Use Case: Supplier Portal

Scenario:

The Supplier Portal delivers notifications for events like:

• New RFQs issued by the organization.
• Purchase orders requiring action.
• Invoices marked as overdue.

Workflow:

1. Organization publishes events (e.g., /po/approved) to SAP Event Mesh.
2. Supplier Portal listens to subscribed topics and caches notifications locally.
3. Notifications are displayed in the portal’s “My Messages” section.
4. Expired notifications are cleaned up periodically.

Benefits:

• Instant delivery of critical updates to suppliers.
• Efficient access to notifications through local caching.
• Reduced dependency on real-time API calls.

---

Conclusion

Caching notifications from S/4HANA ensures efficient delivery and access to critical updates for users in integration scenarios. Event-driven mechanisms like SAP Event Mesh provide real-time updates, while caching improves performance and reduces backend dependency. Proper expiry policies, monitoring, and validation ensure the notification system remains efficient, consistent, and clutter-free.