784 lines
21 KiB
C++
784 lines
21 KiB
C++
/*
|
||
File: AdminMenu.cpp
|
||
Description: Implements the AdminMenu class which provides the administrator’s console interface
|
||
in the Vehicle Service Management System. Handles menu display, user input, and
|
||
admin-specific operations such as inventory management, technician management,
|
||
service creation, combo package management, job assignment, and notifications.
|
||
Author: Trenser
|
||
Date: 19-May-2026
|
||
*/
|
||
|
||
#include <iomanip>
|
||
#include <iostream>
|
||
#include "AdminMenu.h"
|
||
#include "Enums.h"
|
||
#include "InputHelper.h"
|
||
#include "InventoryItem.h"
|
||
#include "MenuHelper.h"
|
||
#include "OutputHelper.h"
|
||
#include "Service.h"
|
||
#include "ServiceBooking.h"
|
||
#include "User.h"
|
||
#include "Utility.h"
|
||
#include "Validator.h"
|
||
|
||
/*
|
||
Function: showMenu
|
||
Description: Displays the admin menu and handles user input until logout is selected.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::showMenu()
|
||
{
|
||
startEventListener();
|
||
while (true)
|
||
{
|
||
try
|
||
{
|
||
if (!m_isMenuActive)
|
||
{
|
||
logout();
|
||
break;
|
||
}
|
||
int choice;
|
||
util::clear();
|
||
std::cout << "Admin Menu"
|
||
<< "\n1. View Stock Levels"
|
||
<< "\n2. Add Inventory Item"
|
||
<< "\n3. Remove Inventory Item"
|
||
<< "\n4. Check Stock Availability"
|
||
<< "\n5. Assign Job to Technician"
|
||
<< "\n6. Display Users"
|
||
<< "\n7. Add Technician"
|
||
<< "\n8. Remove Customer/Technician"
|
||
<< "\n9. Display Services"
|
||
<< "\n10. Create Service"
|
||
<< "\n11. Remove Service"
|
||
<< "\n12. Display Combo Packages"
|
||
<< "\n13. Create Combo Package"
|
||
<< "\n14. Remove Combo Package"
|
||
<< "\n15. View Notifications"
|
||
<< "\n16. Change Password"
|
||
<< "\n17. Confirm Payment"
|
||
<< "\n18. Logout"
|
||
<< "\nEnter a choice: ";
|
||
util::read(choice);
|
||
if (!handleOperation(choice))
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
catch (const std::exception& e)
|
||
{
|
||
std::cout << "Exception: " << e.what() << std::endl;
|
||
util::pressEnter();
|
||
}
|
||
}
|
||
stopEventListener();
|
||
}
|
||
|
||
/*
|
||
Function: handleOperation
|
||
Description: Executes the corresponding admin operation based on the selected menu choice.
|
||
Parameter: int choice - selected menu option
|
||
Return type: bool - true if menu continues, false if logout
|
||
*/
|
||
bool AdminMenu::handleOperation(int choice)
|
||
{
|
||
if (!m_isMenuActive)
|
||
{
|
||
logout();
|
||
return false;
|
||
}
|
||
switch (choice)
|
||
{
|
||
case 1:
|
||
viewStockLevels();
|
||
break;
|
||
case 2:
|
||
addInventoryItem();
|
||
break;
|
||
case 3:
|
||
removeInventoryItem();
|
||
break;
|
||
case 4:
|
||
checkStockAvailability();
|
||
break;
|
||
case 5:
|
||
assignJob();
|
||
break;
|
||
case 6:
|
||
displayUsers();
|
||
break;
|
||
case 7:
|
||
addTechnician();
|
||
break;
|
||
case 8:
|
||
removeUser();
|
||
break;
|
||
case 9:
|
||
displayServices();
|
||
break;
|
||
case 10:
|
||
createService();
|
||
break;
|
||
case 11:
|
||
removeService();
|
||
break;
|
||
case 12:
|
||
displayComboPackages();
|
||
break;
|
||
case 13:
|
||
createComboPackages();
|
||
break;
|
||
case 14:
|
||
removeComboPackage();
|
||
break;
|
||
case 15:
|
||
viewNotifications();
|
||
break;
|
||
case 16:
|
||
changePassword();
|
||
break;
|
||
case 17:
|
||
confirmPayment();
|
||
break;
|
||
case 18:
|
||
logout();
|
||
return false;
|
||
default:
|
||
std::cout << "Enter a valid choice!" << std::endl;
|
||
util::pressEnter();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/*
|
||
Function: handleNotificationEvent
|
||
Description: Retrieves and displays the latest notification for the
|
||
currently logged in admin.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::handleNotificationEvent()
|
||
{
|
||
auto notifications = m_controller.getNotifications();
|
||
displayNewNotification(notifications);
|
||
}
|
||
|
||
/*
|
||
Function: logout
|
||
Description: Logs out the currently authenticated admin user.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::logout()
|
||
{
|
||
m_controller.logout();
|
||
}
|
||
|
||
/*
|
||
Function: changePassword
|
||
Description: Allows the admin to change their password after validation.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::changePassword()
|
||
{
|
||
changePasswordHelper(m_controller);
|
||
}
|
||
|
||
/*
|
||
Function: viewStockLevels
|
||
Description: Displays all active inventory items with their details
|
||
including ID, part name, quantity, and price.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::viewStockLevels()
|
||
{
|
||
util::clear();
|
||
auto inventoryItems = m_controller.getInventoryItems();
|
||
bool hasActiveItems = false;
|
||
std::cout << "View Stock Levels" << std::endl;
|
||
if (inventoryItems.isEmpty())
|
||
{
|
||
std::cout << "No items found in Inventory.\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
for (int index = 0; index < inventoryItems.getSize(); index++)
|
||
{
|
||
const InventoryItem* item = inventoryItems.getValueAt(index);
|
||
if (item->getState() == util::State::ACTIVE)
|
||
{
|
||
hasActiveItems = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!hasActiveItems)
|
||
{
|
||
std::cout << "No active Inventory Item found.\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::cout << std::left << std::setw(15) << "Item ID"
|
||
<< std::setw(25) << "Part Name"
|
||
<< std::setw(15) << "Quantity"
|
||
<< std::setw(15) << "Price"
|
||
<< std::endl;
|
||
for (int iterator = 0; iterator < inventoryItems.getSize(); ++iterator)
|
||
{
|
||
const InventoryItem* item = inventoryItems.getValueAt(iterator);
|
||
if (item != nullptr)
|
||
{
|
||
if (item->getState() != util::State::INACTIVE)
|
||
{
|
||
std::cout << std::left << std::setw(15) << item->getId()
|
||
<< std::setw(25) << item->getPartName()
|
||
<< std::setw(15) << item->getQuantity()
|
||
<< std::setw(15) << item->getPrice()
|
||
<< std::endl;
|
||
}
|
||
}
|
||
}
|
||
std::cout << "\n";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: addInventoryItem
|
||
Description: Allows the admin to either add a new inventory item
|
||
or increase the quantity of an existing item.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::addInventoryItem()
|
||
{
|
||
util::clear();
|
||
int choice, quantity;
|
||
double price;
|
||
std::string partName;
|
||
std::cout << "Add Inventory Item\n";
|
||
std::cout << "1. Add new item \n2. Restock Item\n\nEnter your choice : ";
|
||
util::read(choice);
|
||
switch (choice)
|
||
{
|
||
case 1:
|
||
{
|
||
util::clear();
|
||
std::cout << "Enter Item Details\n";
|
||
std::cout << "Part Name : ";
|
||
util::read(partName);
|
||
std::cout << "Quantity : ";
|
||
util::read(quantity);
|
||
std::cout << "Price : ";
|
||
util::read(price);
|
||
m_controller.addInventoryItem(partName, quantity, price);
|
||
std::cout << "\nNew Item " << partName << " added to the Inventory.\n\n";
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
util::clear();
|
||
std::cout << "Select Item to Restock\n";
|
||
auto inventoryItems = m_controller.getInventoryItems();
|
||
addQuantityToItem(inventoryItems, m_controller);
|
||
break;
|
||
}
|
||
default:
|
||
{
|
||
std::cout << "\nEnter a valid choice.\n\n";
|
||
}
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: removeInventoryItem
|
||
Description: Removes an active inventory item by marking it inactive
|
||
after user selection.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::removeInventoryItem()
|
||
{
|
||
util::clear();
|
||
std::cout << "Remove Inventory Item\n";
|
||
auto inventoryItems = m_controller.getInventoryItems();
|
||
auto activeItems = filterActiveItems(inventoryItems);
|
||
int activeItemsSize = activeItems.getSize();
|
||
if (activeItemsSize == 0)
|
||
{
|
||
std::cout << "No items available in Inventory." << std::endl;
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
displayInventoryWithItems(activeItems);
|
||
int itemIndex;
|
||
std::cout << "Enter the index of the item to remove: ";
|
||
util::read(itemIndex);
|
||
if (itemIndex < 1 || itemIndex > activeItemsSize)
|
||
{
|
||
std::cout << "Invalid index selected." << std::endl;
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
const InventoryItem* selectedItem = activeItems.getValueAt(itemIndex - 1);
|
||
if (selectedItem != nullptr)
|
||
{
|
||
if(selectedItem->getState() != util::State::INACTIVE)
|
||
{
|
||
std::string selectedItemId = selectedItem->getId();
|
||
m_controller.removeInventoryItem(selectedItemId);
|
||
std::cout << "Item " << selectedItem->getPartName() << " removed successfully." << std::endl;
|
||
}
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: checkStockAvailability
|
||
Description: Checks if a specific inventory item is available
|
||
and displays its details if active.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::checkStockAvailability()
|
||
{
|
||
util::clear();
|
||
std::string itemId;
|
||
std::cout << "Check Stock Availability \n";
|
||
std::cout << "Enter the Item ID : ";
|
||
util::read(itemId);
|
||
util::clear();
|
||
const InventoryItem* selectedItem = m_controller.getInventoryItem(itemId);
|
||
if (selectedItem != nullptr)
|
||
{
|
||
if (selectedItem->getState() != util::State::INACTIVE)
|
||
{
|
||
std::cout << "Item Details\n";
|
||
std::cout << "---------------------------------------------\n";
|
||
std::cout << "Item ID : " << selectedItem->getId() << "\n";
|
||
std::cout << "Part Name : " << selectedItem->getPartName() << "\n";
|
||
std::cout << "Quantity : " << selectedItem->getQuantity() << "\n";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::cout << "Item not Found" << std::endl;
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: assignJob
|
||
Description: Allows the admin to assign pending service bookings to available technicians.
|
||
Creates job cards for selected services.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void AdminMenu::assignJob()
|
||
{
|
||
util::clear();
|
||
std::cout << "Assign Job to Technician\n";
|
||
std::string selectedService;
|
||
bool hasPendingService = false;
|
||
auto currentBookings = m_controller.getServiceBookings();
|
||
auto pendingServiceBookings = filterActiveServiceBookings(currentBookings);
|
||
auto availableTechnicians = m_controller.getUsers(util::UserType::TECHNICIAN);
|
||
int bookingsSize = pendingServiceBookings.getSize();
|
||
util::Map<int, const ServiceBooking*> serviceBookingsMap;
|
||
util::Map<int, const User*> currentAvailableTechniciansMap;
|
||
if (listServiceBookings(pendingServiceBookings, bookingsSize, serviceBookingsMap))
|
||
{
|
||
const ServiceBooking* selectedService = selectPendingServiceBookings(serviceBookingsMap);
|
||
if (selectedService)
|
||
{
|
||
if (availableTechnicians.getSize() != 0)
|
||
{
|
||
listAvailableTechnicians(availableTechnicians, availableTechnicians.getSize(), currentAvailableTechniciansMap);
|
||
const User* selectedTechnician = selectTechnician(currentAvailableTechniciansMap);
|
||
if (selectedTechnician)
|
||
{
|
||
auto& servicesInBooking = selectedService->getServices();
|
||
for (int iterator = 0; iterator < servicesInBooking.getSize(); iterator++)
|
||
{
|
||
m_controller.createJobCard(selectedService->getId(), selectedTechnician->getId(), servicesInBooking.getValueAt(iterator)->getId());
|
||
}
|
||
std::cout << "Job card created for each service and technician successfully assigned.\n\n";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::cout << "No technicians are currently available.\n\n";
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::cout << "No pending service bookings available.\n\n";
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: displayServices()
|
||
Description: Display all active services
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void AdminMenu::displayServices()
|
||
{
|
||
util::clear();
|
||
std::cout << "List of all Services\n";
|
||
util::Map<std::string, const Service*> currentServices = m_controller.getServices();
|
||
util::Map<std::string, const Service*> currentActiveServices = filterActiveServices(currentServices);
|
||
displayAllServices(currentActiveServices);
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: createService
|
||
Description: Allows the admin to create a new service by selecting inventory items and specifying labor cost.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void AdminMenu::createService()
|
||
{
|
||
util::clear();
|
||
std::cout << "Create Service\n";
|
||
std::string serviceName;
|
||
double labourCost;
|
||
std::cout << "Enter the service name: ";
|
||
util::read(serviceName);
|
||
util::Map<std::string, const InventoryItem*> currentInventoryItems = m_controller.getInventoryItems();
|
||
util::Map<std::string, const InventoryItem*> activeInventoryItems = filterActiveItems(currentInventoryItems);
|
||
util::Vector<std::string> selectedInventoryItems;
|
||
selectInventoryItems(activeInventoryItems,selectedInventoryItems);
|
||
if (selectedInventoryItems.isEmpty())
|
||
{
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::cout << "\nEnter the labour cost: ";
|
||
util::read(labourCost);
|
||
m_controller.createService(serviceName, selectedInventoryItems, labourCost);
|
||
std::cout << "\nService created sucessfully.\n\n";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: removeService
|
||
Description: Allows the admin to remove an existing service by selecting from available services.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void AdminMenu::removeService()
|
||
{
|
||
util::clear();
|
||
std::cout << "Remove Service\n";
|
||
std::string selectedServiceID;
|
||
util::Map<std::string, const Service*> currentServices = m_controller.getServices();
|
||
util::Map<std::string, const Service*> currentActiveServices = filterActiveServices(currentServices);
|
||
selectedServiceID = selectServicesToRemove(currentActiveServices);
|
||
if (selectedServiceID != "")
|
||
{
|
||
m_controller.removeService(selectedServiceID);
|
||
std::cout << "Service removed successfully.\n\n";
|
||
}
|
||
else
|
||
{
|
||
std::cout << "Failed to remove service.\n\n";
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: displayUsers
|
||
Description: Displays all users.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::displayUsers()
|
||
{
|
||
util::clear();
|
||
auto listOfUsers = m_controller.getUsers();
|
||
auto listOfActiveUsers = filterActiveUsers(listOfUsers);
|
||
int activeUserCount = listOfActiveUsers.getSize();
|
||
std::cout << "List of all Users\n";
|
||
if (activeUserCount < 1)
|
||
{
|
||
std::cout << "No Active users." << std::endl;
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
displayAllUsers(listOfActiveUsers);
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: confirmPayment
|
||
Description: Confirms payment for a selected invoice. Validates invoice status, updates payment date,
|
||
sets status to COMPLETED, and sends a notification to the customer.
|
||
Parameters:
|
||
- invoiceID: std::string, ID of the invoice to confirm
|
||
Returns:
|
||
- void
|
||
*/
|
||
void AdminMenu::confirmPayment()
|
||
{
|
||
util::clear();
|
||
std::cout << "Confirm Payment\n";
|
||
auto invoiceList = m_controller.getAllInvoices();
|
||
if (invoiceList.isEmpty())
|
||
{
|
||
std::cout << "No pending invoices available for confirmation.";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
bool hasConfirmableInvoice = false;
|
||
for (int index = 0; index < invoiceList.getSize(); ++index)
|
||
{
|
||
const Invoice* invoice = invoiceList.getValueAt(index);
|
||
if (invoice && invoice->getStatus() == util::PaymentStatus::PAID)
|
||
{
|
||
hasConfirmableInvoice = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!hasConfirmableInvoice)
|
||
{
|
||
std::cout << "No invoices awaiting confirmation.\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::string selectedID = selectInvoiceFromUserForPayment(invoiceList, util::PaymentStatus::PAID);
|
||
if (selectedID == "")
|
||
{
|
||
std::cout << "Payment failed.\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
m_controller.confirmPayment(selectedID);
|
||
std::cout << "Payment Confirmed successfully.\n";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: addTechnician
|
||
Description: Adds a new technician after validating username, password, email, and phone number.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::addTechnician()
|
||
{
|
||
util::clear();
|
||
std::string username, name, password, email, phoneNumber;
|
||
std::cout << "Add Technician\n";
|
||
std::cout << "Enter Technician Username: ";
|
||
util::read(username);
|
||
std::cout << "Enter Technician Name: ";
|
||
util::read(name);
|
||
std::cout << "Enter Technician Password: ";
|
||
util::read(password);
|
||
if(!util::isPasswordValid(password))
|
||
{
|
||
std::cout << "\nError: Password is invalid!\n\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::cout << "Enter Technician Email: ";
|
||
util::read(email);
|
||
if(!util::isEmailValid(email))
|
||
{
|
||
std::cout << "\nError: Email is invalid!\n\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
std::cout << "Enter Technician Phone: ";
|
||
util::read(phoneNumber);
|
||
if(!util::isPhoneNumberValid(phoneNumber))
|
||
{
|
||
std::cout << "\nError: Phone Number is invalid!\n\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
m_controller.createTechnician(username, name, password, email, phoneNumber);
|
||
std::cout << "\nTechnician Added Successfully.\n\n";
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: removeUser
|
||
Description: Removes a selected active user (customer or technician) from the system.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::removeUser()
|
||
{
|
||
util::clear();
|
||
int indexChoice;
|
||
auto listOfUsers = m_controller.getUsers();
|
||
auto listOfActiveUsers = filterActiveUsers(listOfUsers);
|
||
int activeUserCount = listOfActiveUsers.getSize();
|
||
std::cout << "Remove User \n";
|
||
if (activeUserCount < 1)
|
||
{
|
||
std::cout << "No Active users." << std::endl;
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
displayAllUsers(listOfActiveUsers);
|
||
std::cout << "Enter the index of the user to delete : ";
|
||
util::read(indexChoice);
|
||
if (indexChoice < 1 || indexChoice > activeUserCount)
|
||
{
|
||
std::cout << "Error invalid index.\n" << std::endl;
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
const User* userToRemove = listOfActiveUsers.getValueAt(indexChoice - 1);
|
||
if (userToRemove != nullptr)
|
||
{
|
||
std::string userIdToRemove = userToRemove->getId();
|
||
m_controller.removeUser(userIdToRemove);
|
||
std::cout << userToRemove->getUserName() << " removed Successfully.\n";
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: displayComboPackages()
|
||
Description: Display all active combo packages
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void AdminMenu::displayComboPackages()
|
||
{
|
||
util::clear();
|
||
std::cout << "List of all Combo Packages\n";
|
||
util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
|
||
util::Map<std::string, const ComboPackage*> currentActiveComboPackages = filterComboPackages(currentComboPackages);
|
||
displayAllComboPackages(currentActiveComboPackages);
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: createComboPackages
|
||
Description: Creates a new combo package by selecting two active services and applying a discount.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::createComboPackages()
|
||
{
|
||
util::clear();
|
||
std::cout << "Create Combo Packages\n";
|
||
auto serviceList = m_controller.getServices();
|
||
auto activeServices = filterActiveServices(serviceList);
|
||
int currentActiveServicesCount = activeServices.getSize();
|
||
const int NUMBER_OF_SERVICE_PER_PACKAGE = 2;
|
||
util::Vector<std::string> selectedServiceID;
|
||
for (int iterator = 0; iterator < NUMBER_OF_SERVICE_PER_PACKAGE; iterator++)
|
||
{
|
||
const Service* chosenService = nullptr;
|
||
while (true)
|
||
{
|
||
chosenService = selectServiceFromServices(activeServices);
|
||
if (!chosenService)
|
||
{
|
||
std::cout << "Failed to create combo package!\n\n";
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
bool alreadyChosen = false;
|
||
for (int iteratorOne = 0; iteratorOne < selectedServiceID.getSize(); iteratorOne++)
|
||
{
|
||
if (selectedServiceID[iteratorOne] == chosenService->getId())
|
||
{
|
||
alreadyChosen = true;
|
||
break;
|
||
}
|
||
}
|
||
if (alreadyChosen)
|
||
{
|
||
if (currentActiveServicesCount < 2)
|
||
{
|
||
break;
|
||
}
|
||
std::cout << "Service already selected. Please choose a different one." << std::endl;
|
||
continue;
|
||
}
|
||
selectedServiceID.push_back(chosenService->getId());
|
||
break;
|
||
}
|
||
if (currentActiveServicesCount < 2)
|
||
{
|
||
std::cout << "All the available services selected\n\n";
|
||
break;
|
||
}
|
||
}
|
||
std::string packageName;
|
||
double discountPercentage;
|
||
std::cout << "Enter combo package name: ";
|
||
util::read(packageName);
|
||
std::cout << "Enter discount percentage: ";
|
||
util::read(discountPercentage);
|
||
if (discountPercentage < 0.0 || discountPercentage > 100.0)
|
||
{
|
||
std::cout << "Error: Discount percentage must be between 0 and 100." << std::endl;
|
||
util::pressEnter();
|
||
return;
|
||
}
|
||
m_controller.createComboPackage(packageName, selectedServiceID, discountPercentage);
|
||
std::cout << "Combo package '" << packageName << "' created successfully." << std::endl;
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: removeComboPackage
|
||
Description: Removes a selected combo package from the system.
|
||
Parameter: None
|
||
Return type: void
|
||
*/
|
||
void AdminMenu::removeComboPackage()
|
||
{
|
||
util::clear();
|
||
std::cout << "Remove Combo Package\n";
|
||
util::Map<std::string, const ComboPackage*> currentComboPackages = m_controller.getComboPackages();
|
||
std::string selectedComboPackageID = selectComboPackage(currentComboPackages);
|
||
if (!selectedComboPackageID.empty())
|
||
{
|
||
m_controller.removeComboPackage(selectedComboPackageID);
|
||
std::cout << "Combo Package removed successfully.\n\n";
|
||
}
|
||
else
|
||
{
|
||
std::cout << "Combo package removal failed.\n\n";
|
||
}
|
||
util::pressEnter();
|
||
}
|
||
|
||
/*
|
||
Function: viewNotifications
|
||
Description: Displays notifications for the admin and allows deletion of notifications.
|
||
Parameters:
|
||
- None
|
||
Returns:
|
||
- void
|
||
*/
|
||
void AdminMenu::viewNotifications()
|
||
{
|
||
viewAndDeleteNotification(m_controller);
|
||
}
|