Compare commits
6 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 joelthomastrenser
|
dbc9abae6c | ||
|
joelthomastrenser
|
9752a76cb2 | ||
|
joelthomastrenser
|
505753cc77 | ||
|
joelthomastrenser
|
384a9b05b1 | ||
|
joelthomastrenser
|
e054076175 | ||
|
joelthomastrenser
|
329fc6e23f |
+1
-7
@@ -153,12 +153,9 @@
|
||||
<ClCompile Include="core\sharedmemory\SharedMemory.cpp">
|
||||
<Filter>Source Files\Core\SharedMemory</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="core\events\EventManager.cpp">
|
||||
<ClCompile Include="EventManager.cpp">
|
||||
<Filter>Source Files\Core\Events</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="views\Menu.cpp">
|
||||
<Filter>Source Files\Views</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="utilities\InputHelper.h">
|
||||
@@ -290,8 +287,5 @@
|
||||
<ClInclude Include="core\events\EventManager.h">
|
||||
<Filter>Header Files\Core\Events</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="views\Menu.h">
|
||||
<Filter>Header Files\Views</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -234,17 +234,6 @@ void Controller::removeInventoryItem(const std::string& inventoryItemID)
|
||||
m_inventoryManagementService.removeInventoryItem(inventoryItemID);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: removeServiceBooking
|
||||
Description: Removes a service booking from the service management system by its booking ID.
|
||||
Parameter: const std::string& bookingID - ID of the service booking
|
||||
Return type: void
|
||||
*/
|
||||
void Controller::removeServiceBooking(const std::string& bookingID)
|
||||
{
|
||||
m_serviceManagementService.removeServiceBooking(bookingID);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: addInventoryItemStock
|
||||
Description: Adds stock to an existing inventory item in the inventory management service.
|
||||
@@ -276,7 +265,6 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
|
||||
return readOnlyServiceBookings;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Function: getServiceBookingsByUser
|
||||
Description: Retrieves all service bookings for a specific user.
|
||||
@@ -635,14 +623,6 @@ void Controller::shutdown()
|
||||
dataStore.shutdown();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: registerEvents
|
||||
Description: Registers menu event handles with the authentication
|
||||
service.
|
||||
Parameter: HANDLE accountDisabledEvent - account disabled event handle
|
||||
HANDLE notificationAvailableEvent - notification event handle
|
||||
Return type: void
|
||||
*/
|
||||
void Controller::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
|
||||
{
|
||||
m_authenticationManagementService.registerEvents(accountDisabledEvent, notificationAvailableEvent);
|
||||
|
||||
@@ -58,7 +58,6 @@ public:
|
||||
util::Map<std::string, const User*> getUsers(util::UserType userType);
|
||||
void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
|
||||
void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
|
||||
void removeServiceBooking(const std::string& bookingID);
|
||||
void removeService(const std::string& serviceID);
|
||||
util::Map<std::string, const JobCard*> getJobCardsByUser();
|
||||
void updateJobStatus(const std::string& jobID);
|
||||
|
||||
@@ -415,7 +415,7 @@ util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
|
||||
{
|
||||
throw std::runtime_error("Invalid booking ID: " + bookingId);
|
||||
}
|
||||
auto& trackedBooking = serviceBookings.getValueAt(bookingIndex);
|
||||
auto trackedBooking = serviceBookings.getValueAt(bookingIndex);
|
||||
jobCard->setBooking(trackedBooking.data);
|
||||
const std::string& serviceId = jobCard->getServiceId();
|
||||
int serviceIndex = services.find(serviceId);
|
||||
|
||||
@@ -220,12 +220,6 @@ void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cac
|
||||
if (oldIndex != -1)
|
||||
{
|
||||
TrackedRecord<TObject>& oldRecord = oldCache.getValueAt(oldIndex);
|
||||
if (oldRecord.state == RecordState::MODIFIED)
|
||||
{
|
||||
delete refreshedRecord.data;
|
||||
cache.insert(id, oldRecord);
|
||||
continue;
|
||||
}
|
||||
*oldRecord.data = *refreshedRecord.data;
|
||||
oldRecord.slotIndex = refreshedRecord.slotIndex;
|
||||
oldRecord.state = refreshedRecord.state;
|
||||
|
||||
+4
-33
@@ -8,35 +8,17 @@ Date:19-May-2026
|
||||
*/
|
||||
|
||||
#include <stdexcept>
|
||||
#include <iostream>
|
||||
#include "AuthenticationManagementService.h"
|
||||
#include "User.h"
|
||||
#include "Utility.h"
|
||||
#include "DataStoreLockGuard.h"
|
||||
|
||||
User* AuthenticationManagementService::m_authenticatedUser = nullptr;
|
||||
bool AuthenticationManagementService::m_isAuthorized = false;
|
||||
EventManager AuthenticationManagementService::m_eventManager;
|
||||
HANDLE AuthenticationManagementService::m_accountDisabledEvent = NULL;
|
||||
HANDLE AuthenticationManagementService::m_notificationsAvailableEvent = NULL;
|
||||
|
||||
|
||||
/*
|
||||
Function: ensureAuthorization
|
||||
Description: Verifies that a user is currently authenticated before allowing
|
||||
access to a protected operation. Throws an exception if no
|
||||
authorized user session exists.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
Throws: std::runtime_error - if the user is not authorized
|
||||
*/
|
||||
void AuthenticationManagementService::ensureAuthorization()
|
||||
{
|
||||
if (!m_authenticatedUser || !m_isAuthorized)
|
||||
{
|
||||
throw std::runtime_error("You are not authorized to do this operation!");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: login
|
||||
Description: Authenticates a user by checking the provided username and password
|
||||
@@ -59,19 +41,18 @@ bool AuthenticationManagementService::login(const std::string& username, const s
|
||||
if (password == user->getPassword())
|
||||
{
|
||||
m_authenticatedUser = user;
|
||||
m_isAuthorized = true;
|
||||
m_eventManager.initialize(
|
||||
user->getId(),
|
||||
[]()
|
||||
{
|
||||
if (m_accountDisabledEvent)
|
||||
{
|
||||
AuthenticationManagementService::m_isAuthorized = false;
|
||||
SetEvent(m_accountDisabledEvent);
|
||||
}
|
||||
},
|
||||
[]()
|
||||
{
|
||||
HANDLE eventHandle = OpenEventA(EVENT_MODIFY_STATE, FALSE, "VehicleServiceSystem_NotificationAvailable");
|
||||
if (m_notificationsAvailableEvent)
|
||||
{
|
||||
SetEvent(m_notificationsAvailableEvent);
|
||||
@@ -107,7 +88,6 @@ void AuthenticationManagementService::logout()
|
||||
{
|
||||
m_eventManager.shutdown();
|
||||
m_authenticatedUser = nullptr;
|
||||
m_isAuthorized = false;
|
||||
m_accountDisabledEvent = NULL;
|
||||
m_notificationsAvailableEvent = NULL;
|
||||
}
|
||||
@@ -121,7 +101,6 @@ Return type: void
|
||||
*/
|
||||
void AuthenticationManagementService::changePassword(const std::string& newPassword)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
if (m_authenticatedUser == nullptr)
|
||||
@@ -138,16 +117,8 @@ void AuthenticationManagementService::changePassword(const std::string& newPassw
|
||||
m_dataStore.saveUsers();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: registerEvents
|
||||
Description: Registers menu event handles used to notify the active
|
||||
menu of account disable and notification events.
|
||||
Parameter: HANDLE accountDisabledEvent - account disabled event handle
|
||||
HANDLE notificationAvailableEvent - notification event handle
|
||||
Return type: void
|
||||
*/
|
||||
void AuthenticationManagementService::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
|
||||
void AuthenticationManagementService::registerEvents(HANDLE accountDisabledEvent, HANDLE notifictionAvailableEvent)
|
||||
{
|
||||
m_accountDisabledEvent = accountDisabledEvent;
|
||||
m_notificationsAvailableEvent = notificationAvailableEvent;
|
||||
m_notificationsAvailableEvent = notifictionAvailableEvent;
|
||||
}
|
||||
|
||||
-2
@@ -19,14 +19,12 @@ class AuthenticationManagementService
|
||||
{
|
||||
private:
|
||||
static User* m_authenticatedUser;
|
||||
static bool m_isAuthorized;
|
||||
static EventManager m_eventManager;
|
||||
static HANDLE m_accountDisabledEvent;
|
||||
static HANDLE m_notificationsAvailableEvent;
|
||||
DataStore& m_dataStore;
|
||||
public:
|
||||
AuthenticationManagementService() : m_dataStore(DataStore::getInstance()) {}
|
||||
static void ensureAuthorization();
|
||||
bool login(const std::string& username, const std::string& password);
|
||||
void logout();
|
||||
void changePassword(const std::string& newPassword);
|
||||
|
||||
+1
-7
@@ -14,7 +14,6 @@ Date: 22-May-2026
|
||||
#include "Factory.h"
|
||||
#include "InventoryItem.h"
|
||||
#include "InventoryManagementService.h"
|
||||
#include "AuthenticationManagementService.h"
|
||||
#include "Timestamp.h"
|
||||
#include "User.h"
|
||||
#include "Utility.h"
|
||||
@@ -103,7 +102,6 @@ Return type: void
|
||||
*/
|
||||
void InventoryManagementService::addInventoryItem(const std::string& partName, int quantity, double price)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
|
||||
InventoryItem* newItem = Factory::getObject<InventoryItem>(partName, quantity, price);
|
||||
@@ -120,7 +118,6 @@ Return type: void
|
||||
*/
|
||||
void InventoryManagementService::addInventoryItemStock(const std::string& selectedItemId, int quantity)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
|
||||
int index = trackedInventoryItemMap.find(selectedItemId);
|
||||
@@ -147,7 +144,6 @@ Return type: util::Map<std::string, InventoryItem*>
|
||||
*/
|
||||
util::Map<std::string, InventoryItem*> InventoryManagementService::getInventoryItems()
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
|
||||
auto inventoryMap = util::getObjects(trackedInventoryItemMap);
|
||||
@@ -162,7 +158,6 @@ Return type: void
|
||||
*/
|
||||
void InventoryManagementService::removeInventoryItem(const std::string& inventoryItemID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
|
||||
int index = trackedInventoryItemMap.find(inventoryItemID);
|
||||
@@ -188,7 +183,6 @@ Return type: InventoryItem*
|
||||
*/
|
||||
InventoryItem* InventoryManagementService::getInventoryItem(const std::string& inventoryItemID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedInventoryItemMap = m_dataStore.getInventoryItems();
|
||||
int index = trackedInventoryItemMap.find(inventoryItemID);
|
||||
@@ -276,7 +270,6 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
|
||||
{
|
||||
return;
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
Notification* notification = Factory::getObject<Notification>(
|
||||
user->getId(),
|
||||
title,
|
||||
@@ -286,6 +279,7 @@ void InventoryManagementService::sendNotification(User* user, const std::string&
|
||||
{
|
||||
throw std::runtime_error("Failed to create notification");
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
|
||||
m_dataStore.saveNotifications();
|
||||
EventManager::sendNotificationAvailableEvent(user->getId());
|
||||
|
||||
+2
-7
@@ -15,7 +15,6 @@ Date: 20-May-2026
|
||||
#include "Invoice.h"
|
||||
#include "JobCard.h"
|
||||
#include "PaymentManagementService.h"
|
||||
#include "AuthenticationManagementService.h"
|
||||
#include "DataStoreLockGuard.h"
|
||||
#include "Service.h"
|
||||
#include "ServiceBooking.h"
|
||||
@@ -99,7 +98,6 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
|
||||
{
|
||||
return;
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
Notification* notification = Factory::getObject<Notification>(
|
||||
user->getId(),
|
||||
title,
|
||||
@@ -109,6 +107,7 @@ void PaymentManagementService::sendNotification(User* user, const std::string& t
|
||||
{
|
||||
throw std::runtime_error("Failed to create notification");
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
|
||||
m_dataStore.saveNotifications();
|
||||
EventManager::sendNotificationAvailableEvent(user->getId());
|
||||
@@ -234,7 +233,6 @@ Returns:
|
||||
*/
|
||||
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;
|
||||
@@ -263,7 +261,6 @@ Throws:
|
||||
*/
|
||||
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);
|
||||
@@ -292,7 +289,7 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getAllInvoices
|
||||
Function: getAllInvoice
|
||||
Description: Provides access to all invoices stored in the data store.
|
||||
Parameters:
|
||||
- none
|
||||
@@ -301,7 +298,6 @@ Returns:
|
||||
*/
|
||||
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());
|
||||
@@ -321,7 +317,6 @@ Throws:
|
||||
*/
|
||||
void PaymentManagementService::confirmPayment(const std::string& invoiceID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& currentTrackedInvoices = m_dataStore.getInvoices();
|
||||
int invoiceIndex = currentTrackedInvoices.find(invoiceID);
|
||||
|
||||
+43
-163
@@ -26,33 +26,9 @@ Date:19-May-2026
|
||||
#include "UserManagementService.h"
|
||||
#include "DataStoreLockGuard.h"
|
||||
#include "Utility.h"
|
||||
#include "DataStoreLockGuard.h"
|
||||
#include "EventManager.h"
|
||||
|
||||
/*
|
||||
Function: notifyAllAdmins
|
||||
Description: Sends a notification to all users with the ADMIN role.
|
||||
Iterates through the provided user collection and delivers
|
||||
the specified notification to each administrator using the
|
||||
ServiceManagementService notification mechanism.
|
||||
Parameter: const std::string& title - notification title
|
||||
Parameter: const std::string& message - notification message
|
||||
Parameter: const util::Map<std::string, TrackedRecord<User>>& users - collection of tracked users
|
||||
Parameter: ServiceManagementService* serviceManagementService - service used to dispatch notifications
|
||||
Return type: void
|
||||
*/
|
||||
static void notifyAllAdmins(const std::string& title, const std::string& message, const util::Map<std::string, TrackedRecord<User>>& users, ServiceManagementService* serviceManagementService)
|
||||
{
|
||||
int numberOfUsers = users.getSize();
|
||||
for (int index = 0; index < numberOfUsers; index++)
|
||||
{
|
||||
User* user = users.getValueAt(index).data;
|
||||
if (user->getUserType() == util::UserType::ADMIN)
|
||||
{
|
||||
serviceManagementService->sendNotification(user, title, message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: purchaseService
|
||||
Description: Creates a new service booking for the authenticated user. Validates
|
||||
@@ -66,7 +42,6 @@ Return type: void
|
||||
*/
|
||||
void ServiceManagementService::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
AuthenticationManagementService m_authenticationManagementService;
|
||||
auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
|
||||
if (authenticatedUser == nullptr)
|
||||
@@ -97,8 +72,6 @@ void ServiceManagementService::purchaseService(const util::Vector<std::string>&
|
||||
std::string title = "Service Booking succeeded";
|
||||
std::string message = "Your service booking has been successfully placed with ID " + serviceBooking->getId();
|
||||
sendNotification(authenticatedUser, title, message);
|
||||
m_dataStore.saveServiceBookings();
|
||||
notifyAllAdmins("New Service Order Available", "A new service order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -114,7 +87,6 @@ Return type: void
|
||||
*/
|
||||
void ServiceManagementService::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
AuthenticationManagementService m_authenticationManagementService;
|
||||
auto authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
|
||||
if (authenticatedUser == nullptr)
|
||||
@@ -140,8 +112,6 @@ void ServiceManagementService::purchaseComboPackage(const std::string& comboPack
|
||||
std::string title = "Combo Package Service Booking succeeded";
|
||||
std::string message = "Your service booking for the combo package has been successfully placed with ID " + serviceBooking->getId();
|
||||
sendNotification(authenticatedUser, title, message);
|
||||
m_dataStore.saveServiceBookings();
|
||||
notifyAllAdmins("New Combo Package Order Available", "A new combo package order has been placed with Service Booking ID " + serviceBooking->getId(), m_dataStore.getUsers(), this);
|
||||
}
|
||||
|
||||
util::Map<std::string, User*> ServiceManagementService::m_observers{};
|
||||
@@ -218,7 +188,6 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
|
||||
{
|
||||
return;
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
Notification* notification = Factory::getObject<Notification>(
|
||||
user->getId(),
|
||||
title,
|
||||
@@ -228,6 +197,7 @@ void ServiceManagementService::sendNotification(User* user, const std::string& t
|
||||
{
|
||||
throw std::runtime_error("Failed to create notification");
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
|
||||
m_dataStore.saveNotifications();
|
||||
EventManager::sendNotificationAvailableEvent(user->getId());
|
||||
@@ -463,7 +433,6 @@ Return type: void
|
||||
*/
|
||||
void ServiceManagementService::createComboPackage(const std::string& packageName, const util::Vector<std::string>& serviceIDsInNewCombo, double discountPercentage)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
if (packageName.empty())
|
||||
{
|
||||
@@ -533,7 +502,6 @@ Return type: util::Map<std::string, ComboPackage*>
|
||||
*/
|
||||
util::Map<std::string, ComboPackage*> ServiceManagementService::getComboPackages()
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
util::Map<std::string, ComboPackage*> comboPackages;
|
||||
comboPackages = util::getObjects(m_dataStore.getComboPackages());
|
||||
@@ -548,7 +516,6 @@ Return type: void
|
||||
*/
|
||||
void ServiceManagementService::removeComboPackage(const std::string& comboPackageID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
bool removed = false;
|
||||
auto& trackedComboPackages = m_dataStore.getComboPackages();
|
||||
@@ -581,7 +548,6 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings()
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
util::Map<std::string, ServiceBooking*> serviceBookings;
|
||||
serviceBookings = util::getObjects(m_dataStore.getServiceBookings());
|
||||
@@ -598,7 +564,6 @@ Returns:
|
||||
*/
|
||||
ServiceBooking* ServiceManagementService::getServiceBooking(const std::string& serviceID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
auto currentServiceBookings = getServiceBookings();
|
||||
for (int iterator = 0; iterator < currentServiceBookings.getSize(); iterator++)
|
||||
{
|
||||
@@ -625,27 +590,14 @@ Throws:
|
||||
*/
|
||||
void ServiceManagementService::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
UserManagementService m_userManagementService;
|
||||
ServiceBooking* currentBooking = getServiceBooking(bookingID);
|
||||
if (currentBooking == nullptr)
|
||||
{
|
||||
throw std::runtime_error("Service Booking not available");
|
||||
}
|
||||
if (currentBooking->getStatus() == util::ServiceJobStatus::CANCELLED)
|
||||
{
|
||||
throw std::runtime_error("Cannot create job card. Service Booking was cancelled!");
|
||||
}
|
||||
auto& currentTrackedJobCards = m_dataStore.getJobCards();
|
||||
auto& currentTrackedInventoryItems = m_dataStore.getInventoryItems();
|
||||
auto& currentTrackedServiceBookings = m_dataStore.getServiceBookings();
|
||||
int currentTrackedServiceBookingIndex = currentTrackedServiceBookings.find(bookingID);
|
||||
if (currentTrackedServiceBookingIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid service booking id.");
|
||||
}
|
||||
auto& currentTrackedServiceBooking = currentTrackedServiceBookings.getValueAt(currentTrackedServiceBookingIndex);
|
||||
if (currentBooking == nullptr)
|
||||
{
|
||||
throw std::runtime_error("Service Booking not available");
|
||||
}
|
||||
auto& currentServices = currentBooking->getServices();
|
||||
if (currentServices.find(serviceID) == -1)
|
||||
{
|
||||
@@ -670,18 +622,10 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
|
||||
for (int iterator = 0; iterator < inventoryItems.getSize(); iterator++)
|
||||
{
|
||||
InventoryItem* currentInventoryItem = inventoryItems.getValueAt(iterator);
|
||||
const std::string& currentInventoryItemId = inventoryItems.getKeyAt(iterator);
|
||||
if (currentInventoryItem)
|
||||
{
|
||||
int trackedCurrentInventoryItemIndex = currentTrackedInventoryItems.find(currentInventoryItemId);
|
||||
if (trackedCurrentInventoryItemIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid inventory item index.");
|
||||
}
|
||||
auto& trackedCurrentInventoryItem = currentTrackedInventoryItems.getValueAt(trackedCurrentInventoryItemIndex);
|
||||
int currentStockQuantity = currentInventoryItem->getQuantity();
|
||||
currentInventoryItem->setQuantity(currentStockQuantity - 1);
|
||||
trackedCurrentInventoryItem.state = RecordState::MODIFIED;
|
||||
}
|
||||
}
|
||||
currentBooking->setAssignedTechnician(selectedTechnician);
|
||||
@@ -690,7 +634,6 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
|
||||
{
|
||||
currentBooking->setStatus(util::ServiceJobStatus::STARTED);
|
||||
}
|
||||
currentTrackedServiceBooking.state = RecordState::MODIFIED;
|
||||
std::string title = "Job card created";
|
||||
std::string message = "Job card created for the service and you are assigned for that.";
|
||||
JobCard* jobCard = Factory::getObject<JobCard>(bookingID, currentBooking, currentService, serviceID, technicianID, selectedTechnician, util::Timestamp(), util::ServiceJobStatus::STARTED, util::Timestamp());
|
||||
@@ -707,8 +650,6 @@ void ServiceManagementService::createJobCard(const std::string& bookingID, const
|
||||
message = "A technician has been assigned to your Service Booking with ID " + bookingID;
|
||||
sendNotification(currentBooking->getCustomer(), title, message);
|
||||
m_dataStore.saveJobCards();
|
||||
m_dataStore.saveServiceBookings();
|
||||
m_dataStore.saveInventoryItems();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -726,7 +667,6 @@ Throws:
|
||||
*/
|
||||
void ServiceManagementService::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
util::Map<std::string, InventoryItem*> currentServiceInventoryItems;
|
||||
auto& trackedInventoryItems = m_dataStore.getInventoryItems();
|
||||
@@ -773,7 +713,6 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, Service*> ServiceManagementService::getServices()
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
util::Map<std::string, Service*> services;
|
||||
services = util::getObjects(m_dataStore.getServices());
|
||||
@@ -792,7 +731,6 @@ Throws:
|
||||
*/
|
||||
void ServiceManagementService::removeService(const std::string& serviceID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& currentTrackedServices = m_dataStore.getServices();
|
||||
auto& currentTrackedComboPackages = m_dataStore.getComboPackages();
|
||||
@@ -830,61 +768,6 @@ void ServiceManagementService::removeService(const std::string& serviceID)
|
||||
m_dataStore.saveComboPackages();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: removeServiceBooking
|
||||
Description: Removes a pending service booking by its ID.
|
||||
Cancels only if status is PENDING, otherwise throws exceptions
|
||||
for invalid states. Sends notification to the customer and
|
||||
persists changes.
|
||||
Parameter: const std::string& bookingID - ID of the service booking
|
||||
Return type: void
|
||||
*/
|
||||
void ServiceManagementService::removeServiceBooking(const std::string& bookingID)
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedServiceBookings = m_dataStore.getServiceBookings();
|
||||
bool serviceBookingRemoved = false;
|
||||
for (int iterator = 0; iterator < trackedServiceBookings.getSize(); iterator++)
|
||||
{
|
||||
auto& currentTrackedServiceBooking = trackedServiceBookings.getValueAt(iterator);
|
||||
ServiceBooking* currentServiceBooking = currentTrackedServiceBooking.data;
|
||||
if (currentServiceBooking && currentServiceBooking->getId() == bookingID)
|
||||
{
|
||||
if (currentServiceBooking->getStatus() == util::ServiceJobStatus::PENDING)
|
||||
{
|
||||
const std::string title = "Service Booking cancelled.";
|
||||
const std::string message = "Service Booking of id " + bookingID + " successfully cancelled.";
|
||||
currentServiceBooking->setStatus(util::ServiceJobStatus::CANCELLED);
|
||||
currentTrackedServiceBooking.state = RecordState::MODIFIED;
|
||||
serviceBookingRemoved = true;
|
||||
sendNotification(currentServiceBooking->getCustomer(), title, message);
|
||||
break;
|
||||
}
|
||||
else if(currentServiceBooking->getStatus() == util::ServiceJobStatus::COMPLETED)
|
||||
{
|
||||
throw std::runtime_error("Unable to cancel completed service booking.");
|
||||
}
|
||||
else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::STARTED)
|
||||
{
|
||||
throw std::runtime_error("Unable to cancel started service booking.");
|
||||
}
|
||||
else if (currentServiceBooking->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
|
||||
{
|
||||
throw std::runtime_error("Unable to cancel currently Inprogress service booking.");
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error("Service Booking already cancelled.");
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!serviceBookingRemoved)
|
||||
{
|
||||
throw std::runtime_error("Unable to cancel service booking.");
|
||||
}
|
||||
m_dataStore.saveServiceBookings();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getServiceBookings (overloaded)
|
||||
Description: Retrieves all service bookings for a specific customer.
|
||||
@@ -895,7 +778,6 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, ServiceBooking*> ServiceManagementService::getServiceBookings(const std::string& customerID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
util::Map<std::string, ServiceBooking*> currentServiceBookings = getServiceBookings();
|
||||
util::Map<std::string, ServiceBooking*> currentUserServiceBookings;
|
||||
if (currentServiceBookings.getSize() != 0)
|
||||
@@ -922,7 +804,6 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, JobCard*> ServiceManagementService::getJobCards(const std::string& technicianID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedJobCards = m_dataStore.getJobCards();
|
||||
util::Map<std::string, JobCard*> technicianJobCards;
|
||||
@@ -977,46 +858,45 @@ Returns:
|
||||
*/
|
||||
void ServiceManagementService::updateJobStatus(const std::string& jobID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
AuthenticationManagementService authenticationManagementService;
|
||||
PaymentManagementService paymentManagementService;
|
||||
bool jobStatusUpdated = false, serviceBookingCompleted;
|
||||
User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
|
||||
if (currentTechnician == nullptr)
|
||||
{
|
||||
throw std::runtime_error("Unable to fetch current technician.");
|
||||
}
|
||||
util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
|
||||
if (currentAssignedJobs.getSize() == 0)
|
||||
{
|
||||
throw std::runtime_error("No job cards assigned to the technician.");
|
||||
}
|
||||
AuthenticationManagementService authenticationManagementService;
|
||||
PaymentManagementService paymentManagementService;
|
||||
bool jobStatusUpdated = false, serviceBookingCompleted;
|
||||
JobCard* currentJob;
|
||||
User* currentTechnician = authenticationManagementService.getAuthenticatedUser();
|
||||
if (currentTechnician == nullptr)
|
||||
{
|
||||
throw std::runtime_error("Unable to fetch current technician.");
|
||||
}
|
||||
util::Map<std::string, JobCard*> currentAssignedJobs = getJobCards(currentTechnician->getId());
|
||||
if (currentAssignedJobs.getSize() == 0)
|
||||
{
|
||||
throw std::runtime_error("No job cards assigned to the technician.");
|
||||
}
|
||||
auto& trackedJobCards = m_dataStore.getJobCards();
|
||||
auto& trackedServiceBookings = m_dataStore.getServiceBookings();
|
||||
if (currentAssignedJobs.find(jobID) != -1)
|
||||
{
|
||||
if (currentAssignedJobs.find(jobID) != -1)
|
||||
{
|
||||
int jobIndex = trackedJobCards.find(jobID);
|
||||
if (jobIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Unable to fetch current job.");
|
||||
}
|
||||
auto& trackedCurrentJob = trackedJobCards.getValueAt(jobIndex);
|
||||
JobCard* currentJob = trackedCurrentJob.data;
|
||||
if (currentJob == nullptr)
|
||||
{
|
||||
throw std::runtime_error("Unable to fetch current job.");
|
||||
}
|
||||
if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
|
||||
{
|
||||
currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
|
||||
trackedCurrentJob.state = RecordState::MODIFIED;
|
||||
jobStatusUpdated = true;
|
||||
}
|
||||
currentJob = currentAssignedJobs.getValueAt(currentAssignedJobs.find(jobID));
|
||||
if (currentJob == nullptr)
|
||||
{
|
||||
throw std::runtime_error("Unable to fetch current job.");
|
||||
}
|
||||
if (currentJob->getStatus() == util::ServiceJobStatus::STARTED)
|
||||
{
|
||||
currentJob->setStatus(util::ServiceJobStatus::IN_PROGRESS);
|
||||
trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
|
||||
jobStatusUpdated = true;
|
||||
}
|
||||
else if (currentJob->getStatus() == util::ServiceJobStatus::IN_PROGRESS)
|
||||
{
|
||||
currentJob->setStatus(util::ServiceJobStatus::COMPLETED);
|
||||
trackedCurrentJob.state = RecordState::MODIFIED;
|
||||
trackedJobCards.getValueAt(jobIndex).state = RecordState::MODIFIED;
|
||||
jobStatusUpdated = true;
|
||||
serviceBookingCompleted = hasCompletedAllJobs(currentJob->getBookingId(), currentAssignedJobs);
|
||||
if (serviceBookingCompleted)
|
||||
@@ -1030,15 +910,15 @@ void ServiceManagementService::updateJobStatus(const std::string& jobID)
|
||||
sendNotification(currentJob->getBooking()->getCustomer(), title, message);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error("Failed to update job status. Job may already be completed.");
|
||||
}
|
||||
if (!jobStatusUpdated)
|
||||
{
|
||||
throw std::runtime_error("Failed to update job status. Job may already be completed.");
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error("Failed to update job status. Job may already be completed.");
|
||||
}
|
||||
if (!jobStatusUpdated)
|
||||
{
|
||||
throw std::runtime_error("Failed to update job status. Job may already be completed.");
|
||||
}
|
||||
m_dataStore.saveJobCards();
|
||||
m_dataStore.saveServiceBookings();
|
||||
}
|
||||
-1
@@ -35,7 +35,6 @@ public:
|
||||
void createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID);
|
||||
void createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost);
|
||||
void removeService(const std::string& serviceID);
|
||||
void removeServiceBooking(const std::string& bookingID);
|
||||
util::Map<std::string, JobCard*> getJobCards(const std::string& technicianID);
|
||||
void updateJobStatus(const std::string& jobID);
|
||||
void cancelCustomerServiceBookings(const std::string& customerID);
|
||||
|
||||
-5
@@ -15,7 +15,6 @@ Date:19-May-2026
|
||||
#include "Notification.h"
|
||||
#include "PaymentManagementService.h"
|
||||
#include "ServiceManagementService.h"
|
||||
#include "AuthenticationManagementService.h"
|
||||
#include "User.h"
|
||||
#include "UserManagementService.h"
|
||||
#include "Vector.h"
|
||||
@@ -115,7 +114,6 @@ Return type: void
|
||||
*/
|
||||
void UserManagementService::updateUserDetails(const std::string& userID, const std::string& email, const std::string& phone)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
auto usersMap = util::getObjects(trackedUsersMap);
|
||||
@@ -163,7 +161,6 @@ Throws:
|
||||
*/
|
||||
util::Vector<Notification*> UserManagementService::getUserNotifications(const std::string& userID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
if (trackedUsersMap.find(userID) == -1)
|
||||
@@ -207,7 +204,6 @@ Throws:
|
||||
*/
|
||||
void UserManagementService::deleteNotification(const std::string& notificationID, const std::string& userID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
@@ -269,7 +265,6 @@ Return type: void
|
||||
*/
|
||||
void UserManagementService::removeUser(const std::string& userID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
InventoryManagementService inventoryManagementService;
|
||||
PaymentManagementService paymentManagementService;
|
||||
ServiceManagementService serviceManagementService;
|
||||
|
||||
@@ -153,23 +153,10 @@ bool AdminMenu::handleOperation(int choice)
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: handleNotificationEvent
|
||||
Description: Retrieves and displays the latest notification for the
|
||||
currently logged in admin.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void AdminMenu::handleNotificationEvent()
|
||||
{
|
||||
auto notifications = m_controller.getNotifications();
|
||||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||||
std::string name;
|
||||
if (authenticatedUser)
|
||||
{
|
||||
name = authenticatedUser->getName();
|
||||
}
|
||||
displayNewNotification(notifications, name);
|
||||
displayNewNotification(notifications);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -338,23 +325,6 @@ void AdminMenu::removeInventoryItem()
|
||||
std::string selectedItemId = selectedItem->getId();
|
||||
m_controller.removeInventoryItem(selectedItemId);
|
||||
std::cout << "Item " << selectedItem->getPartName() << " removed successfully." << std::endl;
|
||||
const util::Map<std::string, const Service*>& listOfService = m_controller.getServices();
|
||||
for (int serviceIndex = 0; serviceIndex < listOfService.getSize(); serviceIndex++)
|
||||
{
|
||||
const Service* service = listOfService.getValueAt(serviceIndex);
|
||||
if (!service)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const util::Map<std::string, InventoryItem*>& requiredItems = service->getRequiredInventoryItems();
|
||||
if (requiredItems.find(selectedItemId) != -1)
|
||||
{
|
||||
m_controller.removeService(service->getId());
|
||||
std::cout << "Service " << service->getName()
|
||||
<< " removed as the item "
|
||||
<< selectedItem->getPartName() << " required for the service has been removed." << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
util::pressEnter();
|
||||
|
||||
@@ -11,7 +11,7 @@ Date:19-May-2026
|
||||
#include "Controller.h"
|
||||
#include "Menu.h"
|
||||
|
||||
class AdminMenu : public Menu
|
||||
class AdminMenu : Menu
|
||||
{
|
||||
private:
|
||||
bool handleOperation(int choice);
|
||||
|
||||
@@ -51,12 +51,11 @@ void CustomerMenu::showMenu()
|
||||
<< "\n3. Update Profile"
|
||||
<< "\n4. Change Password"
|
||||
<< "\n5. View Service History"
|
||||
<< "\n6. Cancel Service Booking"
|
||||
<< "\n7. Complete Payments"
|
||||
<< "\n8. View Invoices"
|
||||
<< "\n9. View Notifications"
|
||||
<< "\n10. Configure Notifications"
|
||||
<< "\n11. Logout"
|
||||
<< "\n6. Complete Payments"
|
||||
<< "\n7. View Invoices"
|
||||
<< "\n8. View Notifications"
|
||||
<< "\n9. Configure Notifications"
|
||||
<< "\n10. Logout"
|
||||
<< "\nEnter a choice: ";
|
||||
util::read(choice);
|
||||
if (!handleOperation(choice))
|
||||
@@ -104,21 +103,18 @@ bool CustomerMenu::handleOperation(int choice)
|
||||
viewServiceHistory();
|
||||
break;
|
||||
case 6:
|
||||
cancelServiceBooking();
|
||||
break;
|
||||
case 7:
|
||||
completePayments();
|
||||
break;
|
||||
case 8:
|
||||
case 7:
|
||||
viewInvoices();
|
||||
break;
|
||||
case 9:
|
||||
case 8:
|
||||
viewNotifications();
|
||||
break;
|
||||
case 10:
|
||||
case 9:
|
||||
configureNotifications();
|
||||
break;
|
||||
case 11:
|
||||
case 10:
|
||||
logout();
|
||||
return false;
|
||||
default:
|
||||
@@ -128,23 +124,10 @@ bool CustomerMenu::handleOperation(int choice)
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: handleNotificationEvent
|
||||
Description: Retrieves and displays the latest notification for the
|
||||
currently logged in admin.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void CustomerMenu::handleNotificationEvent()
|
||||
{
|
||||
auto notifications = m_controller.getNotifications();
|
||||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||||
std::string name;
|
||||
if (authenticatedUser)
|
||||
{
|
||||
name = authenticatedUser->getName();
|
||||
}
|
||||
displayNewNotification(notifications, name);
|
||||
displayNewNotification(notifications);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -220,13 +203,6 @@ void CustomerMenu::selectService()
|
||||
util::pressEnter();
|
||||
return;
|
||||
}
|
||||
if (!verifyAllPaymentsCompleted(m_controller))
|
||||
{
|
||||
std::cout << "Your booking cannot be processed because you have pending payments for previous services. Please complete all outstanding invoices before booking a new service."
|
||||
<< std::endl;
|
||||
util::pressEnter();
|
||||
return;
|
||||
}
|
||||
util::Vector<std::string> selectedServices;
|
||||
const Service* selectedService = selectServiceFromServices(services);
|
||||
if (selectedService == nullptr)
|
||||
@@ -269,13 +245,6 @@ void CustomerMenu::selectComboPackage()
|
||||
util::pressEnter();
|
||||
return;
|
||||
}
|
||||
if (!verifyAllPaymentsCompleted(m_controller))
|
||||
{
|
||||
std::cout << "Your booking cannot be processed because you have pending payments for previous services. Please complete all outstanding invoices before booking a new combo package."
|
||||
<< std::endl;
|
||||
util::pressEnter();
|
||||
return;
|
||||
}
|
||||
const ComboPackage* selectedComboPackage = selectComboPackageFromPackages(activeComboPackages);
|
||||
if (selectedComboPackage == nullptr)
|
||||
{
|
||||
@@ -351,46 +320,6 @@ void CustomerMenu::viewServiceHistory()
|
||||
util::pressEnter();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: cancelServiceBooking
|
||||
Description: Allows the customer to cancel a pending service booking.
|
||||
Displays the list of active bookings, lets the user select one,
|
||||
and removes it from the system. If no bookings are available,
|
||||
an appropriate message is shown.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void CustomerMenu::cancelServiceBooking()
|
||||
{
|
||||
util::clear();
|
||||
std::cout << "Cancel Service Booking\n";
|
||||
const User* currentUser = m_controller.getAuthenticatedUser();
|
||||
std::string currentUserID = currentUser->getId();
|
||||
util::Map<std::string, const ServiceBooking*> serviceBookingsByCurrentUser = m_controller.getServiceBookingsByUser(currentUserID);
|
||||
util::Map<int, const ServiceBooking*> serviceBookingsMap;
|
||||
auto currentPendingServiceBookings = filterActiveServiceBookings(serviceBookingsByCurrentUser);
|
||||
int bookingsSize = currentPendingServiceBookings.getSize();
|
||||
if (listServiceBookings(currentPendingServiceBookings, bookingsSize, serviceBookingsMap))
|
||||
{
|
||||
const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
|
||||
if (selectedService)
|
||||
{
|
||||
m_controller.removeServiceBooking(selectedService->getId());
|
||||
std::cout << "Cancelled Service booking of id " + selectedService->getId() << std::endl << std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << "Invalid service booking index.\n\n";
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << "No pending service bookings available.\n\n";
|
||||
}
|
||||
util::pressEnter();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: completePayments
|
||||
Description: Allows the customer to complete pending payments for invoices.
|
||||
|
||||
@@ -12,7 +12,7 @@ Date:19-May-2026
|
||||
#include "Menu.h"
|
||||
#include "Controller.h"
|
||||
|
||||
class CustomerMenu : public Menu
|
||||
class CustomerMenu : Menu
|
||||
{
|
||||
private:
|
||||
bool handleOperation(int choice);
|
||||
@@ -28,6 +28,5 @@ public:
|
||||
void completePayments();
|
||||
void viewInvoices();
|
||||
void viewNotifications();
|
||||
void cancelServiceBooking();
|
||||
void configureNotifications();
|
||||
};
|
||||
};
|
||||
|
||||
@@ -1,21 +1,5 @@
|
||||
/*
|
||||
File: Menu.cpp
|
||||
Description: Implementation file containing common menu event listener
|
||||
functionality, account disable handling, and notification
|
||||
event dispatching for all menu types.
|
||||
Author: Trenser
|
||||
Date:16-Jun-2026
|
||||
*/
|
||||
|
||||
#include "Menu.h"
|
||||
|
||||
/*
|
||||
Function: Menu
|
||||
Description: Constructs a Menu object and initializes event handles
|
||||
and menu state.
|
||||
Parameter: None
|
||||
Return type: None
|
||||
*/
|
||||
Menu::Menu()
|
||||
:
|
||||
m_isMenuActive(false),
|
||||
@@ -23,26 +7,11 @@ Menu::Menu()
|
||||
m_notificationAvailableEvent(NULL),
|
||||
m_shutdownEvent(NULL) {}
|
||||
|
||||
/*
|
||||
Function: ~Menu
|
||||
Description: Destroys the Menu object and performs event listener
|
||||
cleanup.
|
||||
Parameter: None
|
||||
Return type: None
|
||||
*/
|
||||
Menu::~Menu()
|
||||
{
|
||||
stopEventListener();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: startEventListener
|
||||
Description: Creates menu event handles, registers them with the
|
||||
authentication service, and starts the event listener
|
||||
thread.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void Menu::startEventListener()
|
||||
{
|
||||
if (m_isMenuActive.load())
|
||||
@@ -57,14 +26,6 @@ void Menu::startEventListener()
|
||||
m_eventListenerThread = std::thread(&Menu::eventListenerLoop, this);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: eventListenerLoop
|
||||
Description: Waits for account disabled, notification available,
|
||||
and shutdown events and dispatches them to the
|
||||
appropriate handlers.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void Menu::eventListenerLoop()
|
||||
{
|
||||
HANDLE handles[3];
|
||||
@@ -88,13 +49,6 @@ void Menu::eventListenerLoop()
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: stopEventListener
|
||||
Description: Stops the event listener thread and releases all
|
||||
associated event handles.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void Menu::stopEventListener()
|
||||
{
|
||||
m_isMenuActive.store(false);
|
||||
@@ -123,26 +77,13 @@ void Menu::stopEventListener()
|
||||
m_shutdownEvent = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: handleAccountDisabledEvent
|
||||
Description: Handles an account disabled event by marking the menu
|
||||
inactive and notifying the user.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void Menu::handleAccountDisabledEvent()
|
||||
{
|
||||
m_isMenuActive.store(false);
|
||||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||||
std::string messageTitle = "Account Disabled";
|
||||
if (authenticatedUser)
|
||||
{
|
||||
messageTitle += " - " + authenticatedUser->getName();
|
||||
}
|
||||
MessageBoxA(
|
||||
GetConsoleWindow(),
|
||||
"Your account has been disabled.",
|
||||
messageTitle.c_str(),
|
||||
"Account Disabled",
|
||||
MB_OK |
|
||||
MB_ICONWARNING |
|
||||
MB_SETFOREGROUND |
|
||||
|
||||
@@ -28,7 +28,6 @@ Date: 21-May-2026
|
||||
#include "Utility.h"
|
||||
#include "Validator.h"
|
||||
#include "Vector.h"
|
||||
#include "StringHelper.h"
|
||||
|
||||
/*
|
||||
Function: displayAllServices
|
||||
@@ -1057,21 +1056,6 @@ inline const Service* selectServiceFromServices(const util::Map<std::string, con
|
||||
{
|
||||
continue;
|
||||
}
|
||||
bool hasDepletedItem = false;
|
||||
const util::Map<std::string, InventoryItem*>& requiredItems = currentService->getRequiredInventoryItems();
|
||||
for (int itemIndex = 0; itemIndex < requiredItems.getSize(); itemIndex++)
|
||||
{
|
||||
const InventoryItem* item = requiredItems.getValueAt(itemIndex);
|
||||
if (!item || item->getQuantity() < 1)
|
||||
{
|
||||
hasDepletedItem = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (hasDepletedItem)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
activeServicesMap.insert(currentIndex, currentService);
|
||||
double partsCost = util::calculatePartsCost(currentService);
|
||||
std::cout << std::left
|
||||
@@ -1425,16 +1409,7 @@ inline std::string selectComboPackage(util::Map<std::string, const ComboPackage*
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: displayNewNotification
|
||||
Description: Displays the most recent notification from the supplied
|
||||
notification collection.
|
||||
Parameter: util::Vector<const Notification*> notifications -
|
||||
collection of notifications
|
||||
const std::string& - The name of the user currently authenticated with the system
|
||||
Return type: void
|
||||
*/
|
||||
inline void displayNewNotification(util::Vector<const Notification*> notifications, const std::string& name)
|
||||
inline void displayNewNotification(util::Vector<const Notification*> notifications)
|
||||
{
|
||||
const Notification* notification = nullptr;
|
||||
size_t numberOfNotifications = notifications.getSize();
|
||||
@@ -1446,66 +1421,16 @@ inline void displayNewNotification(util::Vector<const Notification*> notificatio
|
||||
}
|
||||
else
|
||||
{
|
||||
if (util::extractNumber(notification->getId()) < util::extractNumber(notifications[index]->getId()))
|
||||
if (notification->getId() < notifications[index]->getId())
|
||||
{
|
||||
notification = notifications[index];
|
||||
}
|
||||
}
|
||||
}
|
||||
if (notification)
|
||||
{
|
||||
std::string messageTitle = notification->getTitle();
|
||||
if (!name.empty())
|
||||
{
|
||||
messageTitle += " - " + name;
|
||||
}
|
||||
MessageBoxA(
|
||||
GetConsoleWindow(),
|
||||
notification->getMessage().c_str(),
|
||||
messageTitle.c_str(),
|
||||
MB_OK |
|
||||
MB_ICONINFORMATION);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: verifyAllPaymentsCompleted
|
||||
Description: Checks whether the authenticated customer has completed
|
||||
all payments for their invoices. Iterates through all
|
||||
invoices belonging to the customer and verifies that
|
||||
each invoice has a payment status of COMPLETED.
|
||||
Parameters: Controller& m_controller -
|
||||
reference to the Controller object used to access
|
||||
authenticated user and invoice data
|
||||
Return type: bool
|
||||
true if all invoices for the authenticated customer
|
||||
are completed, false if any invoice is pending or not completed
|
||||
Throws: std::runtime_error if no authenticated user is found
|
||||
*/
|
||||
inline bool verifyAllPaymentsCompleted(Controller& m_controller)
|
||||
{
|
||||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||||
if (!authenticatedUser)
|
||||
{
|
||||
throw std::runtime_error("No authenticated user found.");
|
||||
}
|
||||
const std::string& authenticatedUserId = authenticatedUser->getId();
|
||||
util::Map<std::string, const Invoice*> listOfInvoices = m_controller.getAllInvoices();
|
||||
for (int invoiceIndex = 0; invoiceIndex < listOfInvoices.getSize(); ++invoiceIndex)
|
||||
{
|
||||
const Invoice* invoice = listOfInvoices.getValueAt(invoiceIndex);
|
||||
if (!invoice)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const std::string& customerId = invoice->getBooking()->getCustomerId();
|
||||
if (customerId == authenticatedUserId)
|
||||
{
|
||||
if (invoice->getStatus() != util::PaymentStatus::COMPLETED)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
MessageBoxA(
|
||||
GetConsoleWindow(),
|
||||
notification->getMessage().c_str(),
|
||||
notification->getTitle().c_str(),
|
||||
MB_OK |
|
||||
MB_ICONINFORMATION);
|
||||
}
|
||||
@@ -51,6 +51,7 @@ void TechnicianMenu::showMenu()
|
||||
{
|
||||
break;
|
||||
}
|
||||
stopEventListener();
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
@@ -98,23 +99,10 @@ bool TechnicianMenu::handleOperation(int choice)
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: handleNotificationEvent
|
||||
Description: Retrieves and displays the latest notification for the
|
||||
currently logged in admin.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void TechnicianMenu::handleNotificationEvent()
|
||||
{
|
||||
auto notifications = m_controller.getNotifications();
|
||||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||||
std::string name;
|
||||
if (authenticatedUser)
|
||||
{
|
||||
name = authenticatedUser->getName();
|
||||
}
|
||||
displayNewNotification(notifications, name);
|
||||
displayNewNotification(notifications);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@@ -11,7 +11,7 @@ Date:19-May-2026
|
||||
#include "Controller.h"
|
||||
#include "Menu.h"
|
||||
|
||||
class TechnicianMenu : public Menu
|
||||
class TechnicianMenu : Menu
|
||||
{
|
||||
private:
|
||||
bool handleOperation(int choice);
|
||||
|
||||
Reference in New Issue
Block a user