Merge branch 'develop' into develop-sm-inventory-management
This commit is contained in:
+209
-50
@@ -12,6 +12,8 @@ Date: 19-May-2026
|
||||
#include "Config.h"
|
||||
#include "SerializedRecords.h"
|
||||
#include "FileHelper.h"
|
||||
#include "ServiceBooking.h"
|
||||
#include "JobCard.h"
|
||||
|
||||
/*
|
||||
Function: DataStore
|
||||
@@ -144,11 +146,6 @@ bool DataStore::initialize()
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_payments))
|
||||
{
|
||||
success = false;
|
||||
break;
|
||||
}
|
||||
if (!SharedMemory::createOrOpenMapping(m_serviceManagementObservers))
|
||||
{
|
||||
success = false;
|
||||
@@ -193,7 +190,6 @@ 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);
|
||||
@@ -230,20 +226,6 @@ util::Map<std::string, TrackedRecord<User>>& DataStore::getUsers()
|
||||
{
|
||||
auto users = loadRecords<User, SerializedUser>(m_users);
|
||||
refreshCache(m_userCache, users);
|
||||
auto& notifications = getNotifications();
|
||||
int numberOfNotifications = m_notificationCache.getSize();
|
||||
for (int index = 0; index < numberOfNotifications; index++)
|
||||
{
|
||||
Notification* notification = notifications.getValueAt(index).data;
|
||||
const std::string& recipientUserId = notification->getRecipientUserId();
|
||||
int userIndex = m_userCache.find(recipientUserId);
|
||||
if (userIndex == -1)
|
||||
{
|
||||
throw std::runtime_error("Invalid recipient user ID");
|
||||
}
|
||||
User* user = m_userCache.getValueAt(userIndex).data;
|
||||
user->addNotification(notification);
|
||||
}
|
||||
return m_userCache;
|
||||
}
|
||||
|
||||
@@ -257,6 +239,8 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, TrackedRecord<Notification>>& DataStore::getNotifications()
|
||||
{
|
||||
auto notifications = loadRecords<Notification, SerializedNotification>(m_notifications);
|
||||
refreshCache(m_notificationCache, notifications);
|
||||
return m_notificationCache;
|
||||
}
|
||||
|
||||
@@ -270,6 +254,28 @@ Returns:
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -283,6 +289,28 @@ Returns:
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -311,6 +339,49 @@ Returns:
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -324,9 +395,51 @@ Returns:
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Function: getInvoices
|
||||
Description: Retrieves all invoice records from the datastore.
|
||||
@@ -340,6 +453,37 @@ util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
|
||||
return m_invoiceCache;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getObservers
|
||||
Description: Retrieves observer records from the specified observer mapping
|
||||
and resolves them to User objects.
|
||||
Parameters:
|
||||
- mapping: Observer mapping to read from
|
||||
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, User*> DataStore::getObservers(MappingInfo& mapping)
|
||||
{
|
||||
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;
|
||||
}
|
||||
|
||||
/*
|
||||
Function: getServiceManagementObservers
|
||||
Description: Retrieves all service management observer records from the datastore.
|
||||
@@ -350,7 +494,7 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getServiceManagementObservers()
|
||||
{
|
||||
return util::Map<std::string, User*>();
|
||||
return getObservers(m_serviceManagementObservers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -363,7 +507,7 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getPaymentManagementObservers()
|
||||
{
|
||||
return util::Map<std::string, User*>();
|
||||
return getObservers(m_paymentManagementObservers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -376,7 +520,7 @@ Returns:
|
||||
*/
|
||||
util::Map<std::string, User*> DataStore::getInventoryManagementObservers()
|
||||
{
|
||||
return util::Map<std::string, User*>();
|
||||
return getObservers(m_inventoryManagementObservers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -389,6 +533,7 @@ Returns:
|
||||
*/
|
||||
void DataStore::saveUsers()
|
||||
{
|
||||
saveRecords<User, SerializedUser>(m_users, m_userCache);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -401,6 +546,7 @@ Returns:
|
||||
*/
|
||||
void DataStore::saveNotifications()
|
||||
{
|
||||
saveRecords<Notification, SerializedNotification>(m_notifications, m_notificationCache);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -413,6 +559,7 @@ Returns:
|
||||
*/
|
||||
void DataStore::saveServices()
|
||||
{
|
||||
saveRecords<Service, SerializedService>(m_services, m_serviceCache);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -425,6 +572,7 @@ Returns:
|
||||
*/
|
||||
void DataStore::saveComboPackages()
|
||||
{
|
||||
saveRecords<ComboPackage, SerializedComboPackage>(m_comboPackages, m_comboPackageCache);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -450,6 +598,7 @@ Returns:
|
||||
*/
|
||||
void DataStore::saveServiceBookings()
|
||||
{
|
||||
saveRecords<ServiceBooking, SerializedServiceBooking>(m_serviceBookings, m_serviceBookingCache);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -462,6 +611,7 @@ Returns:
|
||||
*/
|
||||
void DataStore::saveJobCards()
|
||||
{
|
||||
saveRecords<JobCard, SerializedJobCard>(m_jobCards, m_jobCardCache);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -476,16 +626,49 @@ void DataStore::saveInvoices()
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
Function: saveObservers
|
||||
Description: Persists observer records to the specified observer mapping.
|
||||
Parameters:
|
||||
- mapping: MappingInfo&, observer mapping to save to
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveObservers(MappingInfo& mapping, util::Map<std::string, User*>& observers)
|
||||
{
|
||||
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, TrackedRecord<std::string>>&, collection of observer records
|
||||
- observers: util::Map<std::string, User*>&, collection of observer records
|
||||
Returns:
|
||||
- None
|
||||
*/
|
||||
void DataStore::saveServiceManagementObservers(util::Map<std::string, User*>& observers)
|
||||
{
|
||||
saveObservers(m_serviceManagementObservers, observers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -498,6 +681,7 @@ Returns:
|
||||
*/
|
||||
void DataStore::savePaymentManagementObservers(util::Map<std::string, User*>& observers)
|
||||
{
|
||||
saveObservers(m_paymentManagementObservers, observers);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -510,32 +694,7 @@ Returns:
|
||||
*/
|
||||
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;
|
||||
saveObservers(m_inventoryManagementObservers, observers);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
Reference in New Issue
Block a user