Compare commits
11 Commits
main
..
dc5da0a7b7
| Author | SHA1 | Date | |
|---|---|---|---|
 joelthomastrenser
|
dc5da0a7b7 | ||
|
joelthomastrenser
|
7454c5a75f | ||
|
joelthomastrenser
|
93a38bc6fb | ||
|
joelthomastrenser
|
a8cd72ed17 | ||
|
joelthomastrenser
|
adf74e2427 | ||
|
joelthomastrenser
|
603ed9c60e | ||
|
joelthomastrenser
|
43c337d46a | ||
|
joelthomastrenser
|
1ef6cd9479 | ||
|
joelthomastrenser
|
f8cb7453a7 | ||
|
joelthomastrenser
|
6e9a9292de | ||
|
joelthomastrenser
|
ec1f4ea117 |
+2
-2
@@ -427,5 +427,5 @@ FodyWeavers.xsd
|
||||
*.msm
|
||||
*.msp
|
||||
|
||||
# DAT Files
|
||||
*.dat
|
||||
# CSV Files
|
||||
*.csv
|
||||
|
||||
+11
-14
@@ -102,7 +102,7 @@
|
||||
<SDLCheck>true</SDLCheck>
|
||||
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<ConformanceMode>true</ConformanceMode>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
@@ -117,7 +117,7 @@
|
||||
<SDLCheck>true</SDLCheck>
|
||||
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
||||
<ConformanceMode>true</ConformanceMode>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)core\sharedmemory;$(ProjectDir)core\events;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
<AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)factories;$(ProjectDir)views;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)core\patterns;$(ProjectDir)datastores;$(ProjectDir)datastores\sharedmemory;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
|
||||
</ClCompile>
|
||||
<Link>
|
||||
<SubSystem>Console</SubSystem>
|
||||
@@ -126,11 +126,10 @@
|
||||
</ItemDefinitionGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="controllers\Controller.cpp" />
|
||||
<ClCompile Include="core\events\EventManager.cpp" />
|
||||
<ClCompile Include="core\patterns\Observer.cpp" />
|
||||
<ClCompile Include="core\patterns\Subject.cpp" />
|
||||
<ClCompile Include="core\sharedmemory\SharedMemory.cpp" />
|
||||
<ClCompile Include="datastores\DataStore.cpp" />
|
||||
<ClCompile Include="datastores\sharedmemory\SharedMemory.cpp" />
|
||||
<ClCompile Include="models\ComboPackage.cpp" />
|
||||
<ClCompile Include="models\InventoryItem.cpp" />
|
||||
<ClCompile Include="models\Invoice.cpp" />
|
||||
@@ -141,6 +140,7 @@
|
||||
<ClCompile Include="models\User.cpp" />
|
||||
<ClCompile Include="services\AuthenticationManagementService.cpp" />
|
||||
<ClCompile Include="services\InventoryManagementService.cpp" />
|
||||
<ClCompile Include="services\NotificationManagementService.cpp" />
|
||||
<ClCompile Include="services\PaymentManagementService.cpp" />
|
||||
<ClCompile Include="services\ServiceManagementService.cpp" />
|
||||
<ClCompile Include="services\UserManagementService.cpp" />
|
||||
@@ -149,23 +149,20 @@
|
||||
<ClCompile Include="utilities\Validator.cpp" />
|
||||
<ClCompile Include="views\AdminMenu.cpp" />
|
||||
<ClCompile Include="views\CustomerMenu.cpp" />
|
||||
<ClCompile Include="views\Menu.cpp" />
|
||||
<ClCompile Include="views\TechnicianMenu.cpp" />
|
||||
<ClCompile Include="views\UserInterface.cpp" />
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="controllers\Controller.h" />
|
||||
<ClInclude Include="core\events\EventManager.h" />
|
||||
<ClInclude Include="core\patterns\Observer.h" />
|
||||
<ClInclude Include="core\patterns\Subject.h" />
|
||||
<ClInclude Include="core\sharedmemory\FileHeader.h" />
|
||||
<ClInclude Include="core\sharedmemory\MappingInfo.h" />
|
||||
<ClInclude Include="core\sharedmemory\RecordState.h" />
|
||||
<ClInclude Include="core\sharedmemory\SerializedRecords.h" />
|
||||
<ClInclude Include="core\sharedmemory\SharedMemory.h" />
|
||||
<ClInclude Include="core\sharedmemory\TrackedRecord.h" />
|
||||
<ClInclude Include="datastores\DataStore.h" />
|
||||
<ClInclude Include="datastores\DataStoreLockGuard.h" />
|
||||
<ClInclude Include="datastores\sharedmemory\FileHeader.h" />
|
||||
<ClInclude Include="datastores\sharedmemory\MappingInfo.h" />
|
||||
<ClInclude Include="datastores\sharedmemory\RecordState.h" />
|
||||
<ClInclude Include="datastores\sharedmemory\SerializedRecords.h" />
|
||||
<ClInclude Include="datastores\sharedmemory\SharedMemory.h" />
|
||||
<ClInclude Include="datastores\sharedmemory\TrackedRecord.h" />
|
||||
<ClInclude Include="factories\Factory.h" />
|
||||
<ClInclude Include="models\ComboPackage.h" />
|
||||
<ClInclude Include="models\InventoryItem.h" />
|
||||
@@ -184,6 +181,7 @@
|
||||
<ClInclude Include="utilities\Config.h" />
|
||||
<ClInclude Include="utilities\Enums.h" />
|
||||
<ClInclude Include="utilities\FileHelper.h" />
|
||||
<ClInclude Include="utilities\FileManager.h" />
|
||||
<ClInclude Include="utilities\InputHelper.h" />
|
||||
<ClInclude Include="utilities\Map.h" />
|
||||
<ClInclude Include="utilities\OutputHelper.h" />
|
||||
@@ -194,7 +192,6 @@
|
||||
<ClInclude Include="utilities\Vector.h" />
|
||||
<ClInclude Include="views\AdminMenu.h" />
|
||||
<ClInclude Include="views\CustomerMenu.h" />
|
||||
<ClInclude Include="views\Menu.h" />
|
||||
<ClInclude Include="views\MenuHelper.h" />
|
||||
<ClInclude Include="views\TechnicianMenu.h" />
|
||||
<ClInclude Include="views\UserInterface.h" />
|
||||
|
||||
+24
-39
@@ -64,17 +64,11 @@
|
||||
<Filter Include="Source Files\Core\Patterns">
|
||||
<UniqueIdentifier>{8057b93d-51a9-42df-b06e-01ce395f6308}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Header Files\Core\SharedMemory">
|
||||
<UniqueIdentifier>{d9da9793-fe6f-4914-bee3-99d5934da228}</UniqueIdentifier>
|
||||
<Filter Include="Header Files\DataStores\SharedMemory">
|
||||
<UniqueIdentifier>{ec639004-44c6-4bd6-9963-077adde82b5f}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Source Files\Core\SharedMemory">
|
||||
<UniqueIdentifier>{0769afb6-f57d-4ae3-a1cf-ceca6e606af0}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Header Files\Core\Events">
|
||||
<UniqueIdentifier>{85029bdb-6941-41dc-a3a7-9e5841671d8c}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Source Files\Core\Events">
|
||||
<UniqueIdentifier>{1050aca7-6f2c-4ccb-a446-db9c898c3599}</UniqueIdentifier>
|
||||
<Filter Include="Source Files\DataStores\SharedMemory">
|
||||
<UniqueIdentifier>{7aa8722e-adfa-466e-8211-de63f3b7892b}</UniqueIdentifier>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
@@ -120,6 +114,9 @@
|
||||
<ClCompile Include="datastores\DataStore.cpp">
|
||||
<Filter>Source Files\DataStores</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="services\NotificationManagementService.cpp">
|
||||
<Filter>Source Files\Services</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="core\patterns\Observer.cpp">
|
||||
<Filter>Source Files\Core\Patterns</Filter>
|
||||
</ClCompile>
|
||||
@@ -150,14 +147,8 @@
|
||||
<ClCompile Include="models\ComboPackage.cpp">
|
||||
<Filter>Source Files\Models</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="core\sharedmemory\SharedMemory.cpp">
|
||||
<Filter>Source Files\Core\SharedMemory</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="core\events\EventManager.cpp">
|
||||
<Filter>Source Files\Core\Events</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="views\Menu.cpp">
|
||||
<Filter>Source Files\Views</Filter>
|
||||
<ClCompile Include="datastores\sharedmemory\SharedMemory.cpp">
|
||||
<Filter>Source Files\DataStores\SharedMemory</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
@@ -254,6 +245,9 @@
|
||||
<ClInclude Include="utilities\Config.h">
|
||||
<Filter>Header Files\Utilities</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="utilities\FileManager.h">
|
||||
<Filter>Header Files\Utilities</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="utilities\StringHelper.h">
|
||||
<Filter>Header Files\Utilities</Filter>
|
||||
</ClInclude>
|
||||
@@ -266,32 +260,23 @@
|
||||
<ClInclude Include="views\MenuHelper.h">
|
||||
<Filter>Header Files\Views</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="datastores\DataStoreLockGuard.h">
|
||||
<Filter>Header Files\DataStores</Filter>
|
||||
<ClInclude Include="datastores\sharedmemory\FileHeader.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="core\sharedmemory\FileHeader.h">
|
||||
<Filter>Header Files\Core\SharedMemory</Filter>
|
||||
<ClInclude Include="datastores\sharedmemory\MappingInfo.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="core\sharedmemory\MappingInfo.h">
|
||||
<Filter>Header Files\Core\SharedMemory</Filter>
|
||||
<ClInclude Include="datastores\sharedmemory\RecordState.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="core\sharedmemory\RecordState.h">
|
||||
<Filter>Header Files\Core\SharedMemory</Filter>
|
||||
<ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="core\sharedmemory\SerializedRecords.h">
|
||||
<Filter>Header Files\Core\SharedMemory</Filter>
|
||||
<ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="core\sharedmemory\SharedMemory.h">
|
||||
<Filter>Header Files\Core\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="core\sharedmemory\TrackedRecord.h">
|
||||
<Filter>Header Files\Core\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="core\events\EventManager.h">
|
||||
<Filter>Header Files\Core\Events</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="views\Menu.h">
|
||||
<Filter>Header Files\Views</Filter>
|
||||
<ClInclude Include="datastores\sharedmemory\SharedMemory.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
+47
-47
@@ -6,7 +6,6 @@ Description: Implementation file containing the method definitions of the
|
||||
Author: Trenser
|
||||
Date:19-May-2026
|
||||
*/
|
||||
|
||||
#include "ComboPackage.h"
|
||||
#include "Controller.h"
|
||||
#include "Enums.h"
|
||||
@@ -234,17 +233,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 +264,6 @@ util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
|
||||
return readOnlyServiceBookings;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Function: getServiceBookingsByUser
|
||||
Description: Retrieves all service bookings for a specific user.
|
||||
@@ -600,50 +587,63 @@ void Controller::configureNotifications(bool paymentNotifications, bool serviceN
|
||||
}
|
||||
|
||||
/*
|
||||
Function: initialize
|
||||
Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- bool
|
||||
*/
|
||||
bool Controller::initialize()
|
||||
{
|
||||
auto& dataStore = DataStore::getInstance();
|
||||
|
||||
if (!dataStore.initialize())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
m_userManagementService.ensureAdminExists();
|
||||
m_inventoryManagementService.sendLowStockAlerts();
|
||||
m_paymentManagementService.sendPaymentReminders();
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: shutdown
|
||||
Description: Shutdown the system, and do necessary cleanups
|
||||
Function: loadSystemData
|
||||
Description: Loads all system data from persistent storage into memory.
|
||||
Invokes the respective management services to load users, inventory items, services,
|
||||
combo packages, service bookings, job cards, invoices, and observers.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void Controller::shutdown()
|
||||
void Controller::loadSystemData()
|
||||
{
|
||||
auto& dataStore = DataStore::getInstance();
|
||||
dataStore.shutdown();
|
||||
m_userManagementService.loadUsers();
|
||||
m_inventoryManagementService.loadInventoryItems();
|
||||
m_serviceManagementService.loadServices();
|
||||
m_serviceManagementService.loadComboPackages();
|
||||
m_serviceManagementService.loadServiceBookings();
|
||||
m_serviceManagementService.loadJobCards();
|
||||
m_paymentManagementService.loadInvoices();
|
||||
m_serviceManagementService.loadObservers();
|
||||
m_paymentManagementService.loadObservers();
|
||||
m_inventoryManagementService.loadObservers();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: registerEvents
|
||||
Description: Registers menu event handles with the authentication
|
||||
service.
|
||||
Parameter: HANDLE accountDisabledEvent - account disabled event handle
|
||||
HANDLE notificationAvailableEvent - notification event handle
|
||||
Function: saveSystemData
|
||||
Description: Saves all system data from memory back to persistent storage.
|
||||
Invokes the respective management services to save users, inventory items, services,
|
||||
combo packages, service bookings, job cards, invoices, and observers.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void Controller::saveSystemData()
|
||||
{
|
||||
m_userManagementService.saveUsers();
|
||||
m_inventoryManagementService.saveInventoryItems();
|
||||
m_serviceManagementService.saveServices();
|
||||
m_serviceManagementService.saveComboPackages();
|
||||
m_serviceManagementService.saveServiceBookings();
|
||||
m_serviceManagementService.saveJobCards();
|
||||
m_paymentManagementService.saveInvoices();
|
||||
m_serviceManagementService.saveObservers();
|
||||
m_paymentManagementService.saveObservers();
|
||||
m_inventoryManagementService.saveObservers();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: runSystemChecks
|
||||
Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void Controller::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
|
||||
void Controller::runSystemChecks()
|
||||
{
|
||||
m_authenticationManagementService.registerEvents(accountDisabledEvent, notificationAvailableEvent);
|
||||
m_userManagementService.ensureAdminExists();
|
||||
m_inventoryManagementService.sendLowStockAlerts();
|
||||
m_paymentManagementService.sendPaymentReminders();
|
||||
}
|
||||
|
||||
|
||||
@@ -8,7 +8,6 @@ Date:19-May-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <windows.h>
|
||||
#include <string>
|
||||
#include "AuthenticationManagementService.h"
|
||||
#include "Enums.h"
|
||||
@@ -58,7 +57,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);
|
||||
@@ -72,7 +70,7 @@ public:
|
||||
util::Vector<const Notification*> getNotifications();
|
||||
void deleteNotification(const std::string& notificationID);
|
||||
void configureNotifications(bool paymentNotifications, bool serviceNotifications);
|
||||
bool initialize();
|
||||
void shutdown();
|
||||
void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
|
||||
void loadSystemData();
|
||||
void saveSystemData();
|
||||
void runSystemChecks();
|
||||
};
|
||||
-225
@@ -1,225 +0,0 @@
|
||||
/*
|
||||
File: EventManager.cpp
|
||||
Description: Implementation file containing the method definitions of the
|
||||
EventManager class, including listener management and
|
||||
interprocess event publishing.
|
||||
Author: Trenser
|
||||
Date:15-Jun-2026
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
#include "EventManager.h"
|
||||
|
||||
namespace
|
||||
{
|
||||
const std::string USER_DISABLED_EVENT = "userDisabled_";
|
||||
|
||||
const std::string NOTIFICATION_AVAILABLE_EVENT = "notificationAvailable_";
|
||||
}
|
||||
|
||||
/*
|
||||
Function: EventManager
|
||||
Description: Constructs an EventManager instance with default values.
|
||||
Parameter: None
|
||||
Return type: None
|
||||
*/
|
||||
EventManager::EventManager()
|
||||
:
|
||||
m_userDisabledEvent(NULL),
|
||||
m_notificationAvailableEvent(NULL),
|
||||
m_shutdownEvent(NULL),
|
||||
m_running(false) {}
|
||||
|
||||
/*
|
||||
Function: ~EventManager
|
||||
Description: Destroys the EventManager and performs final cleanup.
|
||||
Parameter: None
|
||||
Return type: None
|
||||
*/
|
||||
EventManager::~EventManager()
|
||||
{
|
||||
shutdown();
|
||||
if (m_listenerThread.joinable())
|
||||
{
|
||||
m_listenerThread.join();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: initialize
|
||||
Description: Creates the user-specific events and starts the listener
|
||||
thread.
|
||||
Parameter: const std::string& userId - unique identifier of the user
|
||||
std::function<void()> userDisabledCallback - callback for
|
||||
user disable events
|
||||
std::function<void()> notificationCallback - callback for
|
||||
notification events
|
||||
Return type: bool - true if initialization succeeds, false otherwise
|
||||
*/
|
||||
bool EventManager::initialize(const std::string& userId, std::function<void()> userDisabledCallback, std::function<void()> notificationCallback)
|
||||
{
|
||||
if (m_running.load())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
m_userDisabledCallback = userDisabledCallback;
|
||||
m_notificationCallback = notificationCallback;
|
||||
m_userDisabledEvent = CreateEventA(NULL, FALSE, FALSE, (USER_DISABLED_EVENT + userId).c_str());
|
||||
if (!m_userDisabledEvent)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (GetLastError() == ERROR_ALREADY_EXISTS)
|
||||
{
|
||||
CloseHandle(m_userDisabledEvent);
|
||||
m_userDisabledEvent = NULL;
|
||||
throw std::runtime_error("Only one session allowed per user.");
|
||||
}
|
||||
m_notificationAvailableEvent = CreateEventA(NULL, FALSE, FALSE, (NOTIFICATION_AVAILABLE_EVENT + userId).c_str());
|
||||
if (!m_notificationAvailableEvent)
|
||||
{
|
||||
CloseHandle(m_userDisabledEvent);
|
||||
m_userDisabledEvent = NULL;
|
||||
return false;
|
||||
}
|
||||
m_shutdownEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
if (!m_shutdownEvent)
|
||||
{
|
||||
CloseHandle(m_userDisabledEvent);
|
||||
CloseHandle(m_notificationAvailableEvent);
|
||||
m_userDisabledEvent = NULL;
|
||||
m_notificationAvailableEvent = NULL;
|
||||
return false;
|
||||
}
|
||||
m_running.store(true);
|
||||
m_listenerThread = std::thread(&EventManager::run, this);
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: shutdown
|
||||
Description: Stops the listener thread and releases event resources.
|
||||
Parameter: None
|
||||
Return type: None
|
||||
*/
|
||||
void EventManager::shutdown()
|
||||
{
|
||||
if (!m_running.load())
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_running.store(false);
|
||||
if (m_shutdownEvent)
|
||||
{
|
||||
SetEvent(m_shutdownEvent);
|
||||
}
|
||||
if (m_listenerThread.joinable())
|
||||
{
|
||||
if (std::this_thread::get_id() != m_listenerThread.get_id())
|
||||
{
|
||||
m_listenerThread.join();
|
||||
}
|
||||
}
|
||||
if (m_userDisabledEvent)
|
||||
{
|
||||
CloseHandle(m_userDisabledEvent);
|
||||
m_userDisabledEvent = NULL;
|
||||
}
|
||||
if (m_notificationAvailableEvent)
|
||||
{
|
||||
CloseHandle(m_notificationAvailableEvent);
|
||||
m_notificationAvailableEvent = NULL;
|
||||
}
|
||||
if (m_shutdownEvent)
|
||||
{
|
||||
CloseHandle(m_shutdownEvent);
|
||||
m_shutdownEvent = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: run
|
||||
Description: Waits for and dispatches user-related events.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void EventManager::run()
|
||||
{
|
||||
HANDLE handles[3];
|
||||
handles[0] = m_userDisabledEvent;
|
||||
handles[1] = m_notificationAvailableEvent;
|
||||
handles[2] = m_shutdownEvent;
|
||||
while (m_running.load())
|
||||
{
|
||||
DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
|
||||
switch (result)
|
||||
{
|
||||
case WAIT_OBJECT_0:
|
||||
try
|
||||
{
|
||||
if (m_userDisabledCallback)
|
||||
{
|
||||
m_userDisabledCallback();
|
||||
}
|
||||
}
|
||||
catch (const std::exception& exception)
|
||||
{
|
||||
std::cout << exception.what() << std::endl;
|
||||
}
|
||||
break;
|
||||
case WAIT_OBJECT_0 + 1:
|
||||
try
|
||||
{
|
||||
if (m_notificationCallback)
|
||||
{
|
||||
m_notificationCallback();
|
||||
}
|
||||
}
|
||||
catch (const std::exception& exception)
|
||||
{
|
||||
std::cout << exception.what() << std::endl;
|
||||
}
|
||||
break;
|
||||
case WAIT_OBJECT_0 + 2:
|
||||
return;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: sendUserDisabledEvent
|
||||
Description: Publishes a user disabled event for a specific user.
|
||||
Parameter: const std::string& userId - target user identifier
|
||||
Return type: void
|
||||
*/
|
||||
void EventManager::sendUserDisabledEvent(const std::string& userId)
|
||||
{
|
||||
HANDLE eventHandle = CreateEventA(NULL, FALSE, FALSE, (USER_DISABLED_EVENT + userId).c_str());
|
||||
if (!eventHandle)
|
||||
{
|
||||
return;
|
||||
}
|
||||
SetEvent(eventHandle);
|
||||
CloseHandle(eventHandle);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: sendNotificationAvailableEvent
|
||||
Description: Publishes a notification available event for a specific
|
||||
user.
|
||||
Parameter: const std::string& userId - target user identifier
|
||||
Return type: void
|
||||
*/
|
||||
void EventManager::sendNotificationAvailableEvent(const std::string& userId)
|
||||
{
|
||||
HANDLE eventHandle = CreateEventA(NULL, FALSE, FALSE, (NOTIFICATION_AVAILABLE_EVENT + userId).c_str());
|
||||
if (!eventHandle)
|
||||
{
|
||||
return;
|
||||
}
|
||||
SetEvent(eventHandle);
|
||||
CloseHandle(eventHandle);
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
/*
|
||||
File: EventManager.h
|
||||
Description: Header file declaring the EventManager class, which manages
|
||||
user-specific interprocess events for user disable and
|
||||
notification availability updates.
|
||||
Author: Trenser
|
||||
Date:15-Jun-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <windows.h>
|
||||
#include <atomic>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
|
||||
class EventManager
|
||||
{
|
||||
private:
|
||||
HANDLE m_userDisabledEvent;
|
||||
HANDLE m_notificationAvailableEvent;
|
||||
HANDLE m_shutdownEvent;
|
||||
std::atomic<bool> m_running;
|
||||
std::thread m_listenerThread;
|
||||
std::function<void()> m_userDisabledCallback;
|
||||
std::function<void()> m_notificationCallback;
|
||||
void run();
|
||||
|
||||
public:
|
||||
EventManager();
|
||||
~EventManager();
|
||||
bool initialize(const std::string& userId, std::function<void()> userDisabledCallback, std::function<void()> notificationCallback);
|
||||
void shutdown();
|
||||
static void sendUserDisabledEvent(const std::string& userId);
|
||||
static void sendNotificationAvailableEvent(const std::string& userId);
|
||||
};
|
||||
@@ -7,8 +7,11 @@ Date: 19-May-2026
|
||||
|
||||
#pragma once
|
||||
|
||||
class Notification;
|
||||
|
||||
class Observer
|
||||
{
|
||||
public:
|
||||
virtual ~Observer() = default;
|
||||
virtual void addNotification(Notification* notification) = 0;
|
||||
};
|
||||
-17
@@ -1,17 +0,0 @@
|
||||
/*
|
||||
File: FileHeader.h
|
||||
Description: Defines the FileHeader structure used to store
|
||||
metadata for binary record files, including
|
||||
record count and capacity.
|
||||
Author: Trenser
|
||||
Created: 10-June-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
|
||||
struct FileHeader
|
||||
{
|
||||
size_t recordCount;
|
||||
size_t capacity;
|
||||
};
|
||||
-17
@@ -1,17 +0,0 @@
|
||||
/*
|
||||
File: RecordState.h
|
||||
Description: Defines the RecordState enumeration used to
|
||||
represent the state of a record in storage.
|
||||
States include CLEAN, NEW_RECORD, and MODIFIED.
|
||||
Author: Trenser
|
||||
Created: 10-June-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
enum class RecordState : int
|
||||
{
|
||||
CLEAN,
|
||||
NEW_RECORD,
|
||||
MODIFIED
|
||||
};
|
||||
+100
-355
@@ -12,46 +12,10 @@ Date: 19-May-2026
|
||||
#include "Config.h"
|
||||
#include "SerializedRecords.h"
|
||||
#include "FileHelper.h"
|
||||
#include "ServiceBooking.h"
|
||||
#include "JobCard.h"
|
||||
#include "Invoice.h"
|
||||
|
||||
/*
|
||||
Function: DataStore
|
||||
Description: Constructs the DataStore singleton and initializes
|
||||
internal handles to their default values.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
DataStore::DataStore() :
|
||||
m_globalMutex(NULL) {}
|
||||
|
||||
/*
|
||||
Function: ~DataStore
|
||||
Description: Destroys the DataStore singleton and releases all
|
||||
cached application objects owned by the datastore.
|
||||
This includes users, notifications, services,
|
||||
combo packages, inventory items, service bookings,
|
||||
job cards, and invoices.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
DataStore::~DataStore()
|
||||
{
|
||||
clearCache(m_userCache);
|
||||
clearCache(m_notificationCache);
|
||||
clearCache(m_serviceCache);
|
||||
clearCache(m_comboPackageCache);
|
||||
clearCache(m_inventoryItemCache);
|
||||
clearCache(m_serviceBookingCache);
|
||||
clearCache(m_jobCardCache);
|
||||
clearCache(m_invoiceCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: initialize
|
||||
Description: Initializes the shared-memory datastore.
|
||||
@@ -74,15 +38,6 @@ bool DataStore::initialize()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!lockDataStore())
|
||||
{
|
||||
CloseHandle(m_globalMutex);
|
||||
m_globalMutex = NULL;
|
||||
return false;
|
||||
}
|
||||
bool success = true;
|
||||
do
|
||||
{
|
||||
util::ensureDirectoryExists(config::file::DIRECTORY);
|
||||
m_users.fileName = config::file::USER_FILE;
|
||||
m_users.recordSize = sizeof(SerializedUser);
|
||||
@@ -108,67 +63,53 @@ bool DataStore::initialize()
|
||||
m_inventoryManagementObservers.recordSize = sizeof(SerializedObserver);
|
||||
if (!SharedMemory::createOrOpenMapping(m_users))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_notifications))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_services))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!SharedMemory::createOrOpenMapping(m_comboPackages))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_inventoryItems))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_serviceBookings))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_jobCards))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_invoices))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_payments))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_paymentManagementObservers))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_inventoryManagementObservers))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
return false;
|
||||
}
|
||||
} while (false);
|
||||
unlockDataStore();
|
||||
if (!success)
|
||||
{
|
||||
shutdown();
|
||||
}
|
||||
return success;
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -191,6 +132,7 @@ void DataStore::shutdown()
|
||||
SharedMemory::closeMapping(m_serviceBookings);
|
||||
SharedMemory::closeMapping(m_jobCards);
|
||||
SharedMemory::closeMapping(m_invoices);
|
||||
SharedMemory::closeMapping(m_payments);
|
||||
SharedMemory::closeMapping(m_serviceManagementObservers);
|
||||
SharedMemory::closeMapping(m_paymentManagementObservers);
|
||||
SharedMemory::closeMapping(m_inventoryManagementObservers);
|
||||
@@ -223,11 +165,9 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<User>>: Collection of user records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
|
||||
util::Map<std::string, TrackedRecord<User>> DataStore::getUsers()
|
||||
{
|
||||
auto users = loadRecords<User, SerializedUser>(m_users);
|
||||
refreshCache(m_userCache, users);
|
||||
return m_userCache;
|
||||
return util::Map<std::string, TrackedRecord<User>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -238,11 +178,9 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<Notification>>: Collection of notification records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
|
||||
util::Map<std::string, TrackedRecord<Notification>> DataStore::getNotifications()
|
||||
{
|
||||
auto notifications = loadRecords<Notification, SerializedNotification>(m_notifications);
|
||||
refreshCache(m_notificationCache, notifications);
|
||||
return m_notificationCache;
|
||||
return util::Map<std::string, TrackedRecord<Notification>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -253,31 +191,9 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<Service>>: Collection of service records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<Service>>& DataStore::getServices()
|
||||
util::Map<std::string, TrackedRecord<Service>> DataStore::getServices()
|
||||
{
|
||||
util::Map<std::string, TrackedRecord<Service>> services = loadRecords<Service, SerializedService>(m_services);
|
||||
refreshCache(m_serviceCache, services);
|
||||
util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems = getInventoryItems();
|
||||
size_t numberOfServices = m_serviceCache.getSize();
|
||||
for (int iteratorOne =0; iteratorOne < numberOfServices; iteratorOne++)
|
||||
{
|
||||
Service* currentService = m_serviceCache.getValueAt(iteratorOne).data;
|
||||
util::Map<std::string, InventoryItem*> inventoryItemMap;
|
||||
util::Vector<std::string> currentServiceInventoryItem = currentService->getRequiredInventoryItemIDs();
|
||||
for (int iteratorTwo = 0; iteratorTwo < currentServiceInventoryItem.getSize(); iteratorTwo++)
|
||||
{
|
||||
const std::string& currentInventoryItemId = currentServiceInventoryItem[iteratorTwo];
|
||||
int currentInventoryItemIndex = inventoryItems.find(currentInventoryItemId);
|
||||
if (currentInventoryItemIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid inventory item ID");
|
||||
}
|
||||
InventoryItem* currentItem = inventoryItems.getValueAt(currentInventoryItemIndex).data;
|
||||
inventoryItemMap[currentInventoryItemId] = currentItem;
|
||||
}
|
||||
currentService->setRequiredInventoryItems(inventoryItemMap);
|
||||
}
|
||||
return m_serviceCache;
|
||||
return util::Map<std::string, TrackedRecord<Service>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -288,31 +204,9 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<ComboPackage>>: Collection of combo package records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<ComboPackage>>& DataStore::getComboPackages()
|
||||
util::Map<std::string, TrackedRecord<ComboPackage>> DataStore::getComboPackages()
|
||||
{
|
||||
util::Map<std::string, TrackedRecord<ComboPackage>> comboPackages = loadRecords<ComboPackage, SerializedComboPackage>(m_comboPackages);
|
||||
refreshCache(m_comboPackageCache, comboPackages);
|
||||
util::Map<std::string, TrackedRecord<Service>>& services = getServices();
|
||||
size_t numberOfComboPackages = m_comboPackageCache.getSize();
|
||||
for (int iteratorOne = 0; iteratorOne < numberOfComboPackages; iteratorOne++)
|
||||
{
|
||||
ComboPackage* currentComboPackage = m_comboPackageCache.getValueAt(iteratorOne).data;
|
||||
util::Vector<std::string> currentServiceIds = currentComboPackage->getServiceIDs();
|
||||
util::Map<std::string, Service*> currentComboPackageServices;
|
||||
for (int iteratorTwo = 0; iteratorTwo < currentServiceIds.getSize(); iteratorTwo++)
|
||||
{
|
||||
const std::string& currentServiceId = currentServiceIds[iteratorTwo];
|
||||
int serviceIndex = services.find(currentServiceId);
|
||||
if (serviceIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid service ID");
|
||||
}
|
||||
Service* currentService = services.getValueAt(serviceIndex).data;
|
||||
currentComboPackageServices[currentServiceId] = currentService;
|
||||
}
|
||||
currentComboPackage->setServices(currentComboPackageServices);
|
||||
}
|
||||
return m_comboPackageCache;
|
||||
return util::Map<std::string, TrackedRecord<ComboPackage>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -323,11 +217,9 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<InventoryItem>>: Collection of inventory item records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<InventoryItem>>& DataStore::getInventoryItems()
|
||||
util::Map<std::string, TrackedRecord<InventoryItem>> DataStore::getInventoryItems()
|
||||
{
|
||||
auto inventoryItems = loadRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems);
|
||||
refreshCache(m_inventoryItemCache, inventoryItems);
|
||||
return m_inventoryItemCache;
|
||||
return util::Map<std::string, TrackedRecord<InventoryItem>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -338,52 +230,9 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<ServiceBooking>>: Collection of service booking records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBookings()
|
||||
util::Map<std::string, TrackedRecord<ServiceBooking>> DataStore::getServiceBookings()
|
||||
{
|
||||
util::Map<std::string, TrackedRecord<ServiceBooking>> serviceBookings = loadRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings);
|
||||
refreshCache(m_serviceBookingCache, serviceBookings);
|
||||
auto& users = getUsers();
|
||||
auto& services = getServices();
|
||||
size_t numberOfServiceBookings = m_serviceBookingCache.getSize();
|
||||
for (int iteratorOne = 0; iteratorOne < numberOfServiceBookings; iteratorOne++)
|
||||
{
|
||||
ServiceBooking* serviceBooking = m_serviceBookingCache.getValueAt(iteratorOne).data;
|
||||
auto& serviceIds = serviceBooking->getServiceIDs();
|
||||
util::Map<std::string, Service*> servicesInBooking;
|
||||
for (int iteratorTwo = 0; iteratorTwo < serviceIds.getSize(); iteratorTwo++)
|
||||
{
|
||||
const std::string& currentServiceId = serviceIds[iteratorTwo];
|
||||
int serviceIndex = services.find(currentServiceId);
|
||||
if (serviceIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid service index.");
|
||||
}
|
||||
auto& currentService = services.getValueAt(serviceIndex);
|
||||
servicesInBooking[currentServiceId] = currentService.data;
|
||||
}
|
||||
serviceBooking->setServices(servicesInBooking);
|
||||
if (!serviceBooking->getCustomerId().empty())
|
||||
{
|
||||
int userIndex = users.find(serviceBooking->getCustomerId());
|
||||
if (userIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid user index.");
|
||||
}
|
||||
auto& customer = users.getValueAt(userIndex);
|
||||
serviceBooking->setCustomer(customer.data);
|
||||
}
|
||||
if (!serviceBooking->getAssignedTechnicianId().empty())
|
||||
{
|
||||
int technicianIndex = users.find(serviceBooking->getAssignedTechnicianId());
|
||||
if (technicianIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid technician index.");
|
||||
}
|
||||
auto& technician = users.getValueAt(technicianIndex);
|
||||
serviceBooking->setAssignedTechnician(technician.data);
|
||||
}
|
||||
}
|
||||
return m_serviceBookingCache;
|
||||
return util::Map<std::string, TrackedRecord<ServiceBooking>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -394,53 +243,11 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<JobCard>>: Collection of job card records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
|
||||
util::Map<std::string, TrackedRecord<JobCard>> DataStore::getJobCards()
|
||||
{
|
||||
util::Map<std::string, TrackedRecord<JobCard>> jobCards = loadRecords<JobCard, SerializedJobCard>(m_jobCards);
|
||||
refreshCache(m_jobCardCache, jobCards);
|
||||
auto& serviceBookings = getServiceBookings();
|
||||
auto& services = getServices();
|
||||
auto& users = getUsers();
|
||||
int numberOfJobCards = m_jobCardCache.getSize();
|
||||
for (int iterator = 0; iterator < numberOfJobCards; iterator++)
|
||||
{
|
||||
JobCard* jobCard = m_jobCardCache.getValueAt(iterator).data;
|
||||
if (!jobCard)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const std::string& bookingId = jobCard->getBookingId();
|
||||
int bookingIndex = serviceBookings.find(bookingId);
|
||||
if (bookingIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid booking ID: " + bookingId);
|
||||
}
|
||||
auto& trackedBooking = serviceBookings.getValueAt(bookingIndex);
|
||||
jobCard->setBooking(trackedBooking.data);
|
||||
const std::string& serviceId = jobCard->getServiceId();
|
||||
int serviceIndex = services.find(serviceId);
|
||||
if (serviceIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid service ID: " + serviceId);
|
||||
}
|
||||
auto& trackedService = services.getValueAt(serviceIndex);
|
||||
jobCard->setService(trackedService.data);
|
||||
const std::string& technicianId = jobCard->getTechnicianId();
|
||||
if (!technicianId.empty())
|
||||
{
|
||||
int technicianIndex = users.find(technicianId);
|
||||
if (technicianIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid technician ID: " + technicianId);
|
||||
}
|
||||
auto& trackedTechnician = users.getValueAt(technicianIndex);
|
||||
jobCard->setTechnician(trackedTechnician.data);
|
||||
}
|
||||
}
|
||||
return m_jobCardCache;
|
||||
return util::Map<std::string, TrackedRecord<JobCard>>();
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Function: getInvoices
|
||||
Description: Retrieves all invoice records from the datastore.
|
||||
@@ -449,79 +256,22 @@ Parameters:
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<Invoice>>: Collection of invoice records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
|
||||
util::Map<std::string, TrackedRecord<Invoice>> DataStore::getInvoices()
|
||||
{
|
||||
auto& serviceBookings = getServiceBookings();
|
||||
auto& inventoryItems = getInventoryItems();
|
||||
util::Map<std::string, TrackedRecord<Invoice>> invoices = loadRecords<Invoice, SerializedInvoice>(m_invoices);
|
||||
refreshCache(m_invoiceCache, invoices);
|
||||
for (int iterator = 0; iterator < m_invoiceCache.getSize(); iterator++)
|
||||
{
|
||||
auto& trackedInvoice = m_invoiceCache.getValueAt(iterator);
|
||||
Invoice* invoice = trackedInvoice.data;
|
||||
if (!invoice)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const std::string& currentBookingId = invoice->getBookingId();
|
||||
int currentBookingIndex = serviceBookings.find(currentBookingId);
|
||||
if (currentBookingIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid Service Booking Index.");
|
||||
}
|
||||
ServiceBooking* currentBooking = serviceBookings.getValueAt(currentBookingIndex).data;
|
||||
auto& currentInventoryItemIds = invoice->getPartIDs();
|
||||
util::Map<std::string, InventoryItem*> currentInventoryItems;
|
||||
for (int iterator = 0; iterator < currentInventoryItemIds.getSize(); iterator++)
|
||||
{
|
||||
const std::string& currentItemId = currentInventoryItemIds[iterator];
|
||||
int currentItemIndex = inventoryItems.find(currentItemId);
|
||||
if (currentItemIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid Inventory item id.");
|
||||
}
|
||||
InventoryItem* currentItem = inventoryItems.getValueAt(currentItemIndex).data;
|
||||
if (!currentItem)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
currentInventoryItems[currentItemId] = currentItem;
|
||||
}
|
||||
invoice->setBooking(currentBooking);
|
||||
invoice->setParts(currentInventoryItems);
|
||||
}
|
||||
return m_invoiceCache;
|
||||
return util::Map<std::string, TrackedRecord<Invoice>>();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getObservers
|
||||
Description: Retrieves observer records from the specified observer mapping
|
||||
and resolves them to User objects.
|
||||
Function: getPayments
|
||||
Description: Retrieves all payment records from the datastore.
|
||||
Parameters:
|
||||
- mapping: Observer mapping to read from
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, User*>: Collection of observer records
|
||||
Throws:
|
||||
- std::runtime_error if an observer references an invalid user ID
|
||||
- util::Map<std::string, TrackedRecord<Payment>>: Collection of payment records
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getObservers(MappingInfo& mapping)
|
||||
util::Map<std::string, TrackedRecord<Payment>> DataStore::getPayments()
|
||||
{
|
||||
auto& users = getUsers();
|
||||
util::Map<std::string, User*> observers;
|
||||
SharedMemory::ensureLatestMapping(mapping);
|
||||
size_t recordCount = SharedMemory::getRecordCount(mapping);
|
||||
for (size_t index = 0; index < recordCount; index++)
|
||||
{
|
||||
const SerializedObserver* observer = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
|
||||
int userIndex = users.find(observer->id);
|
||||
if (userIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid observer user ID");
|
||||
}
|
||||
User* user = users.getValueAt(userIndex).data;
|
||||
observers.insert(user->getId(), user);
|
||||
}
|
||||
return observers;
|
||||
return util::Map<std::string, TrackedRecord<Payment>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -530,11 +280,11 @@ Description: Retrieves all service management observer records from the datastor
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, User*>: Collection of observer records
|
||||
- util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getServiceManagementObservers()
|
||||
util::Map<std::string, TrackedRecord<std::string>> DataStore::getServiceManagementObservers()
|
||||
{
|
||||
return getObservers(m_serviceManagementObservers);
|
||||
return util::Map<std::string, TrackedRecord<std::string>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -543,11 +293,11 @@ Description: Retrieves all payment management observer records from the datastor
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, User*>: Collection of observer records
|
||||
- util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getPaymentManagementObservers()
|
||||
util::Map<std::string, TrackedRecord<std::string>> DataStore::getPaymentManagementObservers()
|
||||
{
|
||||
return getObservers(m_paymentManagementObservers);
|
||||
return util::Map<std::string, TrackedRecord<std::string>>();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -556,186 +306,181 @@ Description: Retrieves all inventory management observer records from the datast
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, User*>: Collection of observer records
|
||||
- util::Map<std::string, TrackedRecord<std::string>>: Collection of observer records
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getInventoryManagementObservers()
|
||||
util::Map<std::string, TrackedRecord<std::string>> DataStore::getInventoryManagementObservers()
|
||||
{
|
||||
return getObservers(m_inventoryManagementObservers);
|
||||
return util::Map<std::string, TrackedRecord<std::string>>();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveUsers
|
||||
Description: Persists all user records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- users: util::Map<std::string, TrackedRecord<User>>&, collection of user records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveUsers()
|
||||
void DataStore::saveUsers(util::Map<std::string, TrackedRecord<User>>& users)
|
||||
{
|
||||
saveRecords<User, SerializedUser>(m_users, m_userCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveNotifications
|
||||
Description: Persists all notification records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- notifications: util::Map<std::string, TrackedRecord<Notification>>&, collection of notification records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveNotifications()
|
||||
void DataStore::saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications)
|
||||
{
|
||||
saveRecords<Notification, SerializedNotification>(m_notifications, m_notificationCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveServices
|
||||
Description: Persists all service records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- services: util::Map<std::string, TrackedRecord<Service>>&, collection of service records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveServices()
|
||||
void DataStore::saveServices(util::Map<std::string, TrackedRecord<Service>>& services)
|
||||
{
|
||||
saveRecords<Service, SerializedService>(m_services, m_serviceCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveComboPackages
|
||||
Description: Persists all combo package records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- comboPackages: util::Map<std::string, TrackedRecord<ComboPackage>>&, collection of combo package records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveComboPackages()
|
||||
void DataStore::saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages)
|
||||
{
|
||||
saveRecords<ComboPackage, SerializedComboPackage>(m_comboPackages, m_comboPackageCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInventoryItems
|
||||
Description: Persists all inventory item records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- inventoryItems: util::Map<std::string, TrackedRecord<InventoryItem>>&, collection of inventory item records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveInventoryItems()
|
||||
void DataStore::saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems)
|
||||
{
|
||||
saveRecords<InventoryItem, SerializedInventoryItem>(m_inventoryItems, m_inventoryItemCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveServiceBookings
|
||||
Description: Persists all service booking records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- bookings: util::Map<std::string, TrackedRecord<ServiceBooking>>&, collection of service booking records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveServiceBookings()
|
||||
void DataStore::saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings)
|
||||
{
|
||||
saveRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings, m_serviceBookingCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveJobCards
|
||||
Description: Persists all job card records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- jobCards: util::Map<std::string, TrackedRecord<JobCard>>&, collection of job card records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveJobCards()
|
||||
void DataStore::saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards)
|
||||
{
|
||||
saveRecords<JobCard, SerializedJobCard>(m_jobCards, m_jobCardCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInvoices
|
||||
Description: Persists all invoice records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
- invoices: util::Map<std::string, TrackedRecord<Invoice>>&, collection of invoice records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveInvoices()
|
||||
void DataStore::saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices)
|
||||
{
|
||||
saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveObservers
|
||||
Description: Persists observer records to the specified observer mapping.
|
||||
Function: savePayments
|
||||
Description: Persists all payment records to the datastore.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, observer mapping to save to
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
- payments: util::Map<std::string, TrackedRecord<Payment>>&, collection of payment records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers)
|
||||
void DataStore::savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments)
|
||||
{
|
||||
size_t observerCount = static_cast<size_t>(observers.getSize());
|
||||
size_t capacity = config::file::INITIAL_CAPACITY;
|
||||
while (capacity < observerCount)
|
||||
{
|
||||
capacity *= config::file::GROWTH_FACTOR;
|
||||
}
|
||||
if (!SharedMemory::resizeMapping(mapping, capacity))
|
||||
{
|
||||
throw std::runtime_error("Failed to resize observer mapping");
|
||||
}
|
||||
SharedMemory::setRecordCount(mapping, observerCount);
|
||||
for (size_t index = 0; index < observerCount; index++)
|
||||
{
|
||||
SerializedObserver serializedObserver{};
|
||||
User* user = observers.getValueAt(static_cast<int>(index));
|
||||
strcpy_s(serializedObserver.id, sizeof(serializedObserver.id), user->getId().c_str());
|
||||
SerializedObserver* destination = static_cast<SerializedObserver*>(SharedMemory::getRecordAddress(mapping, index));
|
||||
*destination = serializedObserver;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveServiceManagementObservers
|
||||
Description: Persists all service management observer records to the datastore.
|
||||
Parameters:
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
- observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveServiceManagementObservers(util::Map<std::string, User*>& observers)
|
||||
void DataStore::saveServiceManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
|
||||
{
|
||||
saveObservers(m_serviceManagementObservers, observers);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: savePaymentManagementObservers
|
||||
Description: Persists all payment management observer records to the datastore.
|
||||
Parameters:
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
- observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::savePaymentManagementObservers(util::Map<std::string, User*>& observers)
|
||||
void DataStore::savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
|
||||
{
|
||||
saveObservers(m_paymentManagementObservers, observers);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInventoryManagementObservers
|
||||
Description: Persists all inventory management observer records to the datastore.
|
||||
Parameters:
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
- observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveInventoryManagementObservers(util::Map<std::string, User*>& observers)
|
||||
void DataStore::saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers)
|
||||
{
|
||||
saveObservers(m_inventoryManagementObservers, observers);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: lockDataStore
|
||||
Description: Acquires exclusive access to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- bool: True if the datastore was successfully locked, otherwise false
|
||||
*/
|
||||
bool DataStore::lockDataStore()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: unlockDataStore
|
||||
Description: Releases exclusive access to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- bool: True if the datastore was successfully unlocked, otherwise false
|
||||
*/
|
||||
bool DataStore::unlockDataStore()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@@ -11,22 +11,21 @@ Date: 19-May-2026
|
||||
#include "Map.h"
|
||||
#include "MappingInfo.h"
|
||||
#include "TrackedRecord.h"
|
||||
#include "SerializedRecords.h"
|
||||
#include "SharedMemory.h"
|
||||
#include "User.h"
|
||||
#include "Notification.h"
|
||||
#include "Service.h"
|
||||
#include "ComboPackage.h"
|
||||
#include "InventoryItem.h"
|
||||
#include "ServiceBooking.h"
|
||||
#include "JobCard.h"
|
||||
#include "Invoice.h"
|
||||
class User;
|
||||
class Notification;
|
||||
class Service;
|
||||
class ComboPackage;
|
||||
class InventoryItem;
|
||||
class ServiceBooking;
|
||||
class JobCard;
|
||||
class Invoice;
|
||||
class Payment;
|
||||
|
||||
class DataStore
|
||||
{
|
||||
private:
|
||||
DataStore();
|
||||
~DataStore();
|
||||
DataStore(const DataStore&) = delete;
|
||||
DataStore& operator=(const DataStore&) = delete;
|
||||
DataStore(DataStore&&) = delete;
|
||||
@@ -40,43 +39,38 @@ private:
|
||||
MappingInfo m_serviceBookings;
|
||||
MappingInfo m_jobCards;
|
||||
MappingInfo m_invoices;
|
||||
MappingInfo m_payments;
|
||||
MappingInfo m_serviceManagementObservers;
|
||||
MappingInfo m_paymentManagementObservers;
|
||||
MappingInfo m_inventoryManagementObservers;
|
||||
util::Map<std::string, TrackedRecord<User>> m_userCache;
|
||||
util::Map<std::string, TrackedRecord<Notification>> m_notificationCache;
|
||||
util::Map<std::string, TrackedRecord<Service>> m_serviceCache;
|
||||
util::Map<std::string, TrackedRecord<ComboPackage>> m_comboPackageCache;
|
||||
util::Map<std::string, TrackedRecord<InventoryItem>> m_inventoryItemCache;
|
||||
util::Map<std::string, TrackedRecord<ServiceBooking>> m_serviceBookingCache;
|
||||
util::Map<std::string, TrackedRecord<JobCard>> m_jobCardCache;
|
||||
util::Map<std::string, TrackedRecord<Invoice>> m_invoiceCache;
|
||||
public:
|
||||
static DataStore& getInstance();
|
||||
bool initialize();
|
||||
void shutdown();
|
||||
util::Map<std::string, TrackedRecord<User>>& getUsers();
|
||||
util::Map<std::string, TrackedRecord<Notification>>& getNotifications();
|
||||
util::Map<std::string, TrackedRecord<Service>>& getServices();
|
||||
util::Map<std::string, TrackedRecord<ComboPackage>>& getComboPackages();
|
||||
util::Map<std::string, TrackedRecord<InventoryItem>>& getInventoryItems();
|
||||
util::Map<std::string, TrackedRecord<ServiceBooking>>& getServiceBookings();
|
||||
util::Map<std::string, TrackedRecord<JobCard>>& getJobCards();
|
||||
util::Map<std::string, TrackedRecord<Invoice>>& getInvoices();
|
||||
util::Map<std::string, User*> getServiceManagementObservers();
|
||||
util::Map<std::string, User*> getPaymentManagementObservers();
|
||||
util::Map<std::string, User*> getInventoryManagementObservers();
|
||||
void saveUsers();
|
||||
void saveNotifications();
|
||||
void saveServices();
|
||||
void saveComboPackages();
|
||||
void saveInventoryItems();
|
||||
void saveServiceBookings();
|
||||
void saveJobCards();
|
||||
void saveInvoices();
|
||||
void saveServiceManagementObservers(util::Map<std::string, User*>& observers);
|
||||
void savePaymentManagementObservers(util::Map<std::string, User*>& observers);
|
||||
void saveInventoryManagementObservers(util::Map<std::string, User*>& observers);
|
||||
util::Map<std::string, TrackedRecord<User>> getUsers();
|
||||
util::Map<std::string, TrackedRecord<Notification>> getNotifications();
|
||||
util::Map<std::string, TrackedRecord<Service>> getServices();
|
||||
util::Map<std::string, TrackedRecord<ComboPackage>> getComboPackages();
|
||||
util::Map<std::string, TrackedRecord<InventoryItem>> getInventoryItems();
|
||||
util::Map<std::string, TrackedRecord<ServiceBooking>> getServiceBookings();
|
||||
util::Map<std::string, TrackedRecord<JobCard>> getJobCards();
|
||||
util::Map<std::string, TrackedRecord<Invoice>> getInvoices();
|
||||
util::Map<std::string, TrackedRecord<Payment>> getPayments();
|
||||
util::Map<std::string, TrackedRecord<std::string>> getServiceManagementObservers();
|
||||
util::Map<std::string, TrackedRecord<std::string>> getPaymentManagementObservers();
|
||||
util::Map<std::string, TrackedRecord<std::string>> getInventoryManagementObservers();
|
||||
void saveUsers(util::Map<std::string, TrackedRecord<User>>& users);
|
||||
void saveNotifications(util::Map<std::string, TrackedRecord<Notification>>& notifications);
|
||||
void saveServices(util::Map<std::string, TrackedRecord<Service>>& services);
|
||||
void saveComboPackages(util::Map<std::string, TrackedRecord<ComboPackage>>& comboPackages);
|
||||
void saveInventoryItems(util::Map<std::string, TrackedRecord<InventoryItem>>& inventoryItems);
|
||||
void saveServiceBookings(util::Map<std::string, TrackedRecord<ServiceBooking>>& bookings);
|
||||
void saveJobCards(util::Map<std::string, TrackedRecord<JobCard>>& jobCards);
|
||||
void saveInvoices(util::Map<std::string, TrackedRecord<Invoice>>& invoices);
|
||||
void savePayments(util::Map<std::string, TrackedRecord<Payment>>& payments);
|
||||
void saveServiceManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
|
||||
void savePaymentManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
|
||||
void saveInventoryManagementObservers(util::Map<std::string, TrackedRecord<std::string>>& observers);
|
||||
bool lockDataStore();
|
||||
bool unlockDataStore();
|
||||
private:
|
||||
@@ -84,10 +78,6 @@ private:
|
||||
util::Map<std::string, TrackedRecord<TObject>> loadRecords(MappingInfo& mapping);
|
||||
template<typename TObject, typename TSerialized>
|
||||
void saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records);
|
||||
template<typename TObject> void clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache);
|
||||
template<typename TObject> void refreshCache(util::Map<std::string, TrackedRecord<TObject>>&cache, util::Map<std::string, TrackedRecord<TObject>>&refreshedCache);
|
||||
util::Map<std::string, User*> getObservers(MappingInfo& mapping);
|
||||
void saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers);
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -133,7 +123,9 @@ Description: Persists all modified and newly added records
|
||||
shared-memory mapping. Modified records overwrite
|
||||
their existing slots, while new records are
|
||||
appended to the end of the mapping. Records marked
|
||||
as CLEAN are ignored.
|
||||
as CLEAN are ignored. After persistence, all
|
||||
temporary objects owned by the tracked records are
|
||||
destroyed to release memory.
|
||||
Parameter:
|
||||
- mapping: Reference to the mapping where records are
|
||||
stored.
|
||||
@@ -166,88 +158,14 @@ template<typename TObject, typename TSerialized> void DataStore::saveRecords(Map
|
||||
continue;
|
||||
}
|
||||
size_t recordCount = SharedMemory::getRecordCount(mapping);
|
||||
TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,recordCount));
|
||||
TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping, recordCount));
|
||||
*destination = serialized;
|
||||
SharedMemory::setRecordCount(mapping, recordCount + 1);
|
||||
record.slotIndex = recordCount;
|
||||
}
|
||||
record.state = RecordState::CLEAN;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: clearCache
|
||||
Description: Releases all objects owned by the cache and
|
||||
clears the cache contents.
|
||||
Parameters:
|
||||
- cache: Cache to be cleared.
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
template<typename TObject>
|
||||
void DataStore::clearCache(util::Map<std::string, TrackedRecord<TObject>>&cache)
|
||||
{
|
||||
for (int index = 0; index < cache.getSize(); ++index)
|
||||
{
|
||||
delete cache.getValueAt(index).data;
|
||||
cache.getValueAt(index).data = nullptr;
|
||||
}
|
||||
cache.clear();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: refreshCache
|
||||
Description: Refreshes the cache while preserving object addresses
|
||||
for records that already exist. Existing objects are
|
||||
updated in-place so that pointers held elsewhere remain
|
||||
valid after the refresh.
|
||||
Parameters:
|
||||
- cache: Existing cache to refresh.
|
||||
- refreshedCache: Newly loaded cache contents.
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
template<typename TObject>
|
||||
void DataStore::refreshCache(util::Map<std::string, TrackedRecord<TObject>>& cache, util::Map<std::string, TrackedRecord<TObject>>& refreshedCache)
|
||||
{
|
||||
util::Map<std::string, TrackedRecord<TObject>> oldCache = cache;
|
||||
cache.clear();
|
||||
for (int index = 0; index < refreshedCache.getSize(); ++index)
|
||||
{
|
||||
const std::string& id = refreshedCache.getKeyAt(index);
|
||||
TrackedRecord<TObject>& refreshedRecord = refreshedCache.getValueAt(index);
|
||||
int oldIndex = oldCache.find(id);
|
||||
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;
|
||||
delete refreshedRecord.data;
|
||||
refreshedRecord.data = oldRecord.data;
|
||||
}
|
||||
cache.insert(id, refreshedRecord);
|
||||
}
|
||||
for (int index = 0; index < oldCache.getSize(); ++index)
|
||||
{
|
||||
const std::string& id = oldCache.getKeyAt(index);
|
||||
const TrackedRecord<TObject>& localTrackedRecord = oldCache.getValueAt(index);
|
||||
if (cache.find(id) == -1)
|
||||
{
|
||||
if (localTrackedRecord.state == RecordState::NEW_RECORD)
|
||||
{
|
||||
cache.insert(id, localTrackedRecord);
|
||||
}
|
||||
else
|
||||
{
|
||||
delete localTrackedRecord.data;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int index = 0; index < records.getSize(); ++index)
|
||||
{
|
||||
delete records.getValueAt(index).data;
|
||||
records.getValueAt(index).data = nullptr;
|
||||
}
|
||||
}
|
||||
-28
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
File: DataStoreLockGuard.h
|
||||
Description: Defines the DataStoreLockGuard class used to manage DataStore
|
||||
locking and unlocking automatically within a scope.
|
||||
Author: Trenser
|
||||
Date: 12-June-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "DataStore.h"
|
||||
|
||||
class DataStoreLockGuard
|
||||
{
|
||||
public:
|
||||
explicit DataStoreLockGuard(DataStore& dataStore)
|
||||
: m_dataStore(dataStore)
|
||||
{
|
||||
m_dataStore.lockDataStore();
|
||||
}
|
||||
~DataStoreLockGuard()
|
||||
{
|
||||
m_dataStore.unlockDataStore();
|
||||
}
|
||||
DataStoreLockGuard(const DataStoreLockGuard&) = delete;
|
||||
DataStoreLockGuard& operator=(const DataStoreLockGuard&) = delete;
|
||||
private:
|
||||
DataStore& m_dataStore;
|
||||
};
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
|
||||
struct FileHeader
|
||||
{
|
||||
size_t recordCount;
|
||||
size_t capacity;
|
||||
};
|
||||
-10
@@ -1,13 +1,3 @@
|
||||
/*
|
||||
File: MappingInfo.h
|
||||
Description: Defines the MappingInfo structure used for
|
||||
managing Windows file mapping operations.
|
||||
Stores handles, mapped view pointer,
|
||||
file metadata, and capacity information.
|
||||
Author: Trenser
|
||||
Created: 10-June-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <windows.h>
|
||||
#include <string>
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
#pragma once
|
||||
|
||||
enum class RecordState : int
|
||||
{
|
||||
CLEAN,
|
||||
NEW_RECORD,
|
||||
MODIFIED
|
||||
};
|
||||
-12
@@ -1,15 +1,3 @@
|
||||
/*
|
||||
File: SerializedRecords.h
|
||||
Description: Defines serialized structures for persistent storage
|
||||
and retrieval of system entities including User,
|
||||
Notification, Service, ComboPackage, InventoryItem,
|
||||
ServiceBooking, JobCard, Invoice, and Observer.
|
||||
These structures use fixed-size character arrays
|
||||
and primitive types for binary serialization.
|
||||
Author: Trenser
|
||||
Created: 10-June-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "Utility.h"
|
||||
#include "Enums.h"
|
||||
+1
-13
@@ -1,16 +1,4 @@
|
||||
/*
|
||||
File: SharedMemory.cpp
|
||||
Description: Implements shared memory utilities for managing
|
||||
Windows file mapping operations. Provides functions
|
||||
to create, open, resize, and close mappings, as well
|
||||
as access headers, records, and ensure synchronization
|
||||
across processes.
|
||||
Author: Trenser
|
||||
Created: 11-June-2026
|
||||
*/
|
||||
|
||||
#include "SharedMemory.h"
|
||||
#include "Windows.h"
|
||||
#include "Config.h"
|
||||
|
||||
/*
|
||||
@@ -320,7 +308,7 @@ bool SharedMemory::ensureCapacityForInsert(MappingInfo& mapping)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return resizeMapping(mapping, capacity * config::file::GROWTH_FACTOR);
|
||||
return resizeMapping(mapping, capacity * 2);
|
||||
}
|
||||
|
||||
/*
|
||||
-11
@@ -1,14 +1,3 @@
|
||||
/*
|
||||
File: SharedMemory.h
|
||||
Description: Declares functions for managing Windows file
|
||||
mapping and shared memory operations. Provides
|
||||
utilities for creating, resizing, and closing
|
||||
mappings, as well as accessing headers and
|
||||
record data.
|
||||
Author: Trenser
|
||||
Created: 10-June-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstddef>
|
||||
#include "MappingInfo.h"
|
||||
-10
@@ -1,13 +1,3 @@
|
||||
/*
|
||||
File: TrackedRecord.h
|
||||
Description: Defines the TrackedRecord template structure used
|
||||
to manage objects with associated record state and
|
||||
slot index. Supports tracking of CLEAN, NEW_RECORD,
|
||||
and MODIFIED states for persistence and synchronization.
|
||||
Author: Trenser
|
||||
Created: 10-June-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "RecordState.h"
|
||||
|
||||
@@ -29,8 +29,7 @@ Returns:
|
||||
ComboPackage::ComboPackage()
|
||||
: m_id("CMP" + std::to_string(++m_uid)),
|
||||
m_status(util::State::ACTIVE),
|
||||
m_discountPercentage(0.0) {
|
||||
}
|
||||
m_discountPercentage(0.0) {}
|
||||
|
||||
/*
|
||||
Function: ComboPackage
|
||||
|
||||
@@ -12,7 +12,7 @@ Date: 19-May-2026
|
||||
#include "Enums.h"
|
||||
|
||||
class Service;
|
||||
struct SerializedComboPackage;
|
||||
class SerializedComboPackage;
|
||||
|
||||
class ComboPackage
|
||||
{
|
||||
|
||||
@@ -28,8 +28,7 @@ InventoryItem::InventoryItem()
|
||||
: m_id("IIM" + std::to_string(++m_uid)),
|
||||
m_quantity(0),
|
||||
m_status(util::State::ACTIVE),
|
||||
m_price(0.0) {
|
||||
}
|
||||
m_price(0.0) {}
|
||||
|
||||
/*
|
||||
Function: InventoryItem
|
||||
@@ -47,8 +46,7 @@ InventoryItem::InventoryItem(const std::string& partName, int quantity, double p
|
||||
m_partName(partName),
|
||||
m_quantity(quantity),
|
||||
m_status(util::State::ACTIVE),
|
||||
m_price(price) {
|
||||
}
|
||||
m_price(price) {}
|
||||
|
||||
/*
|
||||
Function: InventoryItem (parameterized constructor with ID)
|
||||
|
||||
@@ -35,8 +35,7 @@ Invoice::Invoice()
|
||||
m_discountPercentage(0.0),
|
||||
m_totalAmount(0.0),
|
||||
m_paymentMethod(util::PaymentMode()),
|
||||
m_status(util::PaymentStatus()) {
|
||||
}
|
||||
m_status(util::PaymentStatus()) {}
|
||||
|
||||
/*
|
||||
Function: Invoice
|
||||
@@ -68,7 +67,7 @@ Invoice::Invoice(
|
||||
const util::Timestamp& paymentDate,
|
||||
util::PaymentMode paymentMethod,
|
||||
util::PaymentStatus status
|
||||
)
|
||||
)
|
||||
: m_id("INV" + std::to_string(++m_uid)),
|
||||
m_bookingId(bookingId),
|
||||
m_booking(booking),
|
||||
|
||||
@@ -6,6 +6,7 @@ Author: Trenser
|
||||
Date: 19-May-2026
|
||||
*/
|
||||
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
#include "Map.h"
|
||||
@@ -41,7 +42,7 @@ public:
|
||||
ServiceBooking* booking,
|
||||
const util::Timestamp& invoiceDate,
|
||||
double laborCost,
|
||||
const util::Map<std::string, InventoryItem*>& parts,
|
||||
const util::Map<std::string,InventoryItem*>& parts,
|
||||
double partsCost,
|
||||
double discountPercentage,
|
||||
double totalAmount,
|
||||
|
||||
@@ -29,8 +29,7 @@ JobCard::JobCard()
|
||||
m_booking(nullptr),
|
||||
m_service(nullptr),
|
||||
m_technician(nullptr),
|
||||
m_status(util::ServiceJobStatus()) {
|
||||
}
|
||||
m_status(util::ServiceJobStatus()) {}
|
||||
|
||||
/*
|
||||
Function: JobCard
|
||||
@@ -67,8 +66,7 @@ JobCard::JobCard(const std::string& bookingId,
|
||||
m_technician(technician),
|
||||
m_assignedDate(assignedDate),
|
||||
m_status(status),
|
||||
m_completionDate(completionDate) {
|
||||
}
|
||||
m_completionDate(completionDate) {}
|
||||
|
||||
/*
|
||||
Function: JobCard (parameterized constructor with ID)
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
/*
|
||||
File: Notification.cpp
|
||||
Description: Implements the Notification class which represents system notifications in the Vehicle Service Management System.
|
||||
Provides constructors, accessors, and mutators for notification details such as ID, recipientID, title, message, and timestamp.
|
||||
Provides constructors, accessors, and mutators for notification details such as ID, recipient, title, message, and timestamp.
|
||||
Author: Trenser
|
||||
Date: 19-May-2026
|
||||
*/
|
||||
@@ -24,7 +24,7 @@ Returns:
|
||||
*/
|
||||
Notification::Notification()
|
||||
: m_id("NOT" + std::to_string(++m_uid)),
|
||||
m_state(util::State::ACTIVE) {}
|
||||
m_recipient(nullptr), m_state(util::State::ACTIVE) {}
|
||||
|
||||
/*
|
||||
Function: Notification
|
||||
@@ -38,14 +38,14 @@ Parameters:
|
||||
Returns:
|
||||
- A new Notification object.
|
||||
*/
|
||||
Notification::Notification(const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
|
||||
Notification::Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt)
|
||||
: m_id("NOT" + std::to_string(++m_uid)),
|
||||
m_recipientUserId(recipientUserId),
|
||||
m_recipient(recipient),
|
||||
m_title(title),
|
||||
m_message(message),
|
||||
m_state(util::State::ACTIVE),
|
||||
m_createdAt(createdAt) {
|
||||
}
|
||||
m_createdAt(createdAt){}
|
||||
|
||||
/*
|
||||
Function: Notification (parameterized constructor with ID)
|
||||
@@ -63,6 +63,7 @@ Returns:
|
||||
Notification::Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt, const util::State& state)
|
||||
: m_id(id),
|
||||
m_recipientUserId(recipientUserId),
|
||||
m_recipient(nullptr),
|
||||
m_title(title),
|
||||
m_message(message),
|
||||
m_createdAt(createdAt),
|
||||
@@ -97,6 +98,17 @@ const std::string& Notification::getRecipientUserId() const
|
||||
return m_recipientUserId;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getRecipient
|
||||
Description: Retrieves the pointer to the recipient user.
|
||||
Returns:
|
||||
- User* representing the recipient.
|
||||
*/
|
||||
User* Notification::getRecipient() const
|
||||
{
|
||||
return m_recipient;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getTitle
|
||||
Description: Retrieves the title of the notification.
|
||||
@@ -130,17 +142,6 @@ const util::Timestamp& Notification::getCreatedAt() const
|
||||
return m_createdAt;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getState
|
||||
Description: Retrieves the Notification state
|
||||
Returns:
|
||||
- const util::Timestamp& representing the creation timestamp.
|
||||
*/
|
||||
util::State Notification::getState() const
|
||||
{
|
||||
return m_state;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: setId
|
||||
Description: Sets the unique ID of the notification.
|
||||
@@ -167,6 +168,19 @@ void Notification::setRecipientUserId(const std::string& recipientUserId)
|
||||
m_recipientUserId = recipientUserId;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: setRecipient
|
||||
Description: Sets the recipient user pointer for the notification.
|
||||
Parameters:
|
||||
- recipient: Pointer to the User object.
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void Notification::setRecipient(User* recipient)
|
||||
{
|
||||
m_recipient = recipient;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: setTitle
|
||||
Description: Sets the title of the notification.
|
||||
@@ -206,19 +220,6 @@ void Notification::setCreatedAt(const util::Timestamp& createdAt)
|
||||
m_createdAt = createdAt;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: setState
|
||||
Description: Sets the Notification state.
|
||||
Parameters:
|
||||
- state: Notification state value.
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void Notification::setState(util::State state)
|
||||
{
|
||||
m_state = state;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: serialize
|
||||
Description: Serializes the Notification object into a SerializedNotification record.
|
||||
|
||||
@@ -20,25 +20,28 @@ private:
|
||||
static int m_uid;
|
||||
std::string m_id;
|
||||
std::string m_recipientUserId;
|
||||
User* m_recipient;
|
||||
std::string m_title;
|
||||
std::string m_message;
|
||||
util::Timestamp m_createdAt;
|
||||
util::State m_state;
|
||||
public:
|
||||
Notification();
|
||||
Notification(const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
|
||||
Notification(const std::string& recipientUserId, User* recipient, const std::string& title, const std::string& message, const util::Timestamp& createdAt);
|
||||
Notification(const std::string& id, const std::string& recipientUserId, const std::string& title, const std::string& message, const util::Timestamp& createdAt, const util::State& state);
|
||||
const std::string& getId() const;
|
||||
const std::string& getRecipientUserId() const;
|
||||
User* getRecipient() const;
|
||||
const std::string& getTitle() const;
|
||||
const std::string& getMessage() const;
|
||||
const util::Timestamp& getCreatedAt() const;
|
||||
void setId(const std::string& id);
|
||||
void setRecipientUserId(const std::string& recipientUserId);
|
||||
void setRecipient(User* recipient);
|
||||
void setTitle(const std::string& title);
|
||||
void setMessage(const std::string& message);
|
||||
void setCreatedAt(const util::Timestamp& createdAt);
|
||||
util::State getState() const;
|
||||
util::State getState();
|
||||
void setState(util::State state);
|
||||
SerializedNotification serialize() const;
|
||||
static Notification* deserialize(const SerializedNotification&);
|
||||
|
||||
@@ -28,8 +28,7 @@ Returns:
|
||||
Service::Service()
|
||||
: m_id("SRV" + std::to_string(++m_uid)),
|
||||
m_status(util::State::ACTIVE),
|
||||
m_laborCost(0.0) {
|
||||
}
|
||||
m_laborCost(0.0) {}
|
||||
|
||||
/*
|
||||
Function: Service
|
||||
|
||||
@@ -6,6 +6,7 @@ Author: Trenser
|
||||
Date: 19-May-2026
|
||||
*/
|
||||
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
#include "Map.h"
|
||||
|
||||
@@ -6,7 +6,6 @@ Description: Implementation file containing the method definitions of the
|
||||
Author: Trenser
|
||||
Date:19-May-2026
|
||||
*/
|
||||
|
||||
#include <stdexcept>
|
||||
#include <sstream>
|
||||
#include "SerializedRecords.h"
|
||||
@@ -30,8 +29,7 @@ ServiceBooking::ServiceBooking()
|
||||
m_customer(nullptr),
|
||||
m_assignedTechnician(nullptr),
|
||||
m_status(util::ServiceJobStatus::PENDING),
|
||||
m_discountPercentage(0.0) {
|
||||
}
|
||||
m_discountPercentage(0.0) {}
|
||||
|
||||
/*
|
||||
Function: ServiceBooking
|
||||
|
||||
@@ -6,7 +6,6 @@ Description: Header file declaring the ServiceBooking class, which represents
|
||||
Author: Trenser
|
||||
Date:19-May-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
#include "Map.h"
|
||||
|
||||
@@ -29,8 +29,7 @@ Returns:
|
||||
User::User()
|
||||
: m_id("USR" + std::to_string(++m_uid)),
|
||||
m_type(util::UserType::CUSTOMER),
|
||||
m_status(util::State::ACTIVE) {
|
||||
}
|
||||
m_status(util::State::ACTIVE) {}
|
||||
|
||||
/*
|
||||
Function: User
|
||||
@@ -53,8 +52,7 @@ User::User(const std::string& userName, const std::string& password, const std::
|
||||
m_phone(phone),
|
||||
m_email(email),
|
||||
m_type(role),
|
||||
m_status(util::State::ACTIVE) {
|
||||
}
|
||||
m_status(util::State::ACTIVE) {}
|
||||
|
||||
/*
|
||||
Function: User (parameterized constructor with ID)
|
||||
@@ -89,6 +87,23 @@ User::User(const std::string& userId, const std::string& userName, const std::st
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: ~User
|
||||
Description: Destructor that cleans up dynamically allocated notifications associated with the user.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
User::~User()
|
||||
{
|
||||
auto values = m_notifications.getValues();
|
||||
for (int index = 0; index < values.getSize(); index++)
|
||||
{
|
||||
delete values[index];
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getId
|
||||
Description: Retrieves the unique ID of the user.
|
||||
@@ -155,6 +170,17 @@ const std::string& User::getEmail() const
|
||||
return m_email;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getNotifications
|
||||
Description: Retrieves the map of notifications associated with the user.
|
||||
Returns:
|
||||
- util::Map<std::string, Notification*>& representing the notifications.
|
||||
*/
|
||||
util::Map<std::string, Notification*>& User::getNotifications()
|
||||
{
|
||||
return m_notifications;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getUserType
|
||||
Description: Retrieves the role of the user.
|
||||
@@ -255,6 +281,22 @@ void User::setEmail(const std::string& email)
|
||||
m_email = email;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: addNotification
|
||||
Description: Adds a new notification to the user’s notification map.
|
||||
Parameters:
|
||||
- notification: Pointer to the Notification object.
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void User::addNotification(Notification* notification)
|
||||
{
|
||||
if (notification)
|
||||
{
|
||||
m_notifications.insert(notification->getId(), notification);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: setRole
|
||||
Description: Sets the role of the user.
|
||||
|
||||
@@ -26,19 +26,21 @@ private:
|
||||
std::string m_name;
|
||||
std::string m_phone;
|
||||
std::string m_email;
|
||||
util::Map<std::string, Notification*> m_notifications;
|
||||
util::UserType m_type;
|
||||
util::State m_status;
|
||||
public:
|
||||
User();
|
||||
User(const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role);
|
||||
User(const std::string& userId, const std::string& userName, const std::string& password, const std::string& name, const std::string& phone, const std::string& email, util::UserType role, util::State status);
|
||||
~User() = default;
|
||||
~User();
|
||||
const std::string& getId() const;
|
||||
const std::string& getUserName() const;
|
||||
const std::string& getPassword() const;
|
||||
const std::string& getName() const;
|
||||
const std::string& getPhone() const;
|
||||
const std::string& getEmail() const;
|
||||
util::Map<std::string, Notification*>& getNotifications();
|
||||
util::UserType getUserType() const;
|
||||
util::State getState() const;
|
||||
void setId(const std::string& id);
|
||||
@@ -47,6 +49,7 @@ public:
|
||||
void setName(const std::string& name);
|
||||
void setPhone(const std::string& phone);
|
||||
void setEmail(const std::string& email);
|
||||
void addNotification(Notification* notification) override;
|
||||
void setRole(util::UserType role);
|
||||
void setState(util::State status);
|
||||
SerializedUser serialize() const;
|
||||
|
||||
+4
-75
@@ -10,32 +10,8 @@ Date:19-May-2026
|
||||
#include <stdexcept>
|
||||
#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
|
||||
@@ -48,35 +24,16 @@ Return type: bool - true if login successful, false otherwise
|
||||
*/
|
||||
bool AuthenticationManagementService::login(const std::string& username, const std::string& password)
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUserMap = m_dataStore.getUsers();
|
||||
int trackedUserMapSize = trackedUserMap.getSize();
|
||||
for (int index = 0; index < trackedUserMapSize; index++)
|
||||
util::Map<std::string, User*> users = m_dataStore.getUsers();
|
||||
int usersMapSize = users.getSize();
|
||||
for (int index = 0; index < usersMapSize; index++)
|
||||
{
|
||||
User* user = trackedUserMap.getValueAt(index).data;
|
||||
User* user = users.getValueAt(index);
|
||||
if (username == user->getUserName())
|
||||
{
|
||||
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);
|
||||
}
|
||||
},
|
||||
[]()
|
||||
{
|
||||
if (m_notificationsAvailableEvent)
|
||||
{
|
||||
SetEvent(m_notificationsAvailableEvent);
|
||||
}
|
||||
});
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
@@ -105,11 +62,7 @@ Return type: void
|
||||
*/
|
||||
void AuthenticationManagementService::logout()
|
||||
{
|
||||
m_eventManager.shutdown();
|
||||
m_authenticatedUser = nullptr;
|
||||
m_isAuthorized = false;
|
||||
m_accountDisabledEvent = NULL;
|
||||
m_notificationsAvailableEvent = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -121,33 +74,9 @@ 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)
|
||||
{
|
||||
throw std::runtime_error("There is no user currently logged in!");
|
||||
}
|
||||
int index = trackedUsersMap.find(m_authenticatedUser->getId());
|
||||
if (index == -1)
|
||||
{
|
||||
throw std::runtime_error("User does not exist!\n");
|
||||
}
|
||||
m_authenticatedUser->setPassword(newPassword);
|
||||
trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
|
||||
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)
|
||||
{
|
||||
m_accountDisabledEvent = accountDisabledEvent;
|
||||
m_notificationsAvailableEvent = notificationAvailableEvent;
|
||||
}
|
||||
|
||||
-8
@@ -9,8 +9,6 @@ Date:19-May-2026
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
#include <windows.h>
|
||||
#include "EventManager.h"
|
||||
#include "DataStore.h"
|
||||
|
||||
class User;
|
||||
@@ -19,17 +17,11 @@ 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);
|
||||
User* getAuthenticatedUser();
|
||||
void registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent);
|
||||
};
|
||||
|
||||
+130
-82
@@ -12,15 +12,14 @@ Date: 22-May-2026
|
||||
#include "Config.h"
|
||||
#include "Enums.h"
|
||||
#include "Factory.h"
|
||||
#include "FileManager.h"
|
||||
#include "InventoryItem.h"
|
||||
#include "InventoryManagementService.h"
|
||||
#include "AuthenticationManagementService.h"
|
||||
#include "Timestamp.h"
|
||||
#include "User.h"
|
||||
#include "Utility.h"
|
||||
#include "Vector.h"
|
||||
#include "DataStoreLockGuard.h"
|
||||
#include "EventManager.h"
|
||||
|
||||
|
||||
util::Map<std::string, User*> InventoryManagementService::m_observers{};
|
||||
|
||||
@@ -59,19 +58,18 @@ Returns:
|
||||
*/
|
||||
void InventoryManagementService::sendLowStockAlerts()
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedInventoryItemsMap = m_dataStore.getInventoryItems();
|
||||
auto& trackedUserMap = m_dataStore.getUsers();
|
||||
if (trackedInventoryItemsMap.isEmpty())
|
||||
auto& inventoryItems = m_dataStore.getInventoryItems();
|
||||
if (inventoryItems.isEmpty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
int inventoryItemsSize = trackedInventoryItemsMap.getSize();
|
||||
int usersMapSize = trackedUserMap.getSize();
|
||||
int inventoryItemsSize = inventoryItems.getSize();
|
||||
auto& usersMap = m_dataStore.getUsers();
|
||||
int usersMapSize = usersMap.getSize();
|
||||
util::Vector<User*> adminUsers;
|
||||
for (int index = 0; index < usersMapSize; index++)
|
||||
{
|
||||
User* user = trackedUserMap.getValueAt(index).data;
|
||||
User* user = usersMap.getValueAt(index);
|
||||
if (user->getUserType() == util::UserType::ADMIN)
|
||||
{
|
||||
adminUsers.push_back(user);
|
||||
@@ -84,7 +82,7 @@ void InventoryManagementService::sendLowStockAlerts()
|
||||
}
|
||||
for (int index = 0; index < inventoryItemsSize; index++)
|
||||
{
|
||||
InventoryItem* inventoryItem = trackedInventoryItemsMap.getValueAt(index).data;
|
||||
InventoryItem* inventoryItem = inventoryItems.getValueAt(index);
|
||||
if (inventoryItem && inventoryItem->getQuantity() < config::threshold::INVENTORY_LOW_STOCK_THRESHOLD)
|
||||
{
|
||||
sendLowStockAlertsToAdmins(*this, inventoryItem, adminUsers);
|
||||
@@ -92,6 +90,95 @@ void InventoryManagementService::sendLowStockAlerts()
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getObserverIDs
|
||||
Description: Retrieves the IDs of all observers currently attached to the
|
||||
InventoryManagementService.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Vector<std::string>: Vector of observer user IDs
|
||||
*/
|
||||
util::Vector<std::string> InventoryManagementService::getObserverIDs()
|
||||
{
|
||||
util::Vector<std::string> observerIDs;
|
||||
int numberOfObservers = m_observers.getSize();
|
||||
for (int index = 0; index < numberOfObservers; index++)
|
||||
{
|
||||
User* observer = m_observers.getValueAt(index);
|
||||
if (observer)
|
||||
{
|
||||
observerIDs.push_back(observer->getId());
|
||||
}
|
||||
}
|
||||
return observerIDs;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: loadInventoryItems
|
||||
Description: Loads inventory items from persistent storage into the datastore.
|
||||
Uses FileManager to deserialize inventory items from the configured file.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void InventoryManagementService::loadInventoryItems()
|
||||
{
|
||||
util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
|
||||
auto& inventoryItems = m_dataStore.getInventoryItems();
|
||||
auto inventoryItemsMap = inventoryItemFileManager.load();
|
||||
int numberOfInventoryItems = inventoryItemsMap.getSize();
|
||||
for (int index = 0; index < numberOfInventoryItems; index++)
|
||||
{
|
||||
inventoryItems[inventoryItemsMap.getKeyAt(index)] = inventoryItemsMap.getValueAt(index);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInventoryItems
|
||||
Description: Saves inventory items from the datastore to persistent storage.
|
||||
Uses FileManager to serialize inventory items into the configured file.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void InventoryManagementService::saveInventoryItems()
|
||||
{
|
||||
util::FileManager<InventoryItem> inventoryItemFileManager(config::file::INVENTORYITEM_FILE);
|
||||
auto& inventoryItems = m_dataStore.getInventoryItems();
|
||||
inventoryItemFileManager.save(inventoryItems);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: loadObservers
|
||||
Description: Loads observer IDs from persistent storage and attaches corresponding
|
||||
users as observers to the InventoryManagementService.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void InventoryManagementService::loadObservers()
|
||||
{
|
||||
util::loadObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this, m_dataStore);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveObservers
|
||||
Description: Saves the current observer IDs of the InventoryManagementService
|
||||
to persistent storage for future retrieval.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void InventoryManagementService::saveObservers()
|
||||
{
|
||||
util::saveObservers(config::file::INVENTORYMANAGEMENTOBSERVERS, this);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: addInventoryItem
|
||||
Description: Creates a new inventory item using the Factory and inserts it
|
||||
@@ -103,12 +190,8 @@ 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);
|
||||
trackedInventoryItemMap.insert(newItem->getId(), util::createNewRecord(newItem));
|
||||
m_dataStore.saveInventoryItems();
|
||||
m_dataStore.getInventoryItems().insert(newItem->getId(), newItem);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -120,23 +203,16 @@ 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);
|
||||
if (index == -1)
|
||||
int index = m_dataStore.getInventoryItems().find(selectedItemId);
|
||||
if (index != -1)
|
||||
{
|
||||
throw std::runtime_error("Inventory update failed: Item ID '" + selectedItemId + "' not found.");
|
||||
}
|
||||
InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
|
||||
if (item == nullptr)
|
||||
InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
|
||||
if (item != nullptr)
|
||||
{
|
||||
throw std::runtime_error("Inventory update failed. Item does not exist.\n");
|
||||
}
|
||||
int totalQuantity = item->getQuantity() + quantity;
|
||||
item->setQuantity(totalQuantity);
|
||||
trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
|
||||
m_dataStore.saveInventoryItems();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -147,11 +223,7 @@ 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);
|
||||
return inventoryMap;
|
||||
return m_dataStore.getInventoryItems();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -162,22 +234,15 @@ 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);
|
||||
if (index == -1)
|
||||
int index = m_dataStore.getInventoryItems().find(inventoryItemID);
|
||||
if (index != -1)
|
||||
{
|
||||
throw std::runtime_error("Inventory removal failed: Item ID '" + inventoryItemID + "' not found.");
|
||||
}
|
||||
InventoryItem* item = trackedInventoryItemMap.getValueAt(index).data;
|
||||
if (item == nullptr)
|
||||
InventoryItem* item = m_dataStore.getInventoryItems().getValueAt(index);
|
||||
if (item != nullptr)
|
||||
{
|
||||
throw std::runtime_error("Inventory removal failed: Item ID does not exist.");
|
||||
}
|
||||
item->setState(util::State::INACTIVE);
|
||||
trackedInventoryItemMap.getValueAt(index).state = RecordState::MODIFIED;
|
||||
m_dataStore.saveInventoryItems();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -188,20 +253,12 @@ 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);
|
||||
if (index == -1)
|
||||
int index = m_dataStore.getInventoryItems().find(inventoryItemID);
|
||||
if (index != -1)
|
||||
{
|
||||
return m_dataStore.getInventoryItems().getValueAt(index);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
InventoryItem* inventoryItem = trackedInventoryItemMap.getValueAt(index).data;
|
||||
if (inventoryItem == nullptr)
|
||||
{
|
||||
throw std::runtime_error("Item ID does not exist.");
|
||||
}
|
||||
return inventoryItem;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -214,9 +271,6 @@ Returns:
|
||||
*/
|
||||
void InventoryManagementService::attach(User* user)
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
m_observers.clear();
|
||||
m_observers = m_dataStore.getInventoryManagementObservers();
|
||||
if (user)
|
||||
{
|
||||
const std::string& userID = user->getId();
|
||||
@@ -225,7 +279,6 @@ void InventoryManagementService::attach(User* user)
|
||||
m_observers[userID] = user;
|
||||
}
|
||||
}
|
||||
m_dataStore.saveInventoryManagementObservers(m_observers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -238,9 +291,6 @@ Returns:
|
||||
*/
|
||||
void InventoryManagementService::detach(User* user)
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
m_observers.clear();
|
||||
m_observers = m_dataStore.getInventoryManagementObservers();
|
||||
if (user)
|
||||
{
|
||||
const std::string& userID = user->getId();
|
||||
@@ -249,7 +299,6 @@ void InventoryManagementService::detach(User* user)
|
||||
m_observers.remove(userID);
|
||||
}
|
||||
}
|
||||
m_dataStore.saveInventoryManagementObservers(m_observers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -266,28 +315,27 @@ Throws:
|
||||
*/
|
||||
void InventoryManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
|
||||
{
|
||||
if (!user)
|
||||
if (user)
|
||||
{
|
||||
return;
|
||||
}
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
m_observers = m_dataStore.getInventoryManagementObservers();
|
||||
if (m_observers.find(user->getId()) == -1)
|
||||
if (m_observers.find(user->getId()) != -1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
Notification* notification = Factory::getObject<Notification>(
|
||||
Notification* notification =
|
||||
Factory::getObject<Notification>(
|
||||
user->getId(),
|
||||
user,
|
||||
title,
|
||||
message,
|
||||
util::Timestamp());
|
||||
if (!notification)
|
||||
util::Timestamp()
|
||||
);
|
||||
if (notification)
|
||||
{
|
||||
user->addNotification(notification);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error("Failed to create notification");
|
||||
}
|
||||
trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
|
||||
m_dataStore.saveNotifications();
|
||||
EventManager::sendNotificationAvailableEvent(user->getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+5
@@ -21,6 +21,7 @@ class InventoryManagementService : public NotificationManagementService
|
||||
private:
|
||||
DataStore& m_dataStore;
|
||||
static util::Map<std::string, User*> m_observers;
|
||||
util::Vector<std::string> getObserverIDs() override;
|
||||
public:
|
||||
InventoryManagementService() : m_dataStore(DataStore::getInstance()) {}
|
||||
util::Map<std::string, InventoryItem*> getInventoryItems();
|
||||
@@ -32,4 +33,8 @@ public:
|
||||
void sendNotification(User* user, const std::string& title, const std::string& message) override;
|
||||
void attach(User* user) override;
|
||||
void detach(User* user) override;
|
||||
void loadInventoryItems();
|
||||
void saveInventoryItems();
|
||||
void loadObservers();
|
||||
void saveObservers();
|
||||
};
|
||||
|
||||
+1
@@ -0,0 +1 @@
|
||||
#include "NotificationManagementService.h"
|
||||
+1
@@ -19,4 +19,5 @@ public:
|
||||
virtual void sendNotification(User* recipient, const std::string& title, const std::string& message) = 0;
|
||||
virtual void attach(User* user) = 0;
|
||||
virtual void detach(User* user) = 0;
|
||||
virtual util::Vector<std::string> getObserverIDs() = 0;
|
||||
};
|
||||
|
||||
+153
-67
@@ -11,19 +11,16 @@ Date: 20-May-2026
|
||||
#include "Config.h"
|
||||
#include "Enums.h"
|
||||
#include "Factory.h"
|
||||
#include "FileManager.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{};
|
||||
|
||||
@@ -37,9 +34,6 @@ Returns:
|
||||
*/
|
||||
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();
|
||||
@@ -48,7 +42,6 @@ void PaymentManagementService::attach(User* user)
|
||||
m_observers[userID] = user;
|
||||
}
|
||||
}
|
||||
m_dataStore.savePaymentManagementObservers(m_observers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -61,9 +54,6 @@ Returns:
|
||||
*/
|
||||
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();
|
||||
@@ -72,7 +62,6 @@ void PaymentManagementService::detach(User* user)
|
||||
m_observers.remove(userID);
|
||||
}
|
||||
}
|
||||
m_dataStore.savePaymentManagementObservers(m_observers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -89,29 +78,28 @@ Throws:
|
||||
*/
|
||||
void PaymentManagementService::sendNotification(User* user, const std::string& title, const std::string& message)
|
||||
{
|
||||
if (!user)
|
||||
if (user)
|
||||
{
|
||||
return;
|
||||
}
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
m_observers = m_dataStore.getPaymentManagementObservers();
|
||||
if (m_observers.find(user->getId()) == -1)
|
||||
if (m_observers.find(user->getId()) != -1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
auto& trackedNotificationsMap = m_dataStore.getNotifications();
|
||||
Notification* notification = Factory::getObject<Notification>(
|
||||
Notification* notification =
|
||||
Factory::getObject<Notification>(
|
||||
user->getId(),
|
||||
user,
|
||||
title,
|
||||
message,
|
||||
util::Timestamp());
|
||||
if (!notification)
|
||||
util::Timestamp()
|
||||
);
|
||||
if (notification)
|
||||
{
|
||||
user->addNotification(notification);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw std::runtime_error("Failed to create notification");
|
||||
}
|
||||
trackedNotificationsMap.insert(notification->getId(), util::createNewRecord(notification));
|
||||
m_dataStore.saveNotifications();
|
||||
EventManager::sendNotificationAvailableEvent(user->getId());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -125,12 +113,11 @@ Returns:
|
||||
*/
|
||||
void PaymentManagementService::sendPaymentReminders()
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedInvoicesMap = m_dataStore.getInvoices();
|
||||
int invoicesMapSize = trackedInvoicesMap.getSize();
|
||||
auto& invoicesMap = m_dataStore.getInvoices();
|
||||
int invoicesMapSize = invoicesMap.getSize();
|
||||
for (int index = 0; index < invoicesMapSize; index++)
|
||||
{
|
||||
const Invoice* invoice = trackedInvoicesMap.getValueAt(index).data;
|
||||
const Invoice* invoice = invoicesMap.getValueAt(index);
|
||||
if (invoice && invoice->getStatus() == util::PaymentStatus::PENDING)
|
||||
{
|
||||
util::Timestamp invoiceCreationTimestamp = invoice->getInvoiceDate();
|
||||
@@ -153,6 +140,123 @@ void PaymentManagementService::sendPaymentReminders()
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getObserverIDs
|
||||
Description: Retrieves the IDs of all observers currently attached to the
|
||||
PaymentManagementService.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Vector<std::string>: Vector of observer user IDs
|
||||
*/
|
||||
util::Vector<std::string> PaymentManagementService::getObserverIDs()
|
||||
{
|
||||
util::Vector<std::string> observerIDs;
|
||||
int numberOfObservers = m_observers.getSize();
|
||||
for (int index = 0; index < numberOfObservers; index++)
|
||||
{
|
||||
User* observer = m_observers.getValueAt(index);
|
||||
if (observer)
|
||||
{
|
||||
observerIDs.push_back(observer->getId());
|
||||
}
|
||||
}
|
||||
return observerIDs;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: loadInvoices
|
||||
Description: Loads invoices from persistent storage into the datastore.
|
||||
Validates associated service bookings and inventory parts before
|
||||
attaching them to each invoice. Throws exceptions if invalid IDs
|
||||
are encountered.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
Throws:
|
||||
- std::runtime_error if a booking ID or part ID is invalid
|
||||
*/
|
||||
void PaymentManagementService::loadInvoices()
|
||||
{
|
||||
util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
|
||||
auto& invoices = m_dataStore.getInvoices();
|
||||
auto& serviceBookings = m_dataStore.getServiceBookings();
|
||||
auto& inventoryItems = m_dataStore.getInventoryItems();
|
||||
auto invoicesMap = invoiceFileManager.load();
|
||||
for (int invoiceIndex = 0; invoiceIndex < invoicesMap.getSize(); invoiceIndex++)
|
||||
{
|
||||
Invoice* invoice = invoicesMap.getValueAt(invoiceIndex);
|
||||
int bookingIndex = serviceBookings.find(invoice->getBookingId());
|
||||
if (bookingIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid Booking ID");
|
||||
}
|
||||
ServiceBooking* booking = serviceBookings.getValueAt(bookingIndex);
|
||||
invoice->setBooking(booking);
|
||||
util::Map<std::string, InventoryItem*> invoiceParts;
|
||||
auto& partIDs = invoice->getPartIDs();
|
||||
for (int partIndex = 0; partIndex < partIDs.getSize(); partIndex++)
|
||||
{
|
||||
const std::string& partID = partIDs[partIndex];
|
||||
int inventoryIndex = inventoryItems.find(partID);
|
||||
if (inventoryIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid Part ID");
|
||||
}
|
||||
invoiceParts[partID] = inventoryItems.getValueAt(inventoryIndex);
|
||||
}
|
||||
invoice->setParts(invoiceParts);
|
||||
invoices[invoice->getId()] = invoice;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInvoices
|
||||
Description: Saves invoices from the datastore to persistent storage.
|
||||
Uses FileManager to serialize invoices into the configured file.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void PaymentManagementService::saveInvoices()
|
||||
{
|
||||
util::FileManager<Invoice> invoiceFileManager(config::file::INVOICE_FILE);
|
||||
auto& invoices = m_dataStore.getInvoices();
|
||||
invoiceFileManager.save(invoices);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: loadObservers
|
||||
Description: Loads observer IDs from persistent storage and attaches corresponding
|
||||
users as observers to the PaymentManagementService.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
Throws:
|
||||
- std::runtime_error if an observer ID is invalid (not found in datastore)
|
||||
*/
|
||||
void PaymentManagementService::loadObservers()
|
||||
{
|
||||
util::loadObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this, m_dataStore);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveObservers
|
||||
Description: Saves the current observer IDs of the PaymentManagementService
|
||||
to persistent storage for future retrieval.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void PaymentManagementService::saveObservers()
|
||||
{
|
||||
util::saveObservers(config::file::PAYMENTMANAGEMENTOBSERVERS, this);
|
||||
}
|
||||
|
||||
/*
|
||||
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.
|
||||
@@ -186,7 +290,6 @@ Throws:
|
||||
*/
|
||||
void PaymentManagementService::generateInvoice(ServiceBooking* booking)
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
if (!booking)
|
||||
{
|
||||
throw std::runtime_error("Invoice generation failed: booking is null.");
|
||||
@@ -196,10 +299,10 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
|
||||
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++)
|
||||
util::Map<std::string, JobCard*> currentJobCards = m_dataStore.getJobCards();
|
||||
for (int iterator = 0; iterator < currentJobCards.getSize(); iterator++)
|
||||
{
|
||||
JobCard* currentJobCard = currentTrackedJobCards.getValueAt(iterator).data;
|
||||
JobCard* currentJobCard = currentJobCards.getValueAt(iterator);
|
||||
util::ServiceJobStatus currentJobCardStatus = currentJobCard->getStatus();
|
||||
if (currentJobCard->getBookingId() == bookingID && currentJobCardStatus != util::ServiceJobStatus::CANCELLED && currentJobCardStatus != util::ServiceJobStatus::COMPLETED)
|
||||
{
|
||||
@@ -219,9 +322,8 @@ void PaymentManagementService::generateInvoice(ServiceBooking* booking)
|
||||
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();
|
||||
util::Map<std::string, Invoice*>& currentInvoices = m_dataStore.getInvoices();
|
||||
currentInvoices.insert(invoice->getId(), invoice);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -234,13 +336,11 @@ 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*>& currentInvoices = m_dataStore.getInvoices();
|
||||
util::Map<std::string, Invoice*> currentUserInvoices;
|
||||
for (int iterator = 0; iterator < currentTrackedInvoices.getSize(); iterator++)
|
||||
for (int iterator = 0; iterator < currentInvoices.getSize(); iterator++)
|
||||
{
|
||||
Invoice* currentInvoice = currentTrackedInvoices.getValueAt(iterator).data;
|
||||
Invoice* currentInvoice = currentInvoices.getValueAt(iterator);
|
||||
if (currentInvoice->getBooking()->getCustomerId() == customerID)
|
||||
{
|
||||
currentUserInvoices.insert(currentInvoice->getId(), currentInvoice);
|
||||
@@ -263,14 +363,11 @@ 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);
|
||||
auto& currentInvoices = m_dataStore.getInvoices();
|
||||
int invoiceIndex = currentInvoices.find(invoiceID);
|
||||
if (invoiceIndex != -1)
|
||||
{
|
||||
auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
|
||||
Invoice* invoice = trackedInvoice.data;
|
||||
Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
|
||||
if (invoice && invoice->getStatus() != util::PaymentStatus::PAID)
|
||||
{
|
||||
User* currentUser = invoice->getBooking()->getCustomer();
|
||||
@@ -281,31 +378,25 @@ void PaymentManagementService::completePayment(const std::string& invoiceID, uti
|
||||
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
|
||||
Function: getAllInvoice
|
||||
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*>&: Map of invoice IDs to invoice objects
|
||||
*/
|
||||
util::Map<std::string, Invoice*> PaymentManagementService::getAllInvoices()
|
||||
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;
|
||||
return m_dataStore.getInvoices();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -321,25 +412,20 @@ Throws:
|
||||
*/
|
||||
void PaymentManagementService::confirmPayment(const std::string& invoiceID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& currentTrackedInvoices = m_dataStore.getInvoices();
|
||||
int invoiceIndex = currentTrackedInvoices.find(invoiceID);
|
||||
auto& currentInvoices = m_dataStore.getInvoices();
|
||||
int invoiceIndex = currentInvoices.find(invoiceID);
|
||||
if (invoiceIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Payment confirmation failed: invalid invoice ID.");
|
||||
}
|
||||
auto& trackedInvoice = currentTrackedInvoices.getValueAt(invoiceIndex);
|
||||
Invoice* invoice = trackedInvoice.data;
|
||||
Invoice* invoice = currentInvoices.getValueAt(invoiceIndex);
|
||||
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();
|
||||
}
|
||||
+6
-1
@@ -22,15 +22,20 @@ class PaymentManagementService : public NotificationManagementService
|
||||
private:
|
||||
DataStore& m_dataStore;
|
||||
static util::Map<std::string, User*> m_observers;
|
||||
util::Vector<std::string> getObserverIDs() override;
|
||||
public:
|
||||
PaymentManagementService() : m_dataStore(DataStore::getInstance()) {}
|
||||
void generateInvoice(ServiceBooking* booking);
|
||||
util::Map<std::string, Invoice*> getInvoices(const std::string& customerID);
|
||||
void completePayment(const std::string& invoiceID, util::PaymentMode paymentMode);
|
||||
util::Map<std::string, Invoice*> getAllInvoices();
|
||||
util::Map<std::string, Invoice*>& getAllInvoices();
|
||||
void confirmPayment(const std::string& invoiceID);
|
||||
void sendPaymentReminders();
|
||||
void sendNotification(User* user, const std::string& title, const std::string& message) override;
|
||||
void attach(User* user) override;
|
||||
void detach(User* user) override;
|
||||
void loadInvoices();
|
||||
void saveInvoices();
|
||||
void loadObservers();
|
||||
void saveObservers();
|
||||
};
|
||||
|
||||
+404
-300
File diff suppressed because it is too large
Load Diff
+11
-1
@@ -23,6 +23,7 @@ class ServiceManagementService : public NotificationManagementService
|
||||
private:
|
||||
DataStore& m_dataStore;
|
||||
static util::Map<std::string, User*> m_observers;
|
||||
util::Vector<std::string> getObserverIDs() override;
|
||||
public:
|
||||
ServiceManagementService() : m_dataStore(DataStore::getInstance()) {}
|
||||
util::Map<std::string, Service*> getServices();
|
||||
@@ -35,7 +36,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);
|
||||
@@ -45,4 +45,14 @@ public:
|
||||
void sendNotification(User* user, const std::string& title, const std::string& message) override;
|
||||
void attach(User* user) override;
|
||||
void detach(User* user) override;
|
||||
void loadServices();
|
||||
void saveServices();
|
||||
void loadComboPackages();
|
||||
void saveComboPackages();
|
||||
void loadServiceBookings();
|
||||
void saveServiceBookings();
|
||||
void loadJobCards();
|
||||
void saveJobCards();
|
||||
void loadObservers();
|
||||
void saveObservers();
|
||||
};
|
||||
|
||||
+98
-97
@@ -11,19 +11,15 @@ Date:19-May-2026
|
||||
#include "Config.h"
|
||||
#include "Enums.h"
|
||||
#include "Factory.h"
|
||||
#include "FileManager.h"
|
||||
#include "InventoryManagementService.h"
|
||||
#include "Notification.h"
|
||||
#include "PaymentManagementService.h"
|
||||
#include "ServiceManagementService.h"
|
||||
#include "AuthenticationManagementService.h"
|
||||
#include "User.h"
|
||||
#include "UserManagementService.h"
|
||||
#include "Vector.h"
|
||||
#include "Validator.h"
|
||||
#include "Utility.h"
|
||||
#include "TrackedRecord.h"
|
||||
#include "DataStoreLockGuard.h"
|
||||
#include "EventManager.h"
|
||||
|
||||
/*
|
||||
Function: ensureAdminExists
|
||||
@@ -35,13 +31,12 @@ Return type: void
|
||||
*/
|
||||
void UserManagementService::ensureAdminExists()
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& usersMap = m_dataStore.getUsers();
|
||||
int usersMapSize = usersMap.getSize();
|
||||
bool isAdminFound = false;
|
||||
for (int index = 0; index < usersMapSize; index++)
|
||||
{
|
||||
User* user = usersMap.getValueAt(index).data;
|
||||
User* user = usersMap.getValueAt(index);
|
||||
if (user && user->getUserType() == util::UserType::ADMIN)
|
||||
{
|
||||
isAdminFound = true;
|
||||
@@ -78,9 +73,7 @@ void UserManagementService::createUser(const std::string& username, const std::s
|
||||
InventoryManagementService inventoryManagementService;
|
||||
PaymentManagementService paymentManagementService;
|
||||
ServiceManagementService serviceManagementService;
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
auto usersMap = util::getObjects(trackedUsersMap);
|
||||
auto& usersMap = m_dataStore.getUsers();
|
||||
if (util::isUsernameDuplicate(username, usersMap))
|
||||
{
|
||||
throw std::runtime_error("Username already exists");
|
||||
@@ -94,14 +87,13 @@ void UserManagementService::createUser(const std::string& username, const std::s
|
||||
throw std::runtime_error("Phone already exists");
|
||||
}
|
||||
User* newUser = Factory::getObject<User>(username, password, name, phone, email, type);
|
||||
trackedUsersMap.insert(newUser->getId(), util::createNewRecord(newUser));
|
||||
usersMap.insert(newUser->getId(), newUser);
|
||||
paymentManagementService.attach(newUser);
|
||||
serviceManagementService.attach(newUser);
|
||||
if (newUser->getUserType() == util::UserType::ADMIN)
|
||||
{
|
||||
inventoryManagementService.attach(newUser);
|
||||
}
|
||||
m_dataStore.saveUsers();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -115,25 +107,19 @@ 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);
|
||||
int index = trackedUsersMap.find(userID);
|
||||
auto& usersMap = m_dataStore.getUsers();
|
||||
int index = usersMap.find(userID);
|
||||
if (index == -1)
|
||||
{
|
||||
throw std::runtime_error("User does not exist!\n");
|
||||
}
|
||||
User* user = trackedUsersMap.getValueAt(index).data;
|
||||
bool isModified = false;
|
||||
User* user = usersMap.getValueAt(index);
|
||||
if (email != user->getEmail())
|
||||
{
|
||||
if (util::isEmailDuplicate(email, usersMap))
|
||||
{
|
||||
throw std::runtime_error("Email already exists!\n");
|
||||
}
|
||||
user->setEmail(email);
|
||||
isModified = true;
|
||||
}
|
||||
if (phone != user->getPhone())
|
||||
{
|
||||
@@ -141,14 +127,9 @@ void UserManagementService::updateUserDetails(const std::string& userID, const s
|
||||
{
|
||||
throw std::runtime_error("Phone number already exists!\n");
|
||||
}
|
||||
}
|
||||
user->setEmail(email);
|
||||
user->setPhone(phone);
|
||||
isModified = true;
|
||||
}
|
||||
if (isModified)
|
||||
{
|
||||
trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
|
||||
m_dataStore.saveUsers();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -163,26 +144,20 @@ 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)
|
||||
auto& usersMap = m_dataStore.getUsers();
|
||||
if (usersMap.find(userID) == -1)
|
||||
{
|
||||
throw std::runtime_error("No user found with given UserID");
|
||||
}
|
||||
User* user = trackedUsersMap[userID].data;
|
||||
User* user = usersMap[userID];
|
||||
if (user)
|
||||
{
|
||||
auto& trackedNotificationMap = m_dataStore.getNotifications();
|
||||
int numberOfNotifications = trackedNotificationMap.getSize();
|
||||
auto& notifications = user->getNotifications();
|
||||
int numberOfNotifications = notifications.getSize();
|
||||
util::Vector<Notification*> notificationsVector;
|
||||
for (int index = 0; index < numberOfNotifications; index++)
|
||||
{
|
||||
Notification* notification = trackedNotificationMap.getValueAt(index).data;
|
||||
if (notification->getRecipientUserId() == userID && notification->getState() == util::State::ACTIVE)
|
||||
{
|
||||
notificationsVector.push_back(notification);
|
||||
}
|
||||
notificationsVector.push_back(notifications.getValueAt(index));
|
||||
}
|
||||
return notificationsVector;
|
||||
}
|
||||
@@ -194,40 +169,97 @@ util::Vector<Notification*> UserManagementService::getUserNotifications(const st
|
||||
|
||||
/*
|
||||
Function: deleteNotification
|
||||
Description: Marks a specific notification associated with a given user
|
||||
as inactive.
|
||||
Description: Deletes a specific notification associated with a given user ID.
|
||||
Parameters:
|
||||
- notificationID: The unique ID of the notification to be deleted.
|
||||
- userID: The unique ID of the user whose notification is to be deleted.
|
||||
Returns:
|
||||
- void
|
||||
Throws:
|
||||
- std::runtime_error if no user is found with the given UserID or
|
||||
if no notification is found with the given NotificationID.
|
||||
- std::runtime_error if no user is found with the given UserID or if no notification is found with the given NotificationID.
|
||||
*/
|
||||
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();
|
||||
int userIndex = trackedUsersMap.find(userID);
|
||||
if (userIndex == -1)
|
||||
auto& usersMap = m_dataStore.getUsers();
|
||||
if (usersMap.find(userID) == -1)
|
||||
{
|
||||
throw std::runtime_error("No user found with given UserID");
|
||||
}
|
||||
int notificationIndex = trackedNotificationsMap.find(notificationID);
|
||||
if (notificationIndex == -1)
|
||||
User* user = usersMap[userID];
|
||||
auto& notifications = user->getNotifications();
|
||||
if (notifications.find(notificationID) == -1)
|
||||
{
|
||||
throw std::runtime_error("No notification found with given NotificationID");
|
||||
}
|
||||
Notification* notification = trackedNotificationsMap.getValueAt(notificationIndex).data;
|
||||
if (notification->getRecipientUserId() == userID)
|
||||
notifications.remove(notificationID);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: loadUsers
|
||||
Description: Loads users and notifications from persistent storage into the datastore.
|
||||
Validates that each notification’s recipient exists and attaches the
|
||||
notification to the corresponding user.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
Throws:
|
||||
- std::runtime_error if a notification recipient user ID is invalid
|
||||
*/
|
||||
void UserManagementService::loadUsers()
|
||||
{
|
||||
util::FileManager<User> userFileManager(config::file::USER_FILE);
|
||||
util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
|
||||
auto& users = m_dataStore.getUsers();
|
||||
auto usersMap = userFileManager.load();
|
||||
auto notificationsMap = notificationFileManager.load();
|
||||
int numberOfUsers = usersMap.getSize();
|
||||
int numberOfNotifications = notificationsMap.getSize();
|
||||
for (int index = 0; index < numberOfUsers; index++)
|
||||
{
|
||||
notification->setState(util::State::INACTIVE);
|
||||
trackedNotificationsMap.getValueAt(notificationIndex).state = RecordState::MODIFIED;
|
||||
m_dataStore.saveNotifications();
|
||||
users[usersMap.getKeyAt(index)] = usersMap.getValueAt(index);
|
||||
}
|
||||
for (int index = 0; index < numberOfNotifications; index++)
|
||||
{
|
||||
Notification* notification = notificationsMap.getValueAt(index);
|
||||
const std::string& recipientUserId = notification->getRecipientUserId();
|
||||
int userIndex = users.find(recipientUserId);
|
||||
if (userIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid recipient user ID");
|
||||
}
|
||||
User* user = users.getValueAt(userIndex);
|
||||
user->addNotification(notification);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveUsers
|
||||
Description: Saves users and their notifications from the datastore to persistent storage.
|
||||
Collects notifications from all users into a single map before saving.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
void UserManagementService::saveUsers()
|
||||
{
|
||||
util::FileManager<User> userFileManager(config::file::USER_FILE);
|
||||
util::FileManager<Notification> notificationFileManager(config::file::NOTIFICATION_FILE);
|
||||
auto& users = m_dataStore.getUsers();
|
||||
util::Map<std::string, Notification*> notifications;
|
||||
for (int userIndex = 0; userIndex < users.getSize(); userIndex++)
|
||||
{
|
||||
User* user = users.getValueAt(userIndex);
|
||||
auto& userNotifications = user->getNotifications();
|
||||
for (int notificationIndex = 0; notificationIndex < userNotifications.getSize(); notificationIndex++)
|
||||
{
|
||||
notifications[userNotifications.getKeyAt(notificationIndex)] =
|
||||
userNotifications.getValueAt(notificationIndex);
|
||||
}
|
||||
}
|
||||
userFileManager.save(users);
|
||||
notificationFileManager.save(notifications);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -238,9 +270,7 @@ Return type: util::Map<std::string, User*>
|
||||
*/
|
||||
util::Map<std::string, User*> UserManagementService::getUsers()
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto users = util::getObjects(m_dataStore.getUsers());
|
||||
return users;
|
||||
return m_dataStore.getUsers();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -251,12 +281,10 @@ Return type: User*
|
||||
*/
|
||||
User* UserManagementService::getUser(const std::string& userID)
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
int index = trackedUsersMap.find(userID);
|
||||
int index = m_dataStore.getUsers().find(userID);
|
||||
if (index != -1)
|
||||
{
|
||||
return trackedUsersMap.getValueAt(index).data;
|
||||
return m_dataStore.getUsers().getValueAt(index);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
@@ -269,18 +297,13 @@ Return type: void
|
||||
*/
|
||||
void UserManagementService::removeUser(const std::string& userID)
|
||||
{
|
||||
AuthenticationManagementService::ensureAuthorization();
|
||||
InventoryManagementService inventoryManagementService;
|
||||
PaymentManagementService paymentManagementService;
|
||||
ServiceManagementService serviceManagementService;
|
||||
std::string removedUserID;
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
int index = trackedUsersMap.find(userID);
|
||||
int index = m_dataStore.getUsers().find(userID);
|
||||
if (index != -1)
|
||||
{
|
||||
User* user = trackedUsersMap.getValueAt(index).data;
|
||||
User* user = m_dataStore.getUsers().getValueAt(index);
|
||||
if (user != nullptr)
|
||||
{
|
||||
if (user->getUserType() == util::UserType::CUSTOMER)
|
||||
@@ -291,43 +314,21 @@ void UserManagementService::removeUser(const std::string& userID)
|
||||
{
|
||||
serviceManagementService.cancelTechnicianJobs(userID);
|
||||
}
|
||||
user->setState(util::State::INACTIVE);
|
||||
inventoryManagementService.detach(user);
|
||||
paymentManagementService.detach(user);
|
||||
serviceManagementService.detach(user);
|
||||
user->setState(util::State::INACTIVE);
|
||||
trackedUsersMap.getValueAt(index).state = RecordState::MODIFIED;
|
||||
removedUserID = user->getId();
|
||||
m_dataStore.saveUsers();
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!removedUserID.empty())
|
||||
{
|
||||
EventManager::sendUserDisabledEvent(removedUserID);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getUsers
|
||||
Description: Retrieves all active users of the specified type from
|
||||
the DataStore.
|
||||
Parameters:
|
||||
- type: The user type to filter by
|
||||
(ADMIN, CUSTOMER, or TECHNICIAN).
|
||||
Returns:
|
||||
- util::Map<std::string, User*>:
|
||||
Collection of active users matching the specified type,
|
||||
keyed by user ID.
|
||||
*/
|
||||
util::Map<std::string, User*> UserManagementService::getUsers(util::UserType type)
|
||||
{
|
||||
DataStoreLockGuard lock(m_dataStore);
|
||||
auto& trackedUsersMap = m_dataStore.getUsers();
|
||||
util::Map<std::string, User*> currentUsers = util::getObjects(trackedUsersMap);
|
||||
util::Map<std::string, User*>& currentUsers = m_dataStore.getUsers();
|
||||
util::Map<std::string, User*> filteredUsersMap;
|
||||
for (int index = 0; index < currentUsers.getSize(); index++)
|
||||
for (int iterator = 0; iterator < currentUsers.getSize(); iterator++)
|
||||
{
|
||||
User* currentUser = currentUsers.getValueAt(index);
|
||||
User* currentUser = currentUsers.getValueAt(iterator);
|
||||
if (currentUser && currentUser->getState() == util::State::ACTIVE && currentUser->getUserType() == type)
|
||||
{
|
||||
filteredUsersMap.insert(currentUser->getId(), currentUser);
|
||||
|
||||
+2
-1
@@ -6,7 +6,6 @@ Description: Header file declaring the UserManagementService class, which manage
|
||||
Author: Trenser
|
||||
Date:19-May-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
#include "Map.h"
|
||||
@@ -31,4 +30,6 @@ public:
|
||||
util::Vector<Notification*> getUserNotifications(const std::string& userID);
|
||||
void deleteNotification(const std::string& notificationID, const std::string& userID);
|
||||
void ensureAdminExists();
|
||||
void loadUsers();
|
||||
void saveUsers();
|
||||
};
|
||||
|
||||
@@ -29,7 +29,6 @@ namespace config
|
||||
namespace file
|
||||
{
|
||||
const size_t INITIAL_CAPACITY = 100;
|
||||
const size_t GROWTH_FACTOR = 2;
|
||||
constexpr const char* DIRECTORY = "files/";
|
||||
constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.dat";
|
||||
constexpr const char* USER_FILE = "files/User.dat";
|
||||
|
||||
@@ -43,4 +43,67 @@ namespace util
|
||||
position++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: loadRecords
|
||||
Description: Loads records from a given file path into a vector of strings.
|
||||
Skips the header line if present. Creates the file if it does not exist.
|
||||
Parameters:
|
||||
- filePath: const std::string&, path to the file
|
||||
Returns:
|
||||
- util::Vector<std::string>: Vector containing all records (excluding header)
|
||||
Throws:
|
||||
- None (creates file if missing)
|
||||
*/
|
||||
inline util::Vector<std::string> loadRecords(const std::string& filePath)
|
||||
{
|
||||
util::Vector<std::string> records;
|
||||
std::ifstream file(filePath);
|
||||
if (!file.is_open())
|
||||
{
|
||||
ensureDirectoryExists(filePath);
|
||||
std::ofstream newFile(filePath);
|
||||
newFile.close();
|
||||
file.open(filePath);
|
||||
}
|
||||
std::string line;
|
||||
bool isHeader = true;
|
||||
while (std::getline(file, line))
|
||||
{
|
||||
if (isHeader)
|
||||
{
|
||||
isHeader = false;
|
||||
continue;
|
||||
}
|
||||
records.push_back(line);
|
||||
}
|
||||
return records;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveRecords
|
||||
Description: Saves records to a given file path. Overwrites existing content
|
||||
and writes a header line followed by all records.
|
||||
Parameters:
|
||||
- filePath: const std::string&, path to the file
|
||||
- records: const util::Vector<std::string>&, vector of records to save
|
||||
Returns:
|
||||
- void
|
||||
Throws:
|
||||
- std::runtime_error if the file cannot be opened for writing
|
||||
*/
|
||||
inline void saveRecords(const std::string& filePath, const util::Vector<std::string>& records)
|
||||
{
|
||||
std::ofstream file(filePath, std::ios::trunc);
|
||||
if (!file.is_open())
|
||||
{
|
||||
throw std::runtime_error("Failed to open file " + filePath);
|
||||
}
|
||||
file << "Values" << '\n';
|
||||
int numberOfRecords = records.getSize();
|
||||
for (int index = 0; index < numberOfRecords; index++)
|
||||
{
|
||||
file << records[index] << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
/*
|
||||
File: FileManager.h
|
||||
Description: Declares and implements a generic FileManager template class for
|
||||
loading and saving objects to and from files. Uses serialization
|
||||
and deserialization methods defined in the object type T.
|
||||
Provides persistence support for system entities such as Users,
|
||||
Services, InventoryItems, etc.
|
||||
Author: Trenser
|
||||
Date: 22-May-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include "Vector.h"
|
||||
#include "Map.h"
|
||||
#include "FileHelper.h"
|
||||
|
||||
namespace util
|
||||
{
|
||||
template <typename T> using objects = util::Map<std::string, T*>;
|
||||
|
||||
template <typename T>
|
||||
class FileManager
|
||||
{
|
||||
private:
|
||||
std::string m_filePath;
|
||||
public:
|
||||
FileManager() : m_filePath("") {}
|
||||
FileManager(const std::string& filePath) : m_filePath(filePath) {}
|
||||
objects<T> load();
|
||||
void save(const objects<T>&);
|
||||
};
|
||||
|
||||
/*
|
||||
Function: load
|
||||
Description: Loads records from the file into a map of objects.
|
||||
Skips the header line, deserializes each record into an object of type T,
|
||||
and stores them in a map keyed by object ID.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, T*> containing deserialized objects
|
||||
Throws:
|
||||
- std::runtime_error if deserialization fails for any record
|
||||
*/
|
||||
template <typename T>
|
||||
objects<T> FileManager<T>::load()
|
||||
{
|
||||
objects<T> records;
|
||||
std::ifstream file(m_filePath);
|
||||
if (!file.is_open())
|
||||
{
|
||||
ensureDirectoryExists(m_filePath);
|
||||
std::ofstream newFile(m_filePath);
|
||||
newFile.close();
|
||||
file.open(m_filePath);
|
||||
}
|
||||
util::Vector<std::string> lines;
|
||||
std::string line;
|
||||
while (std::getline(file, line))
|
||||
{
|
||||
lines.push_back(line);
|
||||
}
|
||||
int numberOfLines = lines.getSize();
|
||||
bool isHeader = true;
|
||||
for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
|
||||
{
|
||||
const auto& record = lines[lineIndex];
|
||||
if (isHeader)
|
||||
{
|
||||
isHeader = false;
|
||||
continue;
|
||||
}
|
||||
auto object = T::deserialize(record);
|
||||
if (!object)
|
||||
{
|
||||
throw std::runtime_error("Failed to deserialize record");
|
||||
}
|
||||
records[object->getId()] = object;
|
||||
}
|
||||
return records;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: save
|
||||
Description: Saves records to the file. Serializes each object of type T into a string,
|
||||
writes a header line, and then writes all serialized records to the file.
|
||||
Parameters:
|
||||
- records: const util::Map<std::string, T*>&, map of objects to save
|
||||
Returns:
|
||||
- void
|
||||
Throws:
|
||||
- std::runtime_error if the file cannot be opened for writing
|
||||
*/
|
||||
template <typename T>
|
||||
void FileManager<T>::save(const objects<T>& records)
|
||||
{
|
||||
util::Vector<std::string> lines;
|
||||
lines.push_back(T::getHeaders());
|
||||
int numberOfRecords = records.getSize();
|
||||
for (int recordIndex = 0; recordIndex < numberOfRecords; recordIndex++)
|
||||
{
|
||||
const auto& record = records.getValueAt(recordIndex);
|
||||
lines.push_back(record->serialize());
|
||||
}
|
||||
std::ofstream file(m_filePath, std::ios::trunc);
|
||||
if (!file.is_open())
|
||||
{
|
||||
throw std::runtime_error("Failed to open file " + m_filePath);
|
||||
}
|
||||
int numberOfLines = lines.getSize();
|
||||
for (int lineIndex = 0; lineIndex < numberOfLines; lineIndex++)
|
||||
{
|
||||
file << lines[lineIndex] << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,6 @@
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
#include <conio.h>
|
||||
|
||||
namespace util
|
||||
{
|
||||
@@ -28,7 +27,7 @@ namespace util
|
||||
if (!(std::cin >> value))
|
||||
{
|
||||
std::cin.clear();
|
||||
std::cin.ignore((std::numeric_limits<std::streamsize>::max)(), '\n');
|
||||
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
|
||||
throw std::runtime_error("Invalid console input");
|
||||
}
|
||||
}
|
||||
@@ -55,48 +54,6 @@ namespace util
|
||||
value = cleanedValue;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function: readPassword
|
||||
* Description: Reads a password from console without echoing characters;
|
||||
* displays '*' for each character typed, handles backspace,
|
||||
* and cleans commas from the result.
|
||||
* Parameters:
|
||||
* value - reference to a string where the password will be stored
|
||||
* Returns:
|
||||
* void - no return value
|
||||
*/
|
||||
inline void readPassword(std::string& value)
|
||||
{
|
||||
value.clear();
|
||||
char currentCharacter;
|
||||
while ((currentCharacter = _getch()) != '\r')
|
||||
{
|
||||
if (currentCharacter == '\b')
|
||||
{
|
||||
if (!value.empty())
|
||||
{
|
||||
value.pop_back();
|
||||
std::cout << "\b \b";
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
value += currentCharacter;
|
||||
std::cout << '*';
|
||||
}
|
||||
}
|
||||
std::cout << std::endl;
|
||||
std::string cleanedValue;
|
||||
for (int iterator = 0; iterator < value.length(); iterator++)
|
||||
{
|
||||
if (value[iterator] != ',')
|
||||
{
|
||||
cleanedValue += value[iterator];
|
||||
}
|
||||
}
|
||||
value = cleanedValue;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function: pressEnter
|
||||
* Description: Pauses execution until the user presses Enter.
|
||||
|
||||
@@ -54,79 +54,49 @@ namespace util
|
||||
return cost;
|
||||
}
|
||||
|
||||
template<typename TObject>
|
||||
Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
|
||||
|
||||
template<typename TObject>
|
||||
Map<std::string, const TObject*> getConstObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);
|
||||
|
||||
template<typename TObject>
|
||||
TrackedRecord<TObject> createNewRecord(TObject* object);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getObjects
|
||||
Description: Extracts the object pointers from a tracked-record
|
||||
collection and returns them as a map keyed by the
|
||||
same identifiers.
|
||||
Parameters:
|
||||
- trackedRecords: Collection of tracked records.
|
||||
Returns:
|
||||
- Map<std::string, TObject*>: Collection of object pointers.
|
||||
*/
|
||||
template<typename TObject>
|
||||
util::Map<std::string, TObject*> util::getObjects(const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
|
||||
{
|
||||
util::Map<std::string, TObject*> objects;
|
||||
for (int index = 0; index < trackedRecords.getSize(); ++index)
|
||||
/*
|
||||
Function: loadObservers
|
||||
Description: Loads observer IDs from a file and attaches the corresponding users
|
||||
to the notification management service. Validates that each observer ID
|
||||
exists in the datastore before attaching.
|
||||
Parameters:
|
||||
- filePath: const std::string&, path to the file containing observer IDs
|
||||
- service: NotificationManagementService*, pointer to the notification service
|
||||
- dataStore: DataStore&, reference to the datastore containing users
|
||||
Returns:
|
||||
- void
|
||||
Throws:
|
||||
- std::runtime_error if an observer ID is invalid (not found in datastore)
|
||||
*/
|
||||
inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
|
||||
{
|
||||
const std::string& key = trackedRecords.getKeyAt(index);
|
||||
TObject* object = trackedRecords.getValueAt(index).data;
|
||||
objects.insert(key, object);
|
||||
}
|
||||
return objects;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getConstObjects
|
||||
Description: Extracts the object pointers from a tracked-record
|
||||
collection and returns them as a read-only map
|
||||
keyed by the same identifiers.
|
||||
Parameters:
|
||||
- trackedRecords: Collection of tracked records.
|
||||
Returns:
|
||||
- Map<std::string, const TObject*>:
|
||||
Collection of read-only object pointers.
|
||||
*/
|
||||
template<typename TObject>
|
||||
util::Map<std::string, const TObject*> util::getConstObjects(
|
||||
const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
|
||||
{
|
||||
util::Map<std::string, const TObject*> objects;
|
||||
for (int index = 0; index < trackedRecords.getSize(); ++index)
|
||||
auto observerIDs = util::loadRecords(filePath);
|
||||
auto& users = dataStore.getUsers();
|
||||
for (int index = 0; index < observerIDs.getSize(); index++)
|
||||
{
|
||||
const std::string& key = trackedRecords.getKeyAt(index);
|
||||
const TObject* object = trackedRecords.getValueAt(index).data;
|
||||
objects.insert(key, object);
|
||||
const std::string& observerID = observerIDs[index];
|
||||
int userIndex = users.find(observerID);
|
||||
if (userIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid Observer ID");
|
||||
}
|
||||
service->attach(users.getValueAt(userIndex));
|
||||
}
|
||||
}
|
||||
return objects;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: createNewRecord
|
||||
Description: Creates a tracked record for a newly created
|
||||
object. The record is initialized with
|
||||
NEW_RECORD state.
|
||||
Parameters:
|
||||
- object: Pointer to the newly created object.
|
||||
Returns:
|
||||
- TrackedRecord<TObject>: Initialized tracked record.
|
||||
*/
|
||||
template<typename TObject>
|
||||
TrackedRecord<TObject> util::createNewRecord(TObject* object)
|
||||
{
|
||||
TrackedRecord<TObject> record;
|
||||
record.data = object;
|
||||
record.state = RecordState::NEW_RECORD;
|
||||
return record;
|
||||
/*
|
||||
Function: saveObservers
|
||||
Description: Saves the current observer IDs from the notification management service
|
||||
to a file for persistence.
|
||||
Parameters:
|
||||
- filePath: const std::string&, path to the file where observer IDs will be saved
|
||||
- service: NotificationManagementService*, pointer to the notification service
|
||||
Returns:
|
||||
- void
|
||||
*/
|
||||
inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
|
||||
{
|
||||
auto observerIDs = service->getObserverIDs();
|
||||
util::saveRecords(filePath, observerIDs);
|
||||
}
|
||||
}
|
||||
@@ -30,16 +30,10 @@ Return type: void
|
||||
*/
|
||||
void AdminMenu::showMenu()
|
||||
{
|
||||
startEventListener();
|
||||
while (true)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!m_isMenuActive)
|
||||
{
|
||||
logout();
|
||||
break;
|
||||
}
|
||||
int choice;
|
||||
util::clear();
|
||||
std::cout << "Admin Menu"
|
||||
@@ -74,7 +68,6 @@ void AdminMenu::showMenu()
|
||||
util::pressEnter();
|
||||
}
|
||||
}
|
||||
stopEventListener();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -85,11 +78,6 @@ Return type: bool - true if menu continues, false if logout
|
||||
*/
|
||||
bool AdminMenu::handleOperation(int choice)
|
||||
{
|
||||
if (!m_isMenuActive)
|
||||
{
|
||||
logout();
|
||||
return false;
|
||||
}
|
||||
switch (choice)
|
||||
{
|
||||
case 1:
|
||||
@@ -153,25 +141,6 @@ 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);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: logout
|
||||
Description: Logs out the currently authenticated admin user.
|
||||
@@ -338,23 +307,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();
|
||||
|
||||
@@ -9,13 +9,12 @@ Date:19-May-2026
|
||||
|
||||
#pragma once
|
||||
#include "Controller.h"
|
||||
#include "Menu.h"
|
||||
|
||||
class AdminMenu : public Menu
|
||||
class AdminMenu
|
||||
{
|
||||
private:
|
||||
Controller m_controller;
|
||||
bool handleOperation(int choice);
|
||||
void handleNotificationEvent() override;
|
||||
public:
|
||||
void showMenu();
|
||||
void logout();
|
||||
|
||||
@@ -30,19 +30,13 @@ Description: Displays the customer menu and handles user input until logout is s
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
|
||||
void CustomerMenu::showMenu()
|
||||
{
|
||||
|
||||
startEventListener();
|
||||
while (true)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!m_isMenuActive)
|
||||
{
|
||||
logout();
|
||||
break;
|
||||
}
|
||||
int choice;
|
||||
util::clear();
|
||||
std::cout << "Customer Menu"
|
||||
@@ -51,12 +45,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))
|
||||
@@ -70,7 +63,6 @@ void CustomerMenu::showMenu()
|
||||
util::pressEnter();
|
||||
}
|
||||
}
|
||||
stopEventListener();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -81,11 +73,6 @@ Return type: bool - true if menu continues, false if logout
|
||||
*/
|
||||
bool CustomerMenu::handleOperation(int choice)
|
||||
{
|
||||
if (!m_isMenuActive)
|
||||
{
|
||||
logout();
|
||||
return false;
|
||||
}
|
||||
switch (choice)
|
||||
{
|
||||
case 1:
|
||||
@@ -104,21 +91,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,25 +112,6 @@ 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);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: logout
|
||||
Description: Logs out the currently authenticated customer user.
|
||||
@@ -220,13 +185,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 +227,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 +302,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.
|
||||
|
||||
@@ -9,14 +9,13 @@ Date:19-May-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "Menu.h"
|
||||
#include "Controller.h"
|
||||
|
||||
class CustomerMenu : public Menu
|
||||
class CustomerMenu
|
||||
{
|
||||
private:
|
||||
Controller m_controller;
|
||||
bool handleOperation(int choice);
|
||||
void handleNotificationEvent();
|
||||
public:
|
||||
void showMenu();
|
||||
void logout();
|
||||
@@ -28,6 +27,5 @@ public:
|
||||
void completePayments();
|
||||
void viewInvoices();
|
||||
void viewNotifications();
|
||||
void cancelServiceBooking();
|
||||
void configureNotifications();
|
||||
};
|
||||
@@ -1,150 +0,0 @@
|
||||
/*
|
||||
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),
|
||||
m_accountDisabledEvent(NULL),
|
||||
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())
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_isMenuActive.store(true);
|
||||
m_accountDisabledEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
m_notificationAvailableEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
m_shutdownEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
|
||||
m_controller.registerEvents(m_accountDisabledEvent, m_notificationAvailableEvent);
|
||||
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] = { NULL, NULL, NULL };
|
||||
handles[0] = m_accountDisabledEvent;
|
||||
handles[1] = m_notificationAvailableEvent;
|
||||
handles[2] = m_shutdownEvent;
|
||||
while (m_isMenuActive.load())
|
||||
{
|
||||
DWORD result = WaitForMultipleObjects(3, handles, FALSE, INFINITE);
|
||||
switch (result)
|
||||
{
|
||||
case WAIT_OBJECT_0:
|
||||
handleAccountDisabledEvent();
|
||||
break;
|
||||
case WAIT_OBJECT_0 + 1:
|
||||
handleNotificationEvent();
|
||||
break;
|
||||
case WAIT_OBJECT_0 + 2:
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
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);
|
||||
if (m_shutdownEvent)
|
||||
{
|
||||
SetEvent(m_shutdownEvent);
|
||||
}
|
||||
if (m_eventListenerThread.joinable())
|
||||
{
|
||||
m_eventListenerThread.join();
|
||||
}
|
||||
if (m_accountDisabledEvent)
|
||||
{
|
||||
CloseHandle(m_accountDisabledEvent);
|
||||
}
|
||||
if (m_notificationAvailableEvent)
|
||||
{
|
||||
CloseHandle(m_notificationAvailableEvent);
|
||||
}
|
||||
if (m_shutdownEvent)
|
||||
{
|
||||
CloseHandle(m_shutdownEvent);
|
||||
}
|
||||
m_accountDisabledEvent = NULL;
|
||||
m_notificationAvailableEvent = NULL;
|
||||
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(),
|
||||
MB_OK |
|
||||
MB_ICONWARNING |
|
||||
MB_SETFOREGROUND |
|
||||
MB_TOPMOST);
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
/*
|
||||
File: Menu.h
|
||||
Description: Base class providing common event listener functionality
|
||||
for all menu implementations.
|
||||
Author: Trenser
|
||||
Date:16-Jun-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <windows.h>
|
||||
#include <atomic>
|
||||
#include <thread>
|
||||
#include "Controller.h"
|
||||
|
||||
class Menu
|
||||
{
|
||||
protected:
|
||||
Controller m_controller;
|
||||
std::atomic<bool> m_isMenuActive;
|
||||
HANDLE m_accountDisabledEvent;
|
||||
HANDLE m_notificationAvailableEvent;
|
||||
HANDLE m_shutdownEvent;
|
||||
std::thread m_eventListenerThread;
|
||||
void startEventListener();
|
||||
void stopEventListener();
|
||||
void eventListenerLoop();
|
||||
void handleAccountDisabledEvent();
|
||||
virtual void handleNotificationEvent() = 0;
|
||||
public:
|
||||
Menu();
|
||||
virtual ~Menu();
|
||||
};
|
||||
@@ -28,7 +28,6 @@ Date: 21-May-2026
|
||||
#include "Utility.h"
|
||||
#include "Validator.h"
|
||||
#include "Vector.h"
|
||||
#include "StringHelper.h"
|
||||
|
||||
/*
|
||||
Function: displayAllServices
|
||||
@@ -588,7 +587,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
|
||||
<< util::getPaymentStatusString(selectedInvoice->getStatus()) << std::endl;
|
||||
std::cout << std::left << std::setw(20) << "Payment Mode:"
|
||||
<< util::getPaymentModeString(selectedInvoice->getPaymentMethod()) << std::endl;
|
||||
auto& inventoryItemsInInvoice = selectedInvoice->getParts();
|
||||
auto inventoryItemsInInvoice = selectedInvoice->getParts();
|
||||
if (inventoryItemsInInvoice.isEmpty())
|
||||
{
|
||||
std::cout << "No inventory items used.\n\n";
|
||||
@@ -597,6 +596,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
|
||||
std::cout << "\nItems Used:\n";
|
||||
std::cout << std::left
|
||||
<< std::setw(20) << "ItemName"
|
||||
<< std::setw(10) << "Quantity"
|
||||
<< std::setw(10) << "Price"
|
||||
<< std::endl;
|
||||
std::cout << std::string(40, '-') << std::endl;
|
||||
@@ -605,6 +605,7 @@ inline void displayInvoices(util::Map<std::string, const Invoice*> currentUserIn
|
||||
InventoryItem* currentItem = inventoryItemsInInvoice.getValueAt(iterator);
|
||||
std::cout << std::left
|
||||
<< std::setw(20) << currentItem->getPartName()
|
||||
<< std::setw(10) << currentItem->getQuantity()
|
||||
<< std::setw(10) << currentItem->getPrice()
|
||||
<< std::endl;
|
||||
}
|
||||
@@ -913,7 +914,7 @@ inline void changePasswordHelper(Controller& controller)
|
||||
util::clear();
|
||||
std::cout << "Change Password\n";
|
||||
std::cout << "Enter new password: ";
|
||||
util::readPassword(newPassword);
|
||||
util::read(newPassword);
|
||||
if (!util::isPasswordValid(newPassword))
|
||||
{
|
||||
std::cout << "Error: Password is not strong enough!\n";
|
||||
@@ -927,7 +928,7 @@ inline void changePasswordHelper(Controller& controller)
|
||||
continue;
|
||||
}
|
||||
std::cout << "Confirm new password: ";
|
||||
util::readPassword(confirmedPassword);
|
||||
util::read(confirmedPassword);
|
||||
if (confirmedPassword != newPassword)
|
||||
{
|
||||
std::cout << "Passwords are different. Try again\n";
|
||||
@@ -1055,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
|
||||
@@ -1144,9 +1130,7 @@ inline void displayAllComboPackages(util::Map<std::string, const ComboPackage*>
|
||||
for (int index = 0; index < comboPackages.getSize(); index++)
|
||||
{
|
||||
const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
|
||||
if (currentComboPackage)
|
||||
{
|
||||
if (currentComboPackage->getState() != util::State::ACTIVE)
|
||||
if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
@@ -1156,7 +1140,6 @@ inline void displayAllComboPackages(util::Map<std::string, const ComboPackage*>
|
||||
<< std::setw(15) << util::calculateComboServiceEstimatedCost(currentComboPackage)
|
||||
<< std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1181,9 +1164,7 @@ inline const ComboPackage* selectComboPackageFromPackages(const util::Map<std::s
|
||||
for (int index = 0; index < comboPackages.getSize(); index++)
|
||||
{
|
||||
const ComboPackage* currentComboPackage = comboPackages.getValueAt(index);
|
||||
if (currentComboPackage)
|
||||
{
|
||||
if (currentComboPackage->getState() != util::State::ACTIVE)
|
||||
if (currentComboPackage && currentComboPackage->getState() != util::State::ACTIVE)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
@@ -1196,7 +1177,6 @@ inline const ComboPackage* selectComboPackageFromPackages(const util::Map<std::s
|
||||
<< std::endl;
|
||||
currentIndex++;
|
||||
}
|
||||
}
|
||||
if (activeComboPackages.getSize() == 0)
|
||||
{
|
||||
std::cout << "No active combo packages available." << std::endl;
|
||||
@@ -1428,88 +1408,3 @@ inline std::string selectComboPackage(util::Map<std::string, const ComboPackage*
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
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)
|
||||
{
|
||||
const Notification* notification = nullptr;
|
||||
size_t numberOfNotifications = notifications.getSize();
|
||||
for (int index = 0; index < numberOfNotifications; index++)
|
||||
{
|
||||
if (!notification)
|
||||
{
|
||||
notification = notifications[index];
|
||||
}
|
||||
else
|
||||
{
|
||||
if (util::extractNumber(notification->getId()) < util::extractNumber(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;
|
||||
}
|
||||
|
||||
@@ -27,16 +27,10 @@ Returns:
|
||||
*/
|
||||
void TechnicianMenu::showMenu()
|
||||
{
|
||||
startEventListener();
|
||||
while (true)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!m_isMenuActive)
|
||||
{
|
||||
logout();
|
||||
break;
|
||||
}
|
||||
int choice;
|
||||
util::clear();
|
||||
std::cout << "Technician Menu"
|
||||
@@ -58,7 +52,6 @@ void TechnicianMenu::showMenu()
|
||||
util::pressEnter();
|
||||
}
|
||||
}
|
||||
stopEventListener();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -69,11 +62,6 @@ Return type: bool - true if menu continues, false if logout
|
||||
*/
|
||||
bool TechnicianMenu::handleOperation(int choice)
|
||||
{
|
||||
if (!m_isMenuActive)
|
||||
{
|
||||
logout();
|
||||
return false;
|
||||
}
|
||||
switch (choice)
|
||||
{
|
||||
case 1:
|
||||
@@ -98,25 +86,6 @@ 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);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: displayJobs
|
||||
Description: Displays all Jobs assigned to a Technician
|
||||
|
||||
@@ -9,13 +9,12 @@ Date:19-May-2026
|
||||
|
||||
#pragma once
|
||||
#include "Controller.h"
|
||||
#include "Menu.h"
|
||||
|
||||
class TechnicianMenu : public Menu
|
||||
class TechnicianMenu
|
||||
{
|
||||
private:
|
||||
Controller m_controller;
|
||||
bool handleOperation(int choice);
|
||||
void handleNotificationEvent();
|
||||
public:
|
||||
void showMenu();
|
||||
void displayJobs();
|
||||
|
||||
@@ -27,11 +27,8 @@ void UserInterface::run()
|
||||
{
|
||||
try
|
||||
{
|
||||
if (!m_controller.initialize())
|
||||
{
|
||||
std::cout << "Error: Failed to initialize the system!";
|
||||
return;
|
||||
}
|
||||
m_controller.loadSystemData();
|
||||
m_controller.runSystemChecks();
|
||||
bool isMenuActive = true;
|
||||
while (isMenuActive)
|
||||
{
|
||||
@@ -52,7 +49,7 @@ void UserInterface::run()
|
||||
util::pressEnter();
|
||||
}
|
||||
}
|
||||
m_controller.shutdown();
|
||||
m_controller.saveSystemData();
|
||||
}
|
||||
catch (const std::invalid_argument& exception)
|
||||
{
|
||||
@@ -109,7 +106,7 @@ void UserInterface::login()
|
||||
std::cout << "Enter username: ";
|
||||
util::read(username);
|
||||
std::cout << "Enter password: ";
|
||||
util::readPassword(password);
|
||||
util::read(password);
|
||||
if (m_controller.login(username, password))
|
||||
{
|
||||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||||
@@ -170,7 +167,7 @@ void UserInterface::registerCustomer()
|
||||
return;
|
||||
}
|
||||
std::cout << "Enter password: ";
|
||||
util::readPassword(password);
|
||||
util::read(password);
|
||||
if (!util::isPasswordValid(password))
|
||||
{
|
||||
std::cout << "Error: Password is invalid!";
|
||||
|
||||
Reference in New Issue
Block a user