Implemented datastore shared memory codebase
Changes: - Added SharedMemory module for file-backed memory-mapped storage - Added MappingInfo, FileHeader, RecordState and TrackedRecord infrastructure - Replaced CSV-based serialization with binary struct serialization - Added DataStore initialization and shutdown lifecycle management - Added datastore mutex synchronization for multi-process access - Added shared-memory mapping configuration for all datastore entities - Added generic loadRecords and saveRecords template infrastructure - Added automatic datastore directory creation and .dat file storage - Updated configuration to use binary datastore files and initial capacities - Added enum underlying types for serialization compatibility - Added password masking support for login, registration and password change flows - Added Visual Studio project configuration for shared-memory components - Added datastore-owned record caches for runtime object management - Updated datastore APIs to return cached tracked-record collections by reference - Added generic cache refresh and cleanup infrastructure - Updated save operations to persist datastore caches directly - Added automatic cache cleanup during datastore destruction - Prepared datastore for multi-process shared-memory persistence
This commit is contained in:
+9
-2
@@ -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;%(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;%(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>
|
||||
@@ -129,6 +129,7 @@
|
||||
<ClCompile Include="core\patterns\Observer.cpp" />
|
||||
<ClCompile Include="core\patterns\Subject.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" />
|
||||
@@ -156,6 +157,12 @@
|
||||
<ClInclude Include="core\patterns\Observer.h" />
|
||||
<ClInclude Include="core\patterns\Subject.h" />
|
||||
<ClInclude Include="datastores\DataStore.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" />
|
||||
|
||||
+27
@@ -64,6 +64,12 @@
|
||||
<Filter Include="Source Files\Core\Patterns">
|
||||
<UniqueIdentifier>{8057b93d-51a9-42df-b06e-01ce395f6308}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Header Files\DataStores\SharedMemory">
|
||||
<UniqueIdentifier>{ec639004-44c6-4bd6-9963-077adde82b5f}</UniqueIdentifier>
|
||||
</Filter>
|
||||
<Filter Include="Source Files\DataStores\SharedMemory">
|
||||
<UniqueIdentifier>{7aa8722e-adfa-466e-8211-de63f3b7892b}</UniqueIdentifier>
|
||||
</Filter>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClCompile Include="Trenser.VehicleServiceSystem.cpp">
|
||||
@@ -141,6 +147,9 @@
|
||||
<ClCompile Include="models\ComboPackage.cpp">
|
||||
<Filter>Source Files\Models</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="datastores\sharedmemory\SharedMemory.cpp">
|
||||
<Filter>Source Files\DataStores\SharedMemory</Filter>
|
||||
</ClCompile>
|
||||
</ItemGroup>
|
||||
<ItemGroup>
|
||||
<ClInclude Include="utilities\InputHelper.h">
|
||||
@@ -251,5 +260,23 @@
|
||||
<ClInclude Include="views\MenuHelper.h">
|
||||
<Filter>Header Files\Views</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="datastores\sharedmemory\FileHeader.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="datastores\sharedmemory\MappingInfo.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="datastores\sharedmemory\RecordState.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="datastores\sharedmemory\TrackedRecord.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="datastores\sharedmemory\SerializedRecords.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="datastores\sharedmemory\SharedMemory.h">
|
||||
<Filter>Header Files\DataStores\SharedMemory</Filter>
|
||||
</ClInclude>
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -6,6 +6,7 @@ Description: Implementation file containing the method definitions of the
|
||||
Author: Trenser
|
||||
Date:19-May-2026
|
||||
*/
|
||||
|
||||
#include "ComboPackage.h"
|
||||
#include "Controller.h"
|
||||
#include "Enums.h"
|
||||
|
||||
+488
-52
@@ -9,6 +9,200 @@ Date: 19-May-2026
|
||||
*/
|
||||
|
||||
#include "DataStore.h"
|
||||
#include "Config.h"
|
||||
#include "SerializedRecords.h"
|
||||
#include "FileHelper.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.
|
||||
Creates or opens the global datastore mutex,
|
||||
configures all mapping metadata, and creates
|
||||
or opens the file mappings used to persist
|
||||
application data. After successful completion,
|
||||
all datastore files are mapped into memory and
|
||||
ready for use by the application.
|
||||
Parameter: None
|
||||
Return type: bool
|
||||
- true : Initialization completed successfully.
|
||||
- false : Failed to create the mutex or open
|
||||
one or more file mappings.
|
||||
*/
|
||||
bool DataStore::initialize()
|
||||
{
|
||||
m_globalMutex = CreateMutexA(NULL, FALSE, "VehicleServiceSystemMutex");
|
||||
if (m_globalMutex == NULL)
|
||||
{
|
||||
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);
|
||||
m_notifications.fileName = config::file::NOTIFICATION_FILE;
|
||||
m_notifications.recordSize = sizeof(SerializedNotification);
|
||||
m_services.fileName = config::file::SERVICE_FILE;
|
||||
m_services.recordSize = sizeof(SerializedService);
|
||||
m_comboPackages.fileName = config::file::COMBOPACKAGE_FILE;
|
||||
m_comboPackages.recordSize = sizeof(SerializedComboPackage);
|
||||
m_inventoryItems.fileName = config::file::INVENTORYITEM_FILE;
|
||||
m_inventoryItems.recordSize = sizeof(SerializedInventoryItem);
|
||||
m_serviceBookings.fileName = config::file::SERVICEBOOKING_FILE;
|
||||
m_serviceBookings.recordSize = sizeof(SerializedServiceBooking);
|
||||
m_jobCards.fileName = config::file::JOBCARD_FILE;
|
||||
m_jobCards.recordSize = sizeof(SerializedJobCard);
|
||||
m_invoices.fileName = config::file::INVOICE_FILE;
|
||||
m_invoices.recordSize = sizeof(SerializedInvoice);
|
||||
m_serviceManagementObservers.fileName = config::file::SERVICEMANAGEMENTOBSERVERS;
|
||||
m_serviceManagementObservers.recordSize = sizeof(SerializedObserver);
|
||||
m_paymentManagementObservers.fileName = config::file::PAYMENTMANAGEMENTOBSERVERS;
|
||||
m_paymentManagementObservers.recordSize = sizeof(SerializedObserver);
|
||||
m_inventoryManagementObservers.fileName = config::file::INVENTORYMANAGEMENTOBSERVERS;
|
||||
m_inventoryManagementObservers.recordSize = sizeof(SerializedObserver);
|
||||
if (!SharedMemory::createOrOpenMapping(m_users))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_notifications))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_services))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!SharedMemory::createOrOpenMapping(m_comboPackages))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_inventoryItems))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_serviceBookings))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_jobCards))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_invoices))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_payments))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_paymentManagementObservers))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_inventoryManagementObservers))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
} while (false);
|
||||
unlockDataStore();
|
||||
if (!success)
|
||||
{
|
||||
shutdown();
|
||||
}
|
||||
return success;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: shutdown
|
||||
Description: Releases all shared-memory resources owned by the
|
||||
datastore. Closes every file mapping, unmaps all
|
||||
mapped views, and releases the datastore mutex.
|
||||
After this call, the datastore must be initialized
|
||||
again before use.
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
void DataStore::shutdown()
|
||||
{
|
||||
SharedMemory::closeMapping(m_users);
|
||||
SharedMemory::closeMapping(m_notifications);
|
||||
SharedMemory::closeMapping(m_services);
|
||||
SharedMemory::closeMapping(m_comboPackages);
|
||||
SharedMemory::closeMapping(m_inventoryItems);
|
||||
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);
|
||||
if (m_globalMutex != NULL)
|
||||
{
|
||||
CloseHandle(m_globalMutex);
|
||||
m_globalMutex = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getInstance
|
||||
@@ -26,104 +220,346 @@ DataStore& DataStore::getInstance()
|
||||
|
||||
/*
|
||||
Function: getUsers
|
||||
Description: Retrieves the internal map of users.
|
||||
Description: Retrieves all user records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, User*> containing all users.
|
||||
- util::Map<std::string, TrackedRecord<User>>: Collection of user records
|
||||
*/
|
||||
util::Map<std::string, User*>& DataStore::getUsers()
|
||||
util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
|
||||
{
|
||||
return m_users;
|
||||
return m_userCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getNotifications
|
||||
Description: Retrieves all notification records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<Notification>>: Collection of notification records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
|
||||
{
|
||||
return m_notificationCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getServices
|
||||
Description: Retrieves the internal map of services.
|
||||
Description: Retrieves all service records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, Service*> containing all services.
|
||||
- util::Map<std::string, TrackedRecord<Service>>: Collection of service records
|
||||
*/
|
||||
util::Map<std::string, Service*>& DataStore::getServices()
|
||||
util::Map<std::string, TrackedRecord<Service>>& DataStore::getServices()
|
||||
{
|
||||
return m_services;
|
||||
return m_serviceCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getComboPackages
|
||||
Description: Retrieves the internal map of combo packages.
|
||||
Description: Retrieves all combo package records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, ComboPackage*> containing all combo packages.
|
||||
- util::Map<std::string, TrackedRecord<ComboPackage>>: Collection of combo package records
|
||||
*/
|
||||
util::Map<std::string, ComboPackage*>& DataStore::getComboPackages()
|
||||
util::Map<std::string, TrackedRecord<ComboPackage>>& DataStore::getComboPackages()
|
||||
{
|
||||
return m_comboPackages;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getServiceBookings
|
||||
Description: Retrieves the internal map of service bookings.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, ServiceBooking*> containing all service bookings.
|
||||
*/
|
||||
util::Map<std::string, ServiceBooking*>& DataStore::getServiceBookings()
|
||||
{
|
||||
return m_serviceBookings;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getJobCards
|
||||
Description: Retrieves the internal map of job cards.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, JobCard*> containing all job cards.
|
||||
*/
|
||||
util::Map<std::string, JobCard*>& DataStore::getJobCards()
|
||||
{
|
||||
return m_jobCards;
|
||||
return m_comboPackageCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getInventoryItems
|
||||
Description: Retrieves the internal map of inventory items.
|
||||
Description: Retrieves all inventory item records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, InventoryItem*> containing all inventory items.
|
||||
- util::Map<std::string, TrackedRecord<InventoryItem>>: Collection of inventory item records
|
||||
*/
|
||||
util::Map<std::string, InventoryItem*>& DataStore::getInventoryItems()
|
||||
util::Map<std::string, TrackedRecord<InventoryItem>>& DataStore::getInventoryItems()
|
||||
{
|
||||
return m_inventoryItems;
|
||||
return m_inventoryItemCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getServiceBookings
|
||||
Description: Retrieves all service booking records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<ServiceBooking>>: Collection of service booking records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<ServiceBooking>>& DataStore::getServiceBookings()
|
||||
{
|
||||
return m_serviceBookingCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getJobCards
|
||||
Description: Retrieves all job card records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, TrackedRecord<JobCard>>: Collection of job card records
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<JobCard>>& DataStore::getJobCards()
|
||||
{
|
||||
return m_jobCardCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getInvoices
|
||||
Description: Retrieves the internal map of invoices.
|
||||
Description: Retrieves all invoice records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, Invoice*> containing all invoices.
|
||||
- util::Map<std::string, TrackedRecord<Invoice>>: Collection of invoice records
|
||||
*/
|
||||
util::Map<std::string, Invoice*>& DataStore::getInvoices()
|
||||
util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
|
||||
{
|
||||
return m_invoices;
|
||||
return m_invoiceCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getPayments
|
||||
Description: Retrieves the internal map of payments.
|
||||
Function: getServiceManagementObservers
|
||||
Description: Retrieves all service management observer records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- Reference to util::Map<std::string, Payment*> containing all payments.
|
||||
- util::Map<std::string, User*>: Collection of observer records
|
||||
*/
|
||||
util::Map<std::string, Payment*>& DataStore::getPayments()
|
||||
util::Map<std::string, User*> DataStore::getServiceManagementObservers()
|
||||
{
|
||||
return m_payments;
|
||||
}
|
||||
return util::Map<std::string, User*>();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getPaymentManagementObservers
|
||||
Description: Retrieves all payment management observer records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, User*>: Collection of observer records
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getPaymentManagementObservers()
|
||||
{
|
||||
return util::Map<std::string, User*>();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getInventoryManagementObservers
|
||||
Description: Retrieves all inventory management observer records from the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- util::Map<std::string, User*>: Collection of observer records
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getInventoryManagementObservers()
|
||||
{
|
||||
return util::Map<std::string, User*>();
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveUsers
|
||||
Description: Persists all user records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveUsers()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveNotifications
|
||||
Description: Persists all notification records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveNotifications()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveServices
|
||||
Description: Persists all service records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveServices()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveComboPackages
|
||||
Description: Persists all combo package records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveComboPackages()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInventoryItems
|
||||
Description: Persists all inventory item records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveInventoryItems()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveServiceBookings
|
||||
Description: Persists all service booking records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveServiceBookings()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveJobCards
|
||||
Description: Persists all job card records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveJobCards()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInvoices
|
||||
Description: Persists all invoice records to the datastore.
|
||||
Parameters:
|
||||
- None
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveInvoices()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveServiceManagementObservers
|
||||
Description: Persists all service management observer records to the datastore.
|
||||
Parameters:
|
||||
- observers: util::Map<std::string, TrackedRecord<std::string>>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveServiceManagementObservers(util::Map<std::string, User*>& observers)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: savePaymentManagementObservers
|
||||
Description: Persists all payment management observer records to the datastore.
|
||||
Parameters:
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::savePaymentManagementObservers(util::Map<std::string, User*>& observers)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveInventoryManagementObservers
|
||||
Description: Persists all inventory management observer records to the datastore.
|
||||
Parameters:
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveInventoryManagementObservers(util::Map<std::string, User*>& 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;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: lockDataStore
|
||||
Description: Acquires the datastore mutex, providing
|
||||
exclusive access to the shared-memory
|
||||
datastore. This function blocks until
|
||||
the mutex becomes available or an error
|
||||
occurs.
|
||||
Parameter: None
|
||||
Return type:
|
||||
bool
|
||||
- true : Mutex successfully acquired.
|
||||
- false : Failed to acquire the mutex.
|
||||
*/
|
||||
bool DataStore::lockDataStore()
|
||||
{
|
||||
if (m_globalMutex == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
DWORD result = WaitForSingleObject(m_globalMutex, INFINITE);
|
||||
return result == WAIT_OBJECT_0;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: unlockDataStore
|
||||
Description: Releases the datastore mutex after a
|
||||
successful call to lockDataStore(),
|
||||
allowing other processes to access the
|
||||
shared-memory datastore.
|
||||
Parameter: None
|
||||
Return type:
|
||||
bool
|
||||
- true : Mutex successfully released.
|
||||
- false : Failed to release the mutex.
|
||||
*/
|
||||
bool DataStore::unlockDataStore()
|
||||
{
|
||||
if (m_globalMutex == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return ReleaseMutex(m_globalMutex) != 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -6,42 +6,232 @@ Date: 19-May-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <windows.h>
|
||||
#include <string>
|
||||
#include "Map.h"
|
||||
|
||||
#include "MappingInfo.h"
|
||||
#include "TrackedRecord.h"
|
||||
#include "SharedMemory.h"
|
||||
class User;
|
||||
class Notification;
|
||||
class Service;
|
||||
class ComboPackage;
|
||||
class InventoryItem;
|
||||
class ServiceBooking;
|
||||
class JobCard;
|
||||
class InventoryItem;
|
||||
class Invoice;
|
||||
class Payment;
|
||||
|
||||
class DataStore
|
||||
{
|
||||
private:
|
||||
util::Map<std::string, User*> m_users;
|
||||
util::Map<std::string, Service*> m_services;
|
||||
util::Map<std::string, ComboPackage*> m_comboPackages;
|
||||
util::Map<std::string, ServiceBooking*> m_serviceBookings;
|
||||
util::Map<std::string, JobCard*> m_jobCards;
|
||||
util::Map<std::string, InventoryItem*> m_inventoryItems;
|
||||
util::Map<std::string, Invoice*> m_invoices;
|
||||
util::Map<std::string, Payment*> m_payments;
|
||||
DataStore() {}
|
||||
public:
|
||||
static DataStore& getInstance();
|
||||
DataStore();
|
||||
~DataStore();
|
||||
DataStore(const DataStore&) = delete;
|
||||
DataStore& operator=(const DataStore&) = delete;
|
||||
DataStore(DataStore&&) = delete;
|
||||
DataStore& operator=(DataStore&&) = delete;
|
||||
util::Map<std::string, User*>& getUsers();
|
||||
util::Map<std::string, Service*>& getServices();
|
||||
util::Map<std::string, ComboPackage*>& getComboPackages();
|
||||
util::Map<std::string, ServiceBooking*>& getServiceBookings();
|
||||
util::Map<std::string, JobCard*>& getJobCards();
|
||||
util::Map<std::string, InventoryItem*>& getInventoryItems();
|
||||
util::Map<std::string, Invoice*>& getInvoices();
|
||||
util::Map<std::string, Payment*>& getPayments();
|
||||
};
|
||||
HANDLE m_globalMutex;
|
||||
MappingInfo m_users;
|
||||
MappingInfo m_notifications;
|
||||
MappingInfo m_services;
|
||||
MappingInfo m_comboPackages;
|
||||
MappingInfo m_inventoryItems;
|
||||
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);
|
||||
bool lockDataStore();
|
||||
bool unlockDataStore();
|
||||
private:
|
||||
template<typename TObject, typename TSerialized>
|
||||
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);
|
||||
};
|
||||
|
||||
/*
|
||||
Function: loadRecords
|
||||
Description: Loads all serialized records from the specified
|
||||
shared-memory mapping, deserializes them into
|
||||
application objects, and returns them as a map
|
||||
of tracked records. Each loaded record is marked
|
||||
as CLEAN and assigned its corresponding slot index
|
||||
within the mapping so that future modifications
|
||||
can be written back efficiently.
|
||||
Parameter:
|
||||
- mapping: Reference to the mapping containing the
|
||||
serialized records.
|
||||
Return type:
|
||||
util::Map<std::string, TrackedRecord<TObject>>
|
||||
A map containing all loaded records keyed by
|
||||
their unique identifier.
|
||||
*/
|
||||
template<typename TObject, typename TSerialized>
|
||||
util::Map<std::string, TrackedRecord<TObject>> DataStore::loadRecords(MappingInfo& mapping)
|
||||
{
|
||||
util::Map<std::string, TrackedRecord<TObject>> records;
|
||||
SharedMemory::ensureLatestMapping(mapping);
|
||||
size_t recordCount = SharedMemory::getRecordCount(mapping);
|
||||
for (size_t index = 0; index < recordCount; ++index)
|
||||
{
|
||||
TSerialized* serialized = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping,index));
|
||||
TObject* object = TObject::deserialize(*serialized);
|
||||
TrackedRecord<TObject> trackedRecord;
|
||||
trackedRecord.data = object;
|
||||
trackedRecord.state = RecordState::CLEAN;
|
||||
trackedRecord.slotIndex = index;
|
||||
records.insert(object->getId(), trackedRecord);
|
||||
}
|
||||
return records;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveRecords
|
||||
Description: Persists all modified and newly added records
|
||||
contained in the provided map to the specified
|
||||
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.
|
||||
Parameter:
|
||||
- mapping: Reference to the mapping where records are
|
||||
stored.
|
||||
- records: Map containing the records to be persisted.
|
||||
Return type: void
|
||||
*/
|
||||
template<typename TObject, typename TSerialized> void DataStore::saveRecords(MappingInfo& mapping, util::Map<std::string, TrackedRecord<TObject>>& records)
|
||||
{
|
||||
SharedMemory::ensureLatestMapping(mapping);
|
||||
for (int index = 0; index < records.getSize(); ++index)
|
||||
{
|
||||
TrackedRecord<TObject>& record = records.getValueAt(index);
|
||||
if (record.state == RecordState::CLEAN)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
TSerialized serialized = record.data->serialize();
|
||||
if (record.state == RecordState::MODIFIED)
|
||||
{
|
||||
TSerialized* destination = static_cast<TSerialized*>(SharedMemory::getRecordAddress(mapping, record.slotIndex));
|
||||
if (destination)
|
||||
{
|
||||
*destination = serialized;
|
||||
}
|
||||
}
|
||||
else if (record.state == RecordState::NEW_RECORD)
|
||||
{
|
||||
if (!SharedMemory::ensureCapacityForInsert(mapping))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
size_t recordCount = SharedMemory::getRecordCount(mapping);
|
||||
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);
|
||||
*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);
|
||||
if (cache.find(id) == -1)
|
||||
{
|
||||
delete oldCache.getValueAt(index).data;
|
||||
}
|
||||
}
|
||||
}
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
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;
|
||||
};
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
/*
|
||||
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>
|
||||
|
||||
struct MappingInfo
|
||||
{
|
||||
HANDLE fileHandle;
|
||||
HANDLE mappingHandle;
|
||||
void* mappedView;
|
||||
std::string fileName;
|
||||
size_t recordSize;
|
||||
size_t mappedCapacity;
|
||||
MappingInfo()
|
||||
: fileHandle(NULL),
|
||||
mappingHandle(NULL),
|
||||
mappedView(nullptr),
|
||||
recordSize(0),
|
||||
mappedCapacity(0) {}
|
||||
};
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
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
|
||||
};
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
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"
|
||||
#include "Timestamp.h"
|
||||
|
||||
struct SerializedUser
|
||||
{
|
||||
char id[64];
|
||||
char username[64];
|
||||
char password[64];
|
||||
char name[128];
|
||||
char phone[32];
|
||||
char email[128];
|
||||
util::UserType userType;
|
||||
util::State status;
|
||||
};
|
||||
|
||||
struct SerializedNotification
|
||||
{
|
||||
char id[64];
|
||||
char recipientUserId[64];
|
||||
char title[128];
|
||||
char message[1024];
|
||||
util::Timestamp createdAt;
|
||||
util::State state;
|
||||
};
|
||||
|
||||
struct SerializedService
|
||||
{
|
||||
char id[64];
|
||||
char name[128];
|
||||
char inventoryItemIDs[1024];
|
||||
double laborCost;
|
||||
util::State status;
|
||||
};
|
||||
|
||||
struct SerializedComboPackage
|
||||
{
|
||||
char id[64];
|
||||
char packageName[128];
|
||||
double discountPercentage;
|
||||
char serviceIDs[1024];
|
||||
util::State status;
|
||||
};
|
||||
|
||||
struct SerializedInventoryItem
|
||||
{
|
||||
char id[64];
|
||||
char partName[128];
|
||||
int quantity;
|
||||
double price;
|
||||
util::State status;
|
||||
};
|
||||
|
||||
struct SerializedServiceBooking
|
||||
{
|
||||
char id[64];
|
||||
util::ServiceJobStatus status;
|
||||
char serviceIDs[1024];
|
||||
char customerId[64];
|
||||
char vehicleNumber[64];
|
||||
char vehicleBrand[64];
|
||||
char vehicleModel[64];
|
||||
char assignedTechnicianId[64];
|
||||
double discountPercentage;
|
||||
};
|
||||
|
||||
struct SerializedJobCard
|
||||
{
|
||||
char id[64];
|
||||
char bookingId[64];
|
||||
char serviceId[64];
|
||||
char technicianId[64];
|
||||
util::Timestamp assignedDate;
|
||||
util::ServiceJobStatus status;
|
||||
util::Timestamp completionDate;
|
||||
};
|
||||
|
||||
struct SerializedInvoice
|
||||
{
|
||||
char id[64];
|
||||
char bookingId[64];
|
||||
util::Timestamp invoiceDate;
|
||||
char partIDs[1024];
|
||||
double laborCost;
|
||||
double partsCost;
|
||||
double discountPercentage;
|
||||
double totalAmount;
|
||||
util::Timestamp paymentDate;
|
||||
util::PaymentMode paymentMethod;
|
||||
util::PaymentStatus status;
|
||||
};
|
||||
|
||||
struct SerializedObserver
|
||||
{
|
||||
char id[64];
|
||||
};
|
||||
+385
@@ -0,0 +1,385 @@
|
||||
/*
|
||||
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 "Config.h"
|
||||
|
||||
/*
|
||||
Function: invalidateMapping
|
||||
Description: Releases all mapping resources and resets the mapping to an invalid state.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
static void invalidateMapping(MappingInfo& mapping)
|
||||
{
|
||||
if (mapping.mappedView != nullptr)
|
||||
{
|
||||
UnmapViewOfFile(mapping.mappedView);
|
||||
mapping.mappedView = nullptr;
|
||||
}
|
||||
if (mapping.mappingHandle != NULL)
|
||||
{
|
||||
CloseHandle(mapping.mappingHandle);
|
||||
mapping.mappingHandle = NULL;
|
||||
}
|
||||
if (mapping.fileHandle != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
CloseHandle(mapping.fileHandle);
|
||||
mapping.fileHandle = INVALID_HANDLE_VALUE;
|
||||
}
|
||||
mapping.mappedCapacity = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: createOrOpenMapping
|
||||
Description: Creates or opens a file mapping and maps it into the process address space.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
Returns:
|
||||
- bool: True if the mapping was successfully created/opened, otherwise false
|
||||
*/
|
||||
bool SharedMemory::createOrOpenMapping(MappingInfo& mapping)
|
||||
{
|
||||
if (mapping.recordSize == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
mapping.fileHandle =
|
||||
CreateFileA(
|
||||
mapping.fileName.c_str(),
|
||||
GENERIC_READ | GENERIC_WRITE,
|
||||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||||
NULL,
|
||||
OPEN_ALWAYS,
|
||||
FILE_ATTRIBUTE_NORMAL,
|
||||
NULL);
|
||||
if (mapping.fileHandle == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
LARGE_INTEGER fileSize;
|
||||
if (!GetFileSizeEx(mapping.fileHandle, &fileSize))
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
bool isNewFile = (fileSize.QuadPart == 0);
|
||||
const size_t initialCapacity = config::file::INITIAL_CAPACITY;
|
||||
if (isNewFile)
|
||||
{
|
||||
LARGE_INTEGER newSize;
|
||||
newSize.QuadPart = sizeof(FileHeader) + initialCapacity * mapping.recordSize;
|
||||
if (!SetFilePointerEx(mapping.fileHandle, newSize, NULL, FILE_BEGIN))
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
if (!SetEndOfFile(mapping.fileHandle))
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
mapping.mappingHandle =
|
||||
CreateFileMappingA(
|
||||
mapping.fileHandle,
|
||||
NULL,
|
||||
PAGE_READWRITE,
|
||||
0,
|
||||
0,
|
||||
NULL);
|
||||
if (mapping.mappingHandle == NULL)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
mapping.mappedView =
|
||||
MapViewOfFile(
|
||||
mapping.mappingHandle,
|
||||
FILE_MAP_ALL_ACCESS,
|
||||
0,
|
||||
0,
|
||||
0);
|
||||
if (mapping.mappedView == nullptr)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
FileHeader* header = getHeader(mapping);
|
||||
if (header == nullptr)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
if (isNewFile)
|
||||
{
|
||||
header->recordCount = 0;
|
||||
header->capacity = initialCapacity;
|
||||
}
|
||||
mapping.mappedCapacity = header->capacity;
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: closeMapping
|
||||
Description: Unmaps and closes all resources associated with a file mapping.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping to close
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void SharedMemory::closeMapping(MappingInfo& mapping)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getHeader
|
||||
Description: Returns the file header stored at the beginning of the mapped memory region.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
Returns:
|
||||
- FileHeader*: Pointer to the file header, or nullptr if the mapping is not valid
|
||||
*/
|
||||
FileHeader* SharedMemory::getHeader(MappingInfo& mapping)
|
||||
{
|
||||
if (mapping.mappedView == nullptr)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
return reinterpret_cast<FileHeader*>(mapping.mappedView);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getRecordAddress
|
||||
Description: Returns the address of a record at the specified index within the mapped memory region.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
- index: size_t, record index
|
||||
Returns:
|
||||
- void*: Pointer to the record, or nullptr if the mapping is not valid
|
||||
*/
|
||||
void* SharedMemory::getRecordAddress(MappingInfo& mapping, size_t index)
|
||||
{
|
||||
if (mapping.mappedView == nullptr)
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
return reinterpret_cast<char*>(mapping.mappedView) + sizeof(FileHeader) + index * mapping.recordSize;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getRecordCount
|
||||
Description: Returns the number of records currently stored in the mapping.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
Returns:
|
||||
- size_t: Number of records in the mapping
|
||||
*/
|
||||
size_t SharedMemory::getRecordCount(MappingInfo& mapping)
|
||||
{
|
||||
FileHeader* header = getHeader(mapping);
|
||||
if (header == nullptr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return header->recordCount;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: setRecordCount
|
||||
Description: Updates the number of records stored in the mapping.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
- count: size_t, new record count
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void SharedMemory::setRecordCount(MappingInfo& mapping, size_t count)
|
||||
{
|
||||
FileHeader* header = getHeader(mapping);
|
||||
if (header == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
header->recordCount = count;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getCapacity
|
||||
Description: Returns the current capacity of the mapping.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
Returns:
|
||||
- size_t: Maximum number of records that can be stored in the mapping
|
||||
*/
|
||||
size_t SharedMemory::getCapacity(MappingInfo& mapping)
|
||||
{
|
||||
FileHeader* header = getHeader(mapping);
|
||||
if (header == nullptr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return header->capacity;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: resizeMapping
|
||||
Description: Resizes the file mapping to the specified capacity.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
- newCapacity: size_t, new mapping capacity
|
||||
Returns:
|
||||
- bool: True if the resize succeeded, otherwise false
|
||||
*/
|
||||
bool SharedMemory::resizeMapping(MappingInfo& mapping, size_t newCapacity)
|
||||
{
|
||||
FileHeader* header = getHeader(mapping);
|
||||
if (header == nullptr)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
header->capacity = newCapacity;
|
||||
if (!FlushViewOfFile(mapping.mappedView, sizeof(FileHeader)))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!UnmapViewOfFile(mapping.mappedView))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
mapping.mappedView = nullptr;
|
||||
CloseHandle(mapping.mappingHandle);
|
||||
mapping.mappingHandle = NULL;
|
||||
LARGE_INTEGER newSize;
|
||||
newSize.QuadPart = sizeof(FileHeader) + newCapacity * mapping.recordSize;
|
||||
if (!SetFilePointerEx(mapping.fileHandle, newSize, NULL, FILE_BEGIN))
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
if (!SetEndOfFile(mapping.fileHandle))
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
mapping.mappingHandle =
|
||||
CreateFileMappingA(
|
||||
mapping.fileHandle,
|
||||
NULL,
|
||||
PAGE_READWRITE,
|
||||
0,
|
||||
0,
|
||||
NULL);
|
||||
if (mapping.mappingHandle == NULL)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
mapping.mappedView =
|
||||
MapViewOfFile(
|
||||
mapping.mappingHandle,
|
||||
FILE_MAP_ALL_ACCESS,
|
||||
0,
|
||||
0,
|
||||
0);
|
||||
if (mapping.mappedView == nullptr)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
mapping.mappedCapacity = newCapacity;
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: ensureCapacityForInsert
|
||||
Description: Ensures that the mapping has space for at least one additional record, growing it if necessary.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
Returns:
|
||||
- bool: True if capacity is available, otherwise false
|
||||
*/
|
||||
bool SharedMemory::ensureCapacityForInsert(MappingInfo& mapping)
|
||||
{
|
||||
size_t recordCount = getRecordCount(mapping);
|
||||
size_t capacity = getCapacity(mapping);
|
||||
if (recordCount < capacity)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return resizeMapping(mapping, capacity * 2);
|
||||
}
|
||||
|
||||
/*
|
||||
Function: ensureLatestMapping
|
||||
Description: Remaps the file if another process has resized it.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, mapping information and handles
|
||||
Returns:
|
||||
- bool: True if the mapping is valid and up to date, otherwise false
|
||||
*/
|
||||
bool SharedMemory::ensureLatestMapping(MappingInfo& mapping)
|
||||
{
|
||||
FileHeader* header = getHeader(mapping);
|
||||
if (header == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (header->capacity == mapping.mappedCapacity)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (!UnmapViewOfFile(mapping.mappedView))
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
mapping.mappedView = nullptr;
|
||||
CloseHandle(mapping.mappingHandle);
|
||||
mapping.mappingHandle = NULL;
|
||||
mapping.mappingHandle =
|
||||
CreateFileMappingA(
|
||||
mapping.fileHandle,
|
||||
NULL,
|
||||
PAGE_READWRITE,
|
||||
0,
|
||||
0,
|
||||
NULL);
|
||||
if (mapping.mappingHandle == NULL)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
mapping.mappedView =
|
||||
MapViewOfFile(
|
||||
mapping.mappingHandle,
|
||||
FILE_MAP_ALL_ACCESS,
|
||||
0,
|
||||
0,
|
||||
0);
|
||||
if (mapping.mappedView == nullptr)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
header = getHeader(mapping);
|
||||
if (header == nullptr)
|
||||
{
|
||||
invalidateMapping(mapping);
|
||||
return false;
|
||||
}
|
||||
mapping.mappedCapacity = header->capacity;
|
||||
return true;
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
/*
|
||||
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"
|
||||
#include "FileHeader.h"
|
||||
|
||||
namespace SharedMemory
|
||||
{
|
||||
bool createOrOpenMapping(MappingInfo& mapping);
|
||||
void closeMapping(MappingInfo& mapping);
|
||||
bool ensureLatestMapping(MappingInfo& mapping);
|
||||
bool resizeMapping(MappingInfo& mapping, size_t newCapacity);
|
||||
FileHeader* getHeader(MappingInfo& mapping);
|
||||
void* getRecordAddress(MappingInfo& mapping, size_t index);
|
||||
size_t getRecordCount(MappingInfo& mapping);
|
||||
void setRecordCount(MappingInfo& mapping, size_t count);
|
||||
size_t getCapacity(MappingInfo& mapping);
|
||||
bool ensureCapacityForInsert(MappingInfo& mapping);
|
||||
};
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
/*
|
||||
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"
|
||||
|
||||
static const size_t INVALID_SLOT = static_cast<size_t>(-1);
|
||||
|
||||
template<typename T>
|
||||
struct TrackedRecord
|
||||
{
|
||||
T* data;
|
||||
RecordState state;
|
||||
size_t slotIndex;
|
||||
TrackedRecord()
|
||||
: data(nullptr),
|
||||
state(RecordState::CLEAN),
|
||||
slotIndex(INVALID_SLOT) {}
|
||||
TrackedRecord(
|
||||
T* object,
|
||||
RecordState recordState,
|
||||
size_t slot)
|
||||
: data(object),
|
||||
state(recordState),
|
||||
slotIndex(slot) {}
|
||||
};
|
||||
+1
@@ -6,6 +6,7 @@ Description: Header file declaring the UserManagementService class, which manage
|
||||
Author: Trenser
|
||||
Date:19-May-2026
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <string>
|
||||
#include "Map.h"
|
||||
|
||||
@@ -28,16 +28,18 @@ namespace config
|
||||
|
||||
namespace file
|
||||
{
|
||||
constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.csv";
|
||||
constexpr const char* USER_FILE = "files/User.csv";
|
||||
constexpr const char* NOTIFICATION_FILE = "files/Notification.csv";
|
||||
constexpr const char* SERVICE_FILE = "files/Service.csv";
|
||||
constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.csv";
|
||||
constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.csv";
|
||||
constexpr const char* JOBCARD_FILE = "files/JobCard.csv";
|
||||
constexpr const char* INVOICE_FILE = "files/Invoice.csv";
|
||||
constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.csv";
|
||||
constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.csv";
|
||||
constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.csv";
|
||||
const size_t INITIAL_CAPACITY = 100;
|
||||
constexpr const char* DIRECTORY = "files/";
|
||||
constexpr const char* INVENTORYITEM_FILE = "files/InventoryItem.dat";
|
||||
constexpr const char* USER_FILE = "files/User.dat";
|
||||
constexpr const char* NOTIFICATION_FILE = "files/Notification.dat";
|
||||
constexpr const char* SERVICE_FILE = "files/Service.dat";
|
||||
constexpr const char* COMBOPACKAGE_FILE = "files/ComboPackage.dat";
|
||||
constexpr const char* SERVICEBOOKING_FILE = "files/ServiceBooking.dat";
|
||||
constexpr const char* JOBCARD_FILE = "files/JobCard.dat";
|
||||
constexpr const char* INVOICE_FILE = "files/Invoice.dat";
|
||||
constexpr const char* SERVICEMANAGEMENTOBSERVERS = "files/ServiceManagementObservers.dat";
|
||||
constexpr const char* PAYMENTMANAGEMENTOBSERVERS = "files/PaymentManagementObservers.dat";
|
||||
constexpr const char* INVENTORYMANAGEMENTOBSERVERS = "files/InventoryManagementObservers.dat";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,28 +12,28 @@ Date: 19-May-2026
|
||||
|
||||
namespace util
|
||||
{
|
||||
enum class UserType
|
||||
enum class UserType : int
|
||||
{
|
||||
ADMIN,
|
||||
TECHNICIAN,
|
||||
CUSTOMER
|
||||
};
|
||||
|
||||
enum class PaymentMode
|
||||
enum class PaymentMode : int
|
||||
{
|
||||
ONLINE,
|
||||
OFFLINE,
|
||||
NOTSET
|
||||
};
|
||||
|
||||
enum class PaymentStatus
|
||||
enum class PaymentStatus : int
|
||||
{
|
||||
PENDING,
|
||||
COMPLETED,
|
||||
PAID
|
||||
};
|
||||
|
||||
enum class ServiceJobStatus
|
||||
enum class ServiceJobStatus : int
|
||||
{
|
||||
PENDING,
|
||||
STARTED,
|
||||
@@ -42,7 +42,7 @@ namespace util
|
||||
CANCELLED
|
||||
};
|
||||
|
||||
enum class State
|
||||
enum class State : int
|
||||
{
|
||||
ACTIVE,
|
||||
INACTIVE
|
||||
|
||||
@@ -106,4 +106,4 @@ namespace util
|
||||
file << records[index] << '\n';
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
#include <conio.h>
|
||||
|
||||
namespace util
|
||||
{
|
||||
@@ -54,6 +55,48 @@ 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.
|
||||
|
||||
@@ -99,4 +99,80 @@ namespace util
|
||||
auto observerIDs = service->getObserverIDs();
|
||||
util::saveRecords(filePath, observerIDs);
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
const std::string& key = trackedRecords.getKeyAt(index);
|
||||
const TObject* object = trackedRecords.getValueAt(index).data;
|
||||
objects.insert(key, object);
|
||||
}
|
||||
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;
|
||||
}
|
||||
@@ -30,7 +30,6 @@ Description: Displays the customer menu and handles user input until logout is s
|
||||
Parameter: None
|
||||
Return type: void
|
||||
*/
|
||||
|
||||
void CustomerMenu::showMenu()
|
||||
{
|
||||
while (true)
|
||||
|
||||
@@ -914,7 +914,7 @@ inline void changePasswordHelper(Controller& controller)
|
||||
util::clear();
|
||||
std::cout << "Change Password\n";
|
||||
std::cout << "Enter new password: ";
|
||||
util::read(newPassword);
|
||||
util::readPassword(newPassword);
|
||||
if (!util::isPasswordValid(newPassword))
|
||||
{
|
||||
std::cout << "Error: Password is not strong enough!\n";
|
||||
@@ -928,7 +928,7 @@ inline void changePasswordHelper(Controller& controller)
|
||||
continue;
|
||||
}
|
||||
std::cout << "Confirm new password: ";
|
||||
util::read(confirmedPassword);
|
||||
util::readPassword(confirmedPassword);
|
||||
if (confirmedPassword != newPassword)
|
||||
{
|
||||
std::cout << "Passwords are different. Try again\n";
|
||||
|
||||
@@ -22,4 +22,4 @@ public:
|
||||
void viewNotifications();
|
||||
void logout();
|
||||
void changePassword();
|
||||
};
|
||||
};
|
||||
@@ -106,7 +106,7 @@ void UserInterface::login()
|
||||
std::cout << "Enter username: ";
|
||||
util::read(username);
|
||||
std::cout << "Enter password: ";
|
||||
util::read(password);
|
||||
util::readPassword(password);
|
||||
if (m_controller.login(username, password))
|
||||
{
|
||||
const User* authenticatedUser = m_controller.getAuthenticatedUser();
|
||||
@@ -167,7 +167,7 @@ void UserInterface::registerCustomer()
|
||||
return;
|
||||
}
|
||||
std::cout << "Enter password: ";
|
||||
util::read(password);
|
||||
util::readPassword(password);
|
||||
if (!util::isPasswordValid(password))
|
||||
{
|
||||
std::cout << "Error: Password is invalid!";
|
||||
@@ -185,4 +185,4 @@ void UserInterface::registerCustomer()
|
||||
m_controller.createCustomer(username, name, password, email, phone);
|
||||
std::cout << "Registration is successful";
|
||||
util::pressEnter();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user