joelthomastrenser
82164e42c3
Changes: - Added authorization state tracking to authenticated sessions. - Revoked authorization immediately when an account-disabled event is received. - Added authorization validation before protected service operations. - Cleared authorization state on logout. Fixes #2078
345 lines
12 KiB
C++
345 lines
12 KiB
C++
/*
|
||
File: PaymentManagementService.cpp
|
||
Description: Implements the PaymentManagementService class which manages payment-related operations
|
||
in the Vehicle Service Management System. Provides functionality for attaching/detaching observers,
|
||
sending notifications, and issuing payment reminders based on invoice status and thresholds.
|
||
Author: Trenser
|
||
Date: 20-May-2026
|
||
*/
|
||
|
||
#include <stdexcept>
|
||
#include "Config.h"
|
||
#include "Enums.h"
|
||
#include "Factory.h"
|
||
#include "InventoryItem.h"
|
||
#include "Invoice.h"
|
||
#include "JobCard.h"
|
||
#include "PaymentManagementService.h"
|
||
#include "AuthenticationManagementService.h"
|
||
#include "DataStoreLockGuard.h"
|
||
#include "Service.h"
|
||
#include "ServiceBooking.h"
|
||
#include "Timestamp.h"
|
||
#include "User.h"
|
||
#include "Utility.h"
|
||
#include "DataStoreLockGuard.h"
|
||
#include "EventManager.h"
|
||
|
||
util::Map<std::string, User*> PaymentManagementService::m_observers{};
|
||
|
||
/*
|
||
Function: attach
|
||
Description: Attaches a user as an observer to the PaymentManagementService for receiving notifications.
|
||
Parameters:
|
||
- user: Pointer to the User object to be attached.
|
||
Returns:
|
||
- void
|
||
*/
|
||
void PaymentManagementService::attach(User* user)
|
||
{
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
m_observers.clear();
|
||
m_observers = m_dataStore.getPaymentManagementObservers();
|
||
if (user)
|
||
{
|
||
const std::string& userID = user->getId();
|
||
if (m_observers.find(userID) == -1)
|
||
{
|
||
m_observers[userID] = user;
|
||
}
|
||
}
|
||
m_dataStore.savePaymentManagementObservers(m_observers);
|
||
}
|
||
|
||
/*
|
||
Function: detach
|
||
Description: Detaches a user from the observer list of the PaymentManagementService.
|
||
Parameters:
|
||
- user: Pointer to the User object to be detached.
|
||
Returns:
|
||
- void
|
||
*/
|
||
void PaymentManagementService::detach(User* user)
|
||
{
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
m_observers.clear();
|
||
m_observers = m_dataStore.getPaymentManagementObservers();
|
||
if (user)
|
||
{
|
||
const std::string& userID = user->getId();
|
||
if (m_observers.find(userID) != -1)
|
||
{
|
||
m_observers.remove(userID);
|
||
}
|
||
}
|
||
m_dataStore.savePaymentManagementObservers(m_observers);
|
||
}
|
||
|
||
/*
|
||
Function: sendNotification
|
||
Description: Sends a notification to a user if they are registered as an observer.
|
||
Parameters:
|
||
- user: Pointer to the User object to receive the notification.
|
||
- title: Title of the notification.
|
||
- message: Message content of the notification.
|
||
Returns:
|
||
- void
|
||
Throws:
|
||
- std::runtime_error if notification creation fails.
|
||
*/
|
||
void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
|
||
{
|
||
if (!user)
|
||
{
|
||
return;
|
||
}
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
m_observers = m_dataStore.getPaymentManagementObservers();
|
||
if (m_observers.find(user->getId()) == -1)
|
||
{
|
||
return;
|
||
}
|
||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||
Notification* notification = Factory::getObject<Notification>(
|
||
user->getId(),
|
||
title,
|
||
message,
|
||
util::Timestamp());
|
||
if (!notification)
|
||
{
|
||
throw std::runtime_error("Failed to create notification");
|
||
}
|
||
trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
|
||
m_dataStore.saveNotifications();
|
||
EventManager::sendNotificationAvailableEvent(user->getId());
|
||
}
|
||
|
||
/*
|
||
Function: sendPaymentReminders
|
||
Description: Iterates through all invoices in the datastore and sends payment reminders to customers
|
||
whose invoices are pending beyond the configured threshold duration.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void PaymentManagementService::sendPaymentReminders()
|
||
{
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
auto& trackedInvoicesMap = m_dataStore.getInvoices();
|
||
int invoicesMapSize = trackedInvoicesMap.getSize();
|
||
for (int index = 0; index < invoicesMapSize; index++)
|
||
{
|
||
const Invoice* invoice = trackedInvoicesMap.getValueAt(index).data;
|
||
if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
|
||
{
|
||
util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
|
||
util::Timestamp currentTimestamp;
|
||
if (util::Timestamp::getDurationInHours(invoiceCreationTimestamp, currentTimestamp) >= config::threshold::PAYMENT_REMINDER_THRESHOLD_HOURS)
|
||
{
|
||
const ServiceBooking* serviceBooking = invoice->getBooking();
|
||
if (serviceBooking)
|
||
{
|
||
User* customer = serviceBooking->getCustomer();
|
||
if (customer)
|
||
{
|
||
std::string title = "Payment Reminder";
|
||
std::string message = "Your payment for Invoice ID " + invoice->getId() + " is still pending. Please complete the payment.";
|
||
sendNotification(customer, title, message);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/*
|
||
Function: createInventoryItemsMap (static helper)
|
||
Description: Builds a map of inventory items required for a given service and adds them to the booking’s inventory map.
|
||
Parameters:
|
||
- completeInventoryItemMapOfBooking: util::Map<std::string, InventoryItem*>&, map to store inventory items for the booking
|
||
- currentService: const Service*, pointer to the current service
|
||
Returns:
|
||
- void
|
||
*/
|
||
static void createInventoryItemsMap(util::Map<std::string, InventoryItem*>& completeInventoryItemMapOfBooking, const Service* currentService)
|
||
{
|
||
auto& currentRequiredInventoryItems = currentService->getRequiredInventoryItems();
|
||
for (int iterator = 0; iterator < currentRequiredInventoryItems.getSize(); iterator++)
|
||
{
|
||
auto& currentRequiredInventoryItem = currentRequiredInventoryItems.getValueAt(iterator);
|
||
completeInventoryItemMapOfBooking.insert(currentRequiredInventoryItem->getId(), currentRequiredInventoryItem);
|
||
}
|
||
}
|
||
|
||
/*
|
||
Function: generateInvoice
|
||
Description: Generates an invoice for a completed service booking.
|
||
Validates that all job cards are completed, calculates labor and parts cost, applies discount,
|
||
and stores the invoice in the datastore.
|
||
Parameters:
|
||
- booking: ServiceBooking*, pointer to the service booking
|
||
Returns:
|
||
- void
|
||
Throws:
|
||
- std::runtime_error if booking is null or job cards are incomplete
|
||
*/
|
||
void PaymentManagementService::generateInvoice(ServiceBooking* booking)
|
||
{
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
if (!booking)
|
||
{
|
||
throw std::runtime_error("Invoice generation failed: booking is null.");
|
||
}
|
||
double totalLaborCost = 0, totalPartsCost = 0, totalServiceCost = 0;
|
||
double discountPercentage = booking->getDiscountPercentage();
|
||
std::string bookingID = booking->getId();
|
||
util::Map<std::string, Service*> servicesInTheBookedService = booking->getServices();
|
||
util::Map<std::string, InventoryItem*> completeInventoryItemMapOfBooking;
|
||
auto& currentTrackedJobCards = m_dataStore.getJobCards();
|
||
for (int iterator = 0; iterator < currentTrackedJobCards.getSize(); iterator++)
|
||
{
|
||
JobCard* currentJobCard = currentTrackedJobCards.getValueAt(iterator).data;
|
||
util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
|
||
if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
|
||
{
|
||
throw std::runtime_error("Invoice generation failed: Not all job cards are completed for booking '" + bookingID + "'.");
|
||
}
|
||
}
|
||
for (int iterator = 0; iterator < servicesInTheBookedService.getSize(); iterator++)
|
||
{
|
||
Service* currentService = servicesInTheBookedService.getValueAt(iterator);
|
||
if (currentService)
|
||
{
|
||
createInventoryItemsMap(completeInventoryItemMapOfBooking, currentService);
|
||
totalLaborCost += currentService->getLaborCost();
|
||
totalPartsCost += util::calculatePartsCost(currentService);
|
||
}
|
||
}
|
||
totalServiceCost = totalLaborCost + totalPartsCost;
|
||
totalServiceCost -= (totalServiceCost * (discountPercentage / 100));
|
||
Invoice* invoice = Factory::getObject<Invoice>(bookingID, booking, util::Timestamp(), totalLaborCost, completeInventoryItemMapOfBooking, totalPartsCost, discountPercentage, totalServiceCost, util::Timestamp(), util::PaymentMode::NOTSET, util::PaymentStatus::PENDING);
|
||
auto& currentTrackedInvoices = m_dataStore.getInvoices();
|
||
currentTrackedInvoices.insert(invoice->getId(), util::createNewRecord(invoice));
|
||
m_dataStore.saveInvoices();
|
||
}
|
||
|
||
/*
|
||
Function: getInvoices
|
||
Description: Retrieves all invoices associated with a specific customer.
|
||
Parameters:
|
||
- customerID: std::string, ID of the customer
|
||
Returns:
|
||
- util::Map<std::string, Invoice*> containing the customer’s invoices
|
||
*/
|
||
util::Map<std::string, Invoice*> PaymentManagementService::getInvoices(const std::string& customerID)
|
||
{
|
||
AuthenticationManagementService::ensureAuthorization();
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
auto& currentTrackedInvoices = m_dataStore.getInvoices();
|
||
util::Map<std::string, Invoice*> currentUserInvoices;
|
||
for (int iterator = 0; iterator < currentTrackedInvoices.getSize(); iterator++)
|
||
{
|
||
Invoice* currentInvoice = currentTrackedInvoices.getValueAt(iterator).data;
|
||
if (currentInvoice->getBooking()->getCustomerId() == customerID)
|
||
{
|
||
currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
|
||
}
|
||
}
|
||
return currentUserInvoices;
|
||
}
|
||
|
||
/*
|
||
Function: completePayment
|
||
Description: Completes payment for a specific invoice. Updates payment method, date, and status,
|
||
then sends a notification to the customer.
|
||
Parameters:
|
||
- invoiceID: std::string, ID of the invoice
|
||
- paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
|
||
Returns:
|
||
- void
|
||
Throws:
|
||
- std::runtime_error if the invoice ID is invalid
|
||
*/
|
||
void PaymentManagementService::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
|
||
{
|
||
AuthenticationManagementService::ensureAuthorization();
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
auto& currentTrackedInvoices = m_dataStore.getInvoices();
|
||
int invoiceIndex = currentTrackedInvoices.find(invoiceID);
|
||
if (invoiceIndex != -1)
|
||
{
|
||
auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
|
||
Invoice* invoice = trackedInvoice.data;
|
||
if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
|
||
{
|
||
User* currentUser = invoice->getBooking()->getCustomer();
|
||
invoice->setPaymentMethod(paymentMode);
|
||
invoice->setPaymentDate(util::Timestamp());
|
||
invoice->setStatus(util::PaymentStatus::PAID);
|
||
std::string title, message;
|
||
title = "Payment successful";
|
||
message = "Payment successful for Invoice ID " + invoiceID;
|
||
sendNotification(currentUser, title, message);
|
||
trackedInvoice.state = RecordState::MODIFIED;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
throw std::runtime_error("Payment failed: invalid invoice ID.");
|
||
}
|
||
m_dataStore.saveInvoices();
|
||
}
|
||
|
||
/*
|
||
Function: getAllInvoices
|
||
Description: Provides access to all invoices stored in the data store.
|
||
Parameters:
|
||
- none
|
||
Returns:
|
||
- util::Map<std::string, Invoice*>: Map of invoice IDs to invoice objects
|
||
*/
|
||
util::Map<std::string, Invoice*> PaymentManagementService::getAllInvoices()
|
||
{
|
||
AuthenticationManagementService::ensureAuthorization();
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
util::Map<std::string, Invoice*> invoices;
|
||
invoices = util::getObjects(m_dataStore.getInvoices());
|
||
return invoices;
|
||
}
|
||
|
||
/*
|
||
Function: confirmPayment
|
||
Description: Confirms payment for a specific invoice. Updates payment date and status,
|
||
then sends a notification to the customer.
|
||
Parameters:
|
||
- invoiceID: std::string, ID of the invoice to confirm
|
||
Returns:
|
||
- void
|
||
Throws:
|
||
- std::runtime_error if the invoice ID is invalid
|
||
*/
|
||
void PaymentManagementService::confirmPayment(const std::string& invoiceID)
|
||
{
|
||
AuthenticationManagementService::ensureAuthorization();
|
||
DataStoreLockGuard lock(m_dataStore);
|
||
auto& currentTrackedInvoices = m_dataStore.getInvoices();
|
||
int invoiceIndex = currentTrackedInvoices.find(invoiceID);
|
||
if (invoiceIndex == -1)
|
||
{
|
||
throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
|
||
}
|
||
auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
|
||
Invoice* invoice = trackedInvoice.data;
|
||
if (!invoice || invoice->getStatus() != util::PaymentStatus::PAID)
|
||
{
|
||
throw std::runtime_error("Payment confirmation failed: invoice is not awaiting confirmation.");
|
||
}
|
||
User* currentUser = invoice->getBooking()->getCustomer();
|
||
invoice->setStatus(util::PaymentStatus::COMPLETED);
|
||
trackedInvoice.state = RecordState::MODIFIED;
|
||
std::string title = "Payment Confirmed";
|
||
std::string message = "Payment Confirmed for Invoice ID " + invoiceID;
|
||
sendNotification(currentUser, title, message);
|
||
m_dataStore.saveInvoices();
|
||
} |