joelthomastrenser
8aaa4eeec0
Changes: - Implements #2061 - Introduce EventManager for user-specific Windows event publishing/listening - Add real-time notification and account-disabled event propagation - Register authentication events through Controller and AuthenticationManagementService - Trigger notification events from Inventory, Payment, and Service Management modules - Trigger account-disabled events when users are deactivated - Extract common menu event listener logic into Menu base class - Add notification popup handling for Admin, Customer, and Technician menus - Refactor shared memory components into core/sharedmemory - Update project structure and include paths for events and shared memory modules
638 lines
22 KiB
C++
638 lines
22 KiB
C++
/*
|
||
File: Controller.cpp
|
||
Description: Implementation file containing the method definitions of the
|
||
Controller class, including authentication, user creation,
|
||
service purchasing, and system checks.
|
||
Author: Trenser
|
||
Date:19-May-2026
|
||
*/
|
||
|
||
#include "ComboPackage.h"
|
||
#include "Controller.h"
|
||
#include "Enums.h"
|
||
#include "InventoryItem.h"
|
||
#include "Invoice.h"
|
||
#include "JobCard.h"
|
||
#include "Service.h"
|
||
#include "ServiceBooking.h"
|
||
#include "User.h"
|
||
#include <stdexcept>
|
||
|
||
/*
|
||
Function: login
|
||
Description: Authenticates a user by delegating to the authentication management service.
|
||
Parameter: const std::string& username - user’s username
|
||
const std::string& password - user’s password
|
||
Return type: bool - true if login successful, false otherwise
|
||
*/
|
||
bool Controller::login(const std::string& username, const std::string& password)
|
||
{
|
||
return m_authenticationManagementService.login(username, password);
|
||
}
|
||
|
||
/*
|
||
Function: logout
|
||
Description: Logs out the currently authenticated user.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void Controller::logout()
|
||
{
|
||
m_authenticationManagementService.logout();
|
||
}
|
||
|
||
/*
|
||
Function: changePassword
|
||
Description: Changes the password of the currently authenticated user.
|
||
Parameter: const std::string& newPassword - new password to set
|
||
Return type: void
|
||
*/
|
||
void Controller::changePassword(const std::string& newPassword)
|
||
{
|
||
m_authenticationManagementService.changePassword(newPassword);
|
||
}
|
||
|
||
/*
|
||
Function: createCustomer
|
||
Description: Creates a new customer account with the provided details.
|
||
Parameter: const std::string& username - customer’s username
|
||
const std::string& name - customer’s name
|
||
const std::string& password - customer’s password
|
||
const std::string& email - customer’s email
|
||
const std::string& phone - customer’s phone number
|
||
Return type: void
|
||
*/
|
||
|
||
void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
|
||
{
|
||
m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
|
||
}
|
||
|
||
/*
|
||
Function: getAuthenticatedUser
|
||
Description: Retrieves the currently authenticated user.
|
||
Parameter: None
|
||
Return type: const User* - pointer to the authenticated user
|
||
*/
|
||
const User* Controller::getAuthenticatedUser()
|
||
{
|
||
return m_authenticationManagementService.getAuthenticatedUser();
|
||
}
|
||
|
||
/*
|
||
Function: createTechnician
|
||
Description: Creates a new technician account with provided details by
|
||
delegating to the user management service.
|
||
Parameter: const std::string& username - technician's username
|
||
const std::string& password - technician's password
|
||
const std::string& email - technician's email address
|
||
const std::string& phoneNumber - technician's phone number
|
||
Return type: void
|
||
*/
|
||
void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber)
|
||
{
|
||
m_userManagementService.createUser(username, name, password, email, phoneNumber, util::UserType::TECHNICIAN);
|
||
}
|
||
|
||
/*
|
||
Function: updateUserDetails
|
||
Description: Updates the email and phone details of the currently authenticated user.
|
||
Parameter: const std::string& email - new email address
|
||
const std::string& phone - new phone number
|
||
Return type: void
|
||
*/
|
||
void Controller::updateUserDetails(const std::string& email, const std::string& phone)
|
||
{
|
||
User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
|
||
if (authenticatedUser == nullptr)
|
||
{
|
||
throw std::runtime_error("No user currently logged in!");
|
||
}
|
||
m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
|
||
}
|
||
|
||
/*
|
||
Function: getServices
|
||
Description: Retrieves all available services in read-only form.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- util::Map<std::string, const Service*> containing all services
|
||
*/
|
||
util::Map<std::string, const Service*> Controller::getServices()
|
||
{
|
||
util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
|
||
util::Map<std::string, const Service*> readOnlyServices;
|
||
for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
|
||
{
|
||
readOnlyServices.insert(currentServices.getValueAt(iterator)->getId(), currentServices.getValueAt(iterator));
|
||
}
|
||
return readOnlyServices;
|
||
}
|
||
|
||
/*
|
||
Function: getComboPackages
|
||
Description: Retrieves all available combo packages from the service
|
||
management service and constructs a read-only map.
|
||
Parameter: None
|
||
Return type: util::Map<std::string, const ComboPackage*>
|
||
*/
|
||
util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
|
||
{
|
||
util::Map<std::string, ComboPackage*> currentAvailableComboPackages = m_serviceManagementService.getComboPackages();
|
||
util::Map<std::string, const ComboPackage*> readOnlyComboPackages;
|
||
for (int iterator = 0; iterator < currentAvailableComboPackages.getSize(); iterator++)
|
||
{
|
||
ComboPackage* currentComboPackage = currentAvailableComboPackages.getValueAt(iterator);
|
||
if (currentComboPackage)
|
||
{
|
||
readOnlyComboPackages.insert(currentComboPackage->getId(), currentComboPackage);
|
||
}
|
||
}
|
||
return readOnlyComboPackages;
|
||
}
|
||
|
||
/*
|
||
Function: purchaseService
|
||
Description: Purchases one or more services for a vehicle by delegating to the service management service.
|
||
Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
|
||
const std::string& vehicleNumber - vehicle registration number
|
||
const std::string& vehicleBrand - brand of the vehicle
|
||
const std::string& vehicleModel - model of the vehicle
|
||
Return type: void
|
||
*/
|
||
void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
|
||
{
|
||
m_serviceManagementService.purchaseService(serviceIDs, vehicleNumber, vehicleBrand, vehicleModel);
|
||
}
|
||
|
||
/*
|
||
Function: purchaseComboPackage
|
||
Description: Purchases a combo package for a vehicle by delegating to the service management service.
|
||
Parameter: const std::string& comboPackageID - ID of the combo package
|
||
const std::string& vehicleNumber - vehicle registration number
|
||
const std::string& vehicleBrand - brand of the vehicle
|
||
const std::string& vehicleModel - model of the vehicle
|
||
Return type: void
|
||
*/
|
||
void Controller::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
|
||
{
|
||
m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
|
||
}
|
||
|
||
/*
|
||
Function: getInventoryItems
|
||
Description: Retrieves all inventory items from the inventory management service
|
||
and constructs a read-only map for external use.
|
||
Parameter: None
|
||
Return type: util::Map<std::string, const InventoryItem*>
|
||
*/
|
||
util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
|
||
{
|
||
auto inventoryItems = m_inventoryManagementService.getInventoryItems();
|
||
util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
|
||
int inventoryItemsMapSize = inventoryItems.getSize();
|
||
for (int index = 0; index < inventoryItemsMapSize; index++)
|
||
{
|
||
readOnlyInventoryItems.insert(inventoryItems.getKeyAt(index), inventoryItems.getValueAt(index));
|
||
}
|
||
return readOnlyInventoryItems;
|
||
}
|
||
|
||
/*
|
||
Function: getInventoryItem
|
||
Description: Retrieves a specific inventory item by its ID from the inventory management service.
|
||
Parameter: const std::string& inventoryItemID - ID of the inventory item
|
||
Return type: const InventoryItem*
|
||
*/
|
||
const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
|
||
{
|
||
return m_inventoryManagementService.getInventoryItem(inventoryItemID);
|
||
}
|
||
|
||
/*
|
||
Function: addInventoryItem
|
||
Description: Adds a new inventory item with specified details to the inventory management service.
|
||
Parameter: const std::string& partName - name of the part
|
||
int quantity - quantity of the part
|
||
double price - price of the part
|
||
Return type: void
|
||
*/
|
||
void Controller::addInventoryItem(const std::string& partName, int quantity, double price)
|
||
{
|
||
m_inventoryManagementService.addInventoryItem(partName, quantity, price);
|
||
}
|
||
|
||
/*
|
||
Function: removeInventoryItem
|
||
Description: Removes an inventory item from the inventory management service by its ID.
|
||
Parameter: const std::string& inventoryItemID - ID of the inventory item
|
||
Return type: void
|
||
*/
|
||
void Controller::removeInventoryItem(const std::string& inventoryItemID)
|
||
{
|
||
m_inventoryManagementService.removeInventoryItem(inventoryItemID);
|
||
}
|
||
|
||
/*
|
||
Function: addInventoryItemStock
|
||
Description: Adds stock to an existing inventory item in the inventory management service.
|
||
Parameter: const std::string& selectedItemId - ID of the inventory item
|
||
int quantity - quantity to add
|
||
Return type: void
|
||
*/
|
||
void Controller::addInventoryItemStock(const std::string& selectedItemId, int quantity)
|
||
{
|
||
m_inventoryManagementService.addInventoryItemStock(selectedItemId, quantity);
|
||
}
|
||
|
||
/*
|
||
Function: getServiceBookings
|
||
Description: Retrieves all service bookings in read-only form.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- util::Map<std::string, const ServiceBooking*> containing service bookings
|
||
*/
|
||
util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
|
||
{
|
||
auto serviceBookings = m_serviceManagementService.getServiceBookings();
|
||
util::Map<std::string, const ServiceBooking*> readOnlyServiceBookings;
|
||
for (int iterator = 0; iterator < serviceBookings.getSize(); iterator++)
|
||
{
|
||
readOnlyServiceBookings.insert(serviceBookings.getKeyAt(iterator), serviceBookings.getValueAt(iterator));
|
||
}
|
||
return readOnlyServiceBookings;
|
||
}
|
||
|
||
/*
|
||
Function: getServiceBookingsByUser
|
||
Description: Retrieves all service bookings for a specific user.
|
||
Parameters:
|
||
- userID: std::string, the user ID
|
||
Returns:
|
||
- util::Map<std::string, const ServiceBooking*> containing bookings for the user
|
||
*/
|
||
util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
|
||
{
|
||
util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
|
||
util::Map<std::string, ServiceBooking*> currentServiceBookingsByUser = m_serviceManagementService.getServiceBookings(userID);
|
||
for (int iterator = 0; iterator < currentServiceBookingsByUser.getSize(); iterator++)
|
||
{
|
||
readOnlyServiceBookingsByUserMap.insert(currentServiceBookingsByUser.getValueAt(iterator)->getId(), currentServiceBookingsByUser.getValueAt(iterator));
|
||
}
|
||
return readOnlyServiceBookingsByUserMap;
|
||
}
|
||
|
||
/*
|
||
Function: getUsers
|
||
Description: Retrieves all users from the user management service and
|
||
constructs a read-only map.
|
||
Parameter: None
|
||
Return type: util::Map<std::string, const User*>
|
||
*/
|
||
util::Map<std::string, const User*> Controller::getUsers()
|
||
{
|
||
auto listOfUsers = m_userManagementService.getUsers();
|
||
util::Map<std::string, const User*> readOnlyUserList;
|
||
for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
|
||
{
|
||
readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
|
||
}
|
||
return readOnlyUserList;
|
||
}
|
||
|
||
/*
|
||
Function: getUsers
|
||
Description: Retrieves users filtered by user type.
|
||
Parameters:
|
||
- userType: util::UserType, type of user (CUSTOMER, TECHNICIAN, ADMIN)
|
||
Returns:
|
||
- util::Map<std::string, const User*> containing users of the specified type
|
||
*/
|
||
util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
|
||
{
|
||
auto userMap = m_userManagementService.getUsers(userType);
|
||
util::Map<std::string, const User*> readOnlyUserMap;
|
||
for (int iterator = 0; iterator < userMap.getSize(); iterator++)
|
||
{
|
||
readOnlyUserMap.insert(userMap.getKeyAt(iterator), userMap.getValueAt(iterator));
|
||
}
|
||
return readOnlyUserMap;
|
||
}
|
||
|
||
/*
|
||
Function: createJobCard
|
||
Description: Creates a job card for a service booking assigned to a technician.
|
||
Parameters:
|
||
- bookingID: std::string, ID of the service booking
|
||
- technicianID: std::string, ID of the technician
|
||
- serviceID: std::string, ID of the service
|
||
Returns:
|
||
- void
|
||
*/
|
||
void Controller::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
|
||
{
|
||
m_serviceManagementService.createJobCard(bookingID, technicianID, serviceID);
|
||
}
|
||
|
||
/*
|
||
Function: createService
|
||
Description: Creates a new service with associated inventory items and labor cost.
|
||
Parameters:
|
||
- name: std::string, name of the service
|
||
- inventoryItemIDs: Vector of inventory item IDs
|
||
- laborCost: double, labor cost
|
||
Returns:
|
||
- void
|
||
*/
|
||
void Controller::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
|
||
{
|
||
m_serviceManagementService.createService(name, inventoryItemIDs, laborCost);
|
||
}
|
||
|
||
/*
|
||
Function: removeService
|
||
Description: Removes a service from the system by ID.
|
||
Parameters:
|
||
- serviceID: std::string, ID of the service
|
||
Returns:
|
||
- void
|
||
*/
|
||
void Controller::removeService(const std::string& serviceID)
|
||
{
|
||
m_serviceManagementService.removeService(serviceID);
|
||
}
|
||
|
||
/*
|
||
Function: getJobCardsByUser
|
||
Description: Retrieves job cards assigned to the authenticated technician.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- util::Map<std::string, const JobCard*> containing job cards
|
||
*/
|
||
util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
|
||
{
|
||
const User* currentUser = getAuthenticatedUser();
|
||
auto jobCardsAssignedToTechnician = m_serviceManagementService.getJobCards(currentUser->getId());
|
||
util::Map<std::string, const JobCard*> readOnlyJobCardMap;
|
||
for (int iterator = 0; iterator < jobCardsAssignedToTechnician.getSize(); iterator++)
|
||
{
|
||
JobCard* currentJobCard = jobCardsAssignedToTechnician.getValueAt(iterator);
|
||
readOnlyJobCardMap.insert(currentJobCard->getId(), currentJobCard);
|
||
}
|
||
return readOnlyJobCardMap;
|
||
}
|
||
|
||
/*
|
||
Function: completeJob
|
||
Description: Marks a job card as completed.
|
||
Parameters:
|
||
- jobID: std::string, ID of the job card
|
||
Returns:
|
||
- void
|
||
*/
|
||
void Controller::updateJobStatus(const std::string& jobID)
|
||
{
|
||
m_serviceManagementService.updateJobStatus(jobID);
|
||
}
|
||
|
||
/*
|
||
Function: removeUser
|
||
Description: Removes a user by ID. Cancels associated service bookings
|
||
and technician jobs before removing the user from the system.
|
||
Parameter: const std::string& userID - ID of the user to remove
|
||
Return type: void
|
||
*/
|
||
void Controller::removeUser(const std::string& userID)
|
||
{
|
||
User* user = m_userManagementService.getUser(userID);
|
||
if (!user)
|
||
{
|
||
throw std::runtime_error("Error: User not Found.\n");
|
||
}
|
||
m_userManagementService.removeUser(userID);
|
||
}
|
||
|
||
/*
|
||
Function: createComboPackage
|
||
Description: Creates a new combo package with specified services and discount
|
||
percentage by delegating to the service management service.
|
||
Parameter: const std::string& name - name of the combo package
|
||
const util::Vector<std::string>& serviceIDs - list of service IDs
|
||
double discountPercentage - discount percentage for the package
|
||
Return type: void
|
||
*/
|
||
void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
|
||
{
|
||
m_serviceManagementService.createComboPackage(name, serviceIDs, discountPercentage);
|
||
}
|
||
|
||
/*
|
||
Function: removeComboPackage
|
||
Description: Removes a combo package by ID by delegating to the service
|
||
management service.
|
||
Parameter: const std::string& comboPackageID - ID of the combo package
|
||
Return type: void
|
||
*/
|
||
void Controller::removeComboPackage(const std::string& comboPackageID)
|
||
{
|
||
m_serviceManagementService.removeComboPackage(comboPackageID);
|
||
}
|
||
|
||
/*
|
||
Function: getInvoicesByUser
|
||
Description: Retrieves all invoices associated with the currently authenticated user.
|
||
Converts them into a read-only map before returning.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- util::Map<std::string, const Invoice*> containing the user’s invoices
|
||
*/
|
||
util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
|
||
{
|
||
User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
|
||
util::Map<std::string, Invoice*> currentUserInvoices = m_paymentManagementService.getInvoices(currentUser->getId());
|
||
util::Map<std::string, const Invoice*> userInvoicesReadOnly;
|
||
for (int iterator = 0; iterator < currentUserInvoices.getSize(); iterator++)
|
||
{
|
||
Invoice* currentInvoice = currentUserInvoices.getValueAt(iterator);
|
||
userInvoicesReadOnly.insert(currentInvoice->getId(), currentInvoice);
|
||
}
|
||
return userInvoicesReadOnly;
|
||
}
|
||
|
||
/*
|
||
Function: getAllInvoices
|
||
Description: Retrieves all invoices from the PaymentManagementService and returns them as a read-only map.
|
||
Parameters:
|
||
- none
|
||
Returns:
|
||
- util::Map<std::string, const Invoice*>: Map of invoice IDs to invoice objects
|
||
*/
|
||
util::Map<std::string, const Invoice*> Controller::getAllInvoices()
|
||
{
|
||
auto invoices = m_paymentManagementService.getAllInvoices();
|
||
util::Map<std::string, const Invoice*> readOnlyInvoice;
|
||
for (int iterator = 0; iterator < invoices.getSize(); iterator++)
|
||
{
|
||
readOnlyInvoice.insert(invoices.getKeyAt(iterator), invoices.getValueAt(iterator));
|
||
}
|
||
return readOnlyInvoice;
|
||
}
|
||
|
||
/*
|
||
Function: confirmPayment
|
||
Description: Delegates payment confirmation for a given invoice ID to the PaymentManagementService.
|
||
Parameters:
|
||
- invoiceID: std::string, ID of the invoice to confirm
|
||
Returns:
|
||
- void
|
||
*/
|
||
void Controller::confirmPayment(const std::string& invoiceID)
|
||
{
|
||
m_paymentManagementService.confirmPayment(invoiceID);
|
||
}
|
||
|
||
/*
|
||
Function: completePayment
|
||
Description: Completes payment for a specific invoice using the given payment mode.
|
||
Parameters:
|
||
- invoiceID: std::string, ID of the invoice to be paid
|
||
- paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
|
||
Returns:
|
||
- void
|
||
*/
|
||
void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
|
||
{
|
||
m_paymentManagementService.completePayment(invoiceID, paymentMode);
|
||
}
|
||
|
||
/*
|
||
Function: getNotifications
|
||
Description: Retrieves all notifications for the currently authenticated user.
|
||
Converts them into a read-only vector before returning.
|
||
Parameters: None
|
||
Return type: util::Vector<const Notification*>
|
||
*/
|
||
util::Vector<const Notification*> Controller::getNotifications()
|
||
{
|
||
const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
|
||
if (!authenticatedUser)
|
||
{
|
||
throw std::runtime_error("No user is currently logged in!");
|
||
}
|
||
auto notifications = m_userManagementService.getUserNotifications(authenticatedUser->getId());
|
||
int numberOfNotifications = notifications.getSize();
|
||
util::Vector<const Notification*> readOnlyNotifications;
|
||
for (int index = 0; index < numberOfNotifications; index++)
|
||
{
|
||
readOnlyNotifications.push_back(notifications[index]);
|
||
}
|
||
return readOnlyNotifications;
|
||
}
|
||
|
||
/*
|
||
Function: deleteNotification
|
||
Description: Deletes a specific notification for the currently authenticated user.
|
||
Parameters:
|
||
- notificationID: std::string, the unique identifier of the notification
|
||
Return type: void
|
||
*/
|
||
void Controller::deleteNotification(const std::string& notificationID)
|
||
{
|
||
const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
|
||
if (!authenticatedUser)
|
||
{
|
||
throw std::runtime_error("No user is currently logged in!");
|
||
}
|
||
m_userManagementService.deleteNotification(notificationID, authenticatedUser->getId());
|
||
}
|
||
|
||
/*
|
||
Function: configureNotifications
|
||
Description: Configures notification preferences for the authenticated user.
|
||
Attaches or detaches the user from payment and service notifications.
|
||
Parameters:
|
||
- paymentNotifications: bool, enable/disable payment notifications
|
||
- serviceNotifications: bool, enable/disable service notifications
|
||
Return type: void
|
||
*/
|
||
void Controller::configureNotifications(bool paymentNotifications, bool serviceNotifications)
|
||
{
|
||
User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
|
||
if (authenticatedUser)
|
||
{
|
||
if (paymentNotifications)
|
||
{
|
||
m_paymentManagementService.attach(authenticatedUser);
|
||
}
|
||
else
|
||
{
|
||
m_paymentManagementService.detach(authenticatedUser);
|
||
}
|
||
if (serviceNotifications)
|
||
{
|
||
m_serviceManagementService.attach(authenticatedUser);
|
||
}
|
||
else
|
||
{
|
||
m_serviceManagementService.detach(authenticatedUser);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
throw std::runtime_error("No user is currently logged in!");
|
||
}
|
||
}
|
||
|
||
/*
|
||
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
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void Controller::shutdown()
|
||
{
|
||
auto& dataStore = DataStore::getInstance();
|
||
dataStore.shutdown();
|
||
}
|
||
|
||
/*
|
||
Function: registerEvents
|
||
Description: Registers menu event handles with the authentication
|
||
service.
|
||
Parameter: HANDLE accountDisabledEvent - account disabled event handle
|
||
HANDLE notificationAvailableEvent - notification event handle
|
||
Return type: void
|
||
*/
|
||
void Controller::registerEvents(HANDLE accountDisabledEvent, HANDLE notificationAvailableEvent)
|
||
{
|
||
m_authenticationManagementService.registerEvents(accountDisabledEvent, notificationAvailableEvent);
|
||
}
|