diff --git a/.gitignore b/.gitignore index 47a94ef..fe37065 100644 --- a/.gitignore +++ b/.gitignore @@ -426,3 +426,6 @@ FodyWeavers.xsd *.msix *.msm *.msp + +# CSV Files +*.csv diff --git a/Trenser.FileManager/Trenser.FileManager/FileIO.cpp b/Trenser.FileManager/Trenser.FileManager/FileIO.cpp new file mode 100644 index 0000000..8697eb3 --- /dev/null +++ b/Trenser.FileManager/Trenser.FileManager/FileIO.cpp @@ -0,0 +1,27 @@ +#include "pch.h" +#include "FileIO.h" + +std::vector FileIO::readAllLines(const std::string& path) +{ + std::ifstream file(path); + if (!file.is_open()) + { + std::ofstream newFile(path); + newFile.close(); + file.open(path); + } std::vector lines; + std::string line; + while (std::getline(file, line)) + lines.push_back(line); + return lines; +} + +void FileIO::writeAllLines(const std::string& path, + const std::vector& lines) +{ + std::ofstream file(path, std::ios::trunc); + if (!file.is_open()) + throw std::runtime_error("Failed to open file " + path); + for (const auto& line : lines) + file << line << '\n'; +} diff --git a/Trenser.FileManager/Trenser.FileManager/FileIO.h b/Trenser.FileManager/Trenser.FileManager/FileIO.h new file mode 100644 index 0000000..c628003 --- /dev/null +++ b/Trenser.FileManager/Trenser.FileManager/FileIO.h @@ -0,0 +1,18 @@ +#pragma once +#include +#include +#include +#include +#include + +#ifdef TRENSERFILEMANAGER_EXPORTS +#define TRENSERFILEMANAGER_API __declspec(dllexport) +#else +#define TRENSERFILEMANAGER_API __declspec(dllimport) +#endif + +class TRENSERFILEMANAGER_API FileIO { +public: + static std::vector readAllLines(const std::string& path); + static void writeAllLines(const std::string& path, const std::vector& lines); +}; diff --git a/Trenser.FileManager/Trenser.FileManager/FileManager.h b/Trenser.FileManager/Trenser.FileManager/FileManager.h new file mode 100644 index 0000000..198934d --- /dev/null +++ b/Trenser.FileManager/Trenser.FileManager/FileManager.h @@ -0,0 +1,52 @@ +#pragma once +#include +#include "FileIO.h" + +template using objects = std::map; + +template +class FileManager +{ +private: + std::string m_filePath; +public: + FileManager() : m_filePath("") {} + FileManager(const std::string& filePath) : m_filePath(filePath) {} + objects load(); + void save(const objects&); +}; + +template +objects FileManager::load() +{ + objects records; + auto lines = FileIO::readAllLines(m_filePath); + bool isHeader = true; + for (const auto& record : lines) + { + if (isHeader) + { + isHeader = false; + continue; + } + auto object = T::deserialize(record); + if (!object) + { + throw std::runtime_error("Failed to deserialize record"); + } + records[object->getId()] = object; + } + return records; +} + +template +void FileManager::save(const objects& records) +{ + std::vector lines; + lines.push_back(T::getHeaders()); + for (const auto& recordPair : records) + { + lines.push_back(recordPair.second->serialize()); + } + FileIO::writeAllLines(m_filePath, lines); +} diff --git a/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj b/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj index c7c45c3..7511f8e 100644 --- a/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj +++ b/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj @@ -135,11 +135,14 @@ + + + Create Create diff --git a/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj.filters b/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj.filters index 1e57c7b..8faaab1 100644 --- a/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj.filters +++ b/Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj.filters @@ -21,6 +21,12 @@ Header Files + + Header Files + + + Header Files + @@ -29,5 +35,8 @@ Source Files + + Source Files + \ No newline at end of file diff --git a/Trenser.FileManager/Trenser.FileManager/pch.h b/Trenser.FileManager/Trenser.FileManager/pch.h index 885d5d6..a4ee448 100644 --- a/Trenser.FileManager/Trenser.FileManager/pch.h +++ b/Trenser.FileManager/Trenser.FileManager/pch.h @@ -9,5 +9,10 @@ // add headers that you want to pre-compile here #include "framework.h" +#include +#include +#include +#include +#include #endif //PCH_H diff --git a/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.cpp b/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.cpp index 64b1e4b..f21d31b 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.cpp @@ -6,7 +6,7 @@ */ #include "UserInterface.h" - +#include "FileManager.h" int main() { UserInterface userInterFace; diff --git a/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj b/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj index 4424458..f3f2e5f 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj +++ b/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj @@ -102,12 +102,17 @@ true _DEBUG;_CONSOLE;%(PreprocessorDefinitions) true - $(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)factories;$(ProjectDir)datastores;$(ProjectDir)views;%(AdditionalIncludeDirectories) + $(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)factories;$(ProjectDir)datastores;$(ProjectDir)views;%(AdditionalIncludeDirectories);..\..\Trenser.FileManager\Trenser.FileManager Console true + ..\..\Trenser.FileManager\$(IntDir);%(AdditionalLibraryDirectories) + Trenser.FileManager.lib;%(AdditionalDependencies) + + xcopy /y /d "..\..\Trenser.FileManager\$(IntDir)Trenser.FileManager.dll" "$(OutDir)" + @@ -117,11 +122,17 @@ true NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true + ;..\..\Trenser.FileManager\Trenser.FileManager Console true + ..\..\Trenser.FileManager\$(IntDir);%(AdditionalLibraryDirectories) + Trenser.FileManager.lib;%(AdditionalDependencies) + + xcopy /y /d "..\..\Trenser.FileManager\$(IntDir)Trenser.FileManager.dll" "$(OutDir)" + @@ -150,7 +161,7 @@ - + @@ -162,9 +173,11 @@ + + @@ -172,6 +185,7 @@ + @@ -204,7 +218,7 @@ - + @@ -212,9 +226,11 @@ + + @@ -222,6 +238,7 @@ + diff --git a/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj.filters b/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj.filters index 8a20aa6..1c6dff6 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj.filters +++ b/Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj.filters @@ -39,9 +39,6 @@ Services - - Services - Services @@ -192,14 +189,23 @@ Services + + Services + + + Views + + + Services + + + Utilities + Services - - Services - Services @@ -338,6 +344,18 @@ Services + + Services + + + Views + + + Services + + + Utilities + diff --git a/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.cpp b/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.cpp index cdc3a08..26e3df4 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.cpp @@ -4,7 +4,6 @@ * Author: Trenser * Created : 01-Apr-2026 */ - #include "ZenvyController.h" /* @@ -15,54 +14,232 @@ * password - password of the employee * Returns: * Tuple - login status, employee type, employee designation - * login status - success or failed + * login status - success or failed * employee type - type of the employee logged in * employee designation - designation if employee type is GENERAL. */ - AuthenticationDTO ZenvyController::login(const std::string& email, const std::string& password) { - return m_authenticationManagementService->login(email, password); + return m_authenticationManagementService->login(email, password); } /* - * Function: changePassword - * Description: updates the password of the currently authenticated employee. + * Function: logout + * Description: logs out the currently authenticated employee * Parameters: - * password - the new password to be set for the employee + * None * Returns: * void - no return value */ - void ZenvyController::logout() { - m_authenticationManagementService->logout(); + m_authenticationManagementService->logout(); } /* * Function: changePassword - * Description: updates the password of the currently authenticated employee. + * Description: updates the password of the currently authenticated employee * Parameters: * password - the new password to be set for the employee * Returns: * void - no return value */ - void ZenvyController::changePassword(const std::string& password) { - m_authenticationManagementService->changePassword(password); + m_authenticationManagementService->changePassword(password); } +/* + * Function: createEmployee + * Description: creates a new employee with the given details + * Parameters: + * employeeType - type of employee to be created + * employeeDesignation - designation of the employee + * email - email address of the employee + * name - name of the employee + * phone - phone number of the employee + * Returns: + * void - no return value + */ +void ZenvyController::createEmployee(Enums::EmployeeType employeeType, Enums::EmployeeDesignation employeeDesignation, const std::string& email, const std::string& name, const std::string& phone) const +{ + m_employeeManagementService->createEmployee(employeeType, employeeDesignation, email, name, phone); +} + +/* + * Function: deactivateEmployee + * Description: deactivates an employee based on employee ID + * Parameters: + * id - unique employee ID + * Returns: + * bool - true if deactivated successfully, false otherwise + */ +bool ZenvyController::deactivateEmployee(const std::string& id) const +{ + return m_employeeManagementService->deactivateEmployee(id); +} + +/* + * Function: updateProfile + * Description: updates the profile of the currently authenticated employee + * Parameters: + * name - updated name of the employee + * phone - updated phone number + * Returns: + * void - no return value + */ +void ZenvyController::updateProfile(const std::string& name, const std::string& phone) +{ + m_employeeManagementService->updateProfile(name, phone); +} + +/* + * Function: searchEmployee + * Description: searches employees based on name + * Parameters: + * name - name or partial name of the employee + * Returns: + * Pair of employee type and list of matching employees + */ +std::pair> ZenvyController::searchEmployee(const std::string& name) +{ + return m_employeeManagementService->searchEmployee(name); +} + +/* + * Function: getCurrentEmployee + * Description: retrieves the currently authenticated employee + * Parameters: + * None + * Returns: + * Pointer to the authenticated employee + */ +const Employee* ZenvyController::getCurrentEmployee() const +{ + return m_employeeManagementService->getCurrentEmployee(); +} + +/* + * Function: updateDesignation + * Description: updates the designation of an employee + * Parameters: + * id - unique employee ID + * designation - new designation to be assigned + * Returns: + * bool - true if update is successful, false otherwise + */ +bool ZenvyController::updateDesignation(const std::string& id, Enums::EmployeeDesignation designation) +{ + return m_employeeManagementService->updateDesignation(id, designation); +} + +/* + * Function: getShorlistedCandidates + * Description: retrieves the list of shortlisted candidates + * Parameters: + * None + * Returns: + * Vector of shortlisted candidate pointers + */ +std::vector ZenvyController::getShorlistedCandidates() const +{ + return m_employeeManagementService->getShorlistedCandidates(); +} + +/* + * Function: updateSalary + * Description: updates salary details of an employee + * Parameters: + * employeeId - unique employee ID + * basicSalary - basic salary amount + * houseRentAllowance - HRA amount + * foodAllowance - food allowance amount + * employeePFContribution - employee PF contribution + * employerPFContribution - employer PF contribution + * Returns: + * void - no return value + */ +void ZenvyController::updateSalary(const std::string& employeeId, double basicSalary, double houseRentAllowance, double foodAllowance, double employeePFContribution, double employerPFContribution) +{ + m_payslipManagementService->updateSalary(employeeId, basicSalary, houseRentAllowance, foodAllowance, employeePFContribution, employerPFContribution); +} + +/* + * Function: generatePayslips + * Description: generates payslips for all eligible employees + * Parameters: + * None + * Returns: + * void - no return value + */ +void ZenvyController::generatePayslips() +{ + m_payslipManagementService->generatePayslips(); +} + +/* + * Function: loadStates + * Description: loads persisted application data into memory + * Parameters: + * None + * Returns: + * void - no return value + */ +void ZenvyController::loadStates() +{ + m_employeeManagementService->loadEmployees(); + m_payslipManagementService->loadPayrolls(); + m_payslipManagementService->loadPayslips(); +} + +/* + * Function: persistStates + * Description: saves current application data to storage + * Parameters: + * None + * Returns: + * void - no return value + */ +void ZenvyController::persistStates() +{ + m_employeeManagementService->saveEmployees(); + m_payslipManagementService->savePayrolls(); + m_payslipManagementService->savePayslips(); +} + +/* + * Function: getPayslipForMonth + * Description: retrieves payroll and payslip details for a specific month + * Parameters: + * employeeId - unique employee ID + * year - year of the payslip + * month - month of the payslip + * Returns: + * Pair of payroll and payslip pointers + */ +std::pair ZenvyController::getPayslipForMonth(const std::string& employeeId, int year, int month) +{ + return m_payslipManagementService->getPayslipForMonth(employeeId, year, month); +} + +/* + * Function: ~ZenvyController + * Description: cleans up dynamically allocated service objects + * Parameters: + * None + * Returns: + * void - no return value + */ ZenvyController::~ZenvyController() { delete m_authenticationManagementService; delete m_attendanceManagementService; delete m_bookingManagementService; - delete m_employeeManagememtService; + delete m_employeeManagementService; delete m_leaveManagementService; delete m_notificationManagementService; delete m_payslipManagementService; delete m_talentAcquisitionManagementService; delete m_teamManagementService; delete m_ticketManagementService; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.h b/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.h index 965a5d1..3f503d4 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.h +++ b/Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.h @@ -10,7 +10,7 @@ #include "AuthenticationManagementService.h" #include "AttendanceManagementService.h" #include "BookingManagementService.h" -#include "EmployeeManagememtService.h" +#include "EmployeeManagementService.h" #include "LeaveManagementService.h" #include "NotificationManagementService.h" #include "PayslipManagementService.h" @@ -22,30 +22,56 @@ class ZenvyController { private: - AuthenticationManagementService* m_authenticationManagementService; - AttendanceManagementService* m_attendanceManagementService; - BookingManagementService* m_bookingManagementService; - EmployeeManagememtService* m_employeeManagememtService; - LeaveManagementService* m_leaveManagementService; - NotificationManagementService* m_notificationManagementService; - PayslipManagementService* m_payslipManagementService; - TalentAcquisitionManagementService* m_talentAcquisitionManagementService; - TeamManagementService* m_teamManagementService; - TicketManagementService* m_ticketManagementService; + AuthenticationManagementService* m_authenticationManagementService; + AttendanceManagementService* m_attendanceManagementService; + BookingManagementService* m_bookingManagementService; + EmployeeManagementService* m_employeeManagementService; + LeaveManagementService* m_leaveManagementService; + NotificationManagementService* m_notificationManagementService; + PayslipManagementService* m_payslipManagementService; + TalentAcquisitionManagementService* m_talentAcquisitionManagementService; + TeamManagementService* m_teamManagementService; + TicketManagementService* m_ticketManagementService; public: - ZenvyController() : - m_authenticationManagementService(new AuthenticationManagementService()), - m_attendanceManagementService(new AttendanceManagementService()), - m_bookingManagementService(new BookingManagementService()), - m_employeeManagememtService(new EmployeeManagememtService()), - m_leaveManagementService(new LeaveManagementService()), - m_notificationManagementService(new NotificationManagementService()), - m_payslipManagementService(new PayslipManagementService()), - m_talentAcquisitionManagementService(new TalentAcquisitionManagementService()), - m_teamManagementService(new TeamManagementService()), - m_ticketManagementService(new TicketManagementService()) {}; - AuthenticationDTO login(const std::string& email, const std::string& password); - void logout(); - void changePassword(const std::string&); - ~ZenvyController(); + ZenvyController() : + m_authenticationManagementService(new AuthenticationManagementService()), + m_attendanceManagementService(new AttendanceManagementService()), + m_bookingManagementService(new BookingManagementService()), + m_employeeManagementService(new EmployeeManagementService()), + m_leaveManagementService(new LeaveManagementService()), + m_notificationManagementService(new NotificationManagementService()), + m_payslipManagementService(new PayslipManagementService()), + m_talentAcquisitionManagementService(new TalentAcquisitionManagementService()), + m_teamManagementService(new TeamManagementService()), + m_ticketManagementService(new TicketManagementService()) {}; + ~ZenvyController(); + + //Authentication + AuthenticationDTO login(const std::string& email, const std::string& password); + void logout(); + void changePassword(const std::string&); + + //Employee Management + void createEmployee(Enums::EmployeeType, Enums::EmployeeDesignation, const std::string&, const std::string&, const std::string&) const; + bool deactivateEmployee(const std::string&) const; + const Employee* getCurrentEmployee() const; + void updateProfile(const std::string&, const std::string&); + std::pair> searchEmployee(const std::string&); + bool updateDesignation(const std::string&, Enums::EmployeeDesignation); + std::vector getShorlistedCandidates() const; + + template + Employees getEmployees(Types ...types) const + { + return m_employeeManagementService->getEmployees(types...); + } + + //Payslip management + void updateSalary(const std::string&, double, double, double, double, double); + void generatePayslips(); + std::pairgetPayslipForMonth(const std::string&, int, int); + + //File Management + void loadStates(); + void persistStates(); }; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.cpp b/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.cpp index 75e9f43..fa5610d 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.cpp @@ -6,20 +6,20 @@ */ #include "DataStore.h" +#include "EmployeeManagementService.h" -/* - * Function: getInstance - * Description: provides a singleton instance of the DataStore. - * Parameters: - * None - * Returns: - * DataStore& - reference to the single DataStore object. - */ - + /* + * Function: getInstance + * Description: provides a singleton instance of the DataStore. + * Parameters: + * None + * Returns: + * DataStore& - reference to the single DataStore object. + */ DataStore& DataStore::getInstance() { - static DataStore dataStore; - return dataStore; + static DataStore dataStore; + return dataStore; } /* @@ -30,67 +30,97 @@ DataStore& DataStore::getInstance() * Returns: * logMap& - reference to the log map. */ - logMap& DataStore::getLogs() { - return m_logs; + return m_logs; } /* * Function: getAuthenticatedEmployee - * Description: returns the currently authenticated employee. + * Description: retrieves the currently authenticated employee. * Parameters: * None * Returns: - * std::shared_ptr& - reference to the authenticated employee object. + * Employee*& - reference to the authenticated employee pointer. */ - Employee*& DataStore::getAuthenticatedEmployee() { - return m_authenticatedEmployee; + return m_authenticatedEmployee; } /* * Function: setAuthenticatedEmployee * Description: sets the currently authenticated employee. * Parameters: - * authenticatedEmployee - shared pointer to the employee object to be set as authenticated. + * authenticatedEmployee - pointer to the employee to be set as authenticated. * Returns: * void - no return value. */ - void DataStore::setAuthenticatedEmployee(Employee* authenticatedEmployee) { - m_authenticatedEmployee = authenticatedEmployee; + m_authenticatedEmployee = authenticatedEmployee; } /* * Function: getEmployees - * Description: retrieves the employee map containing all employees. + * Description: retrieves the map containing all employees. * Parameters: * None * Returns: * employeeMap& - reference to the employee map. */ - employeeMap& DataStore::getEmployees() { - return m_employees; + return m_employees; } /* - * Function: getAuthenticatedUser - * Description: alias for getAuthenticatedEmployee, returns the currently authenticated employee. + * Function: getPayrolls + * Description: retrieves the map containing all payroll records. * Parameters: * None * Returns: - * std::shared_ptr& - reference to the authenticated employee object. + * payrollMap& - reference to the payroll map. */ - -Employee* DataStore::getAuthenticatedUser() +payrollMap& DataStore::getPayrolls() { - return m_authenticatedEmployee; + return m_payrolls; } + +/* + * Function: getPayslips + * Description: retrieves the map containing all payslip records. + * Parameters: + * None + * Returns: + * payslipMap& - reference to the payslip map. + */ +payslipMap& DataStore::getPayslips() +{ + return m_payslips; +} + +/* + * Function: getCandidates + * Description: retrieves the map containing all shortlisted candidates. + * Parameters: + * None + * Returns: + * candidateMap& - reference to the candidate map. + */ +candidateMap& DataStore::getCandidates() +{ + return m_candidates; +} + +/* + * Function: ~DataStore + * Description: releases all dynamically allocated objects stored in the DataStore. + * Parameters: + * None + * Returns: + * void - no return value. + */ DataStore::~DataStore() { for (auto& pair : m_employees) @@ -98,15 +128,25 @@ DataStore::~DataStore() delete pair.second; } m_employees.clear(); + for (auto& pair : m_payrolls) + { + delete pair.second; + } + m_payrolls.clear(); + for (auto& pair : m_payslips) + { + delete pair.second; + } + m_payslips.clear(); for (auto& pair : m_logs) { delete pair.second; } m_logs.clear(); - if (m_authenticatedEmployee) + for (auto& pair : m_candidates) { - delete m_authenticatedEmployee; - m_authenticatedEmployee = nullptr; + delete pair.second; } -} - + m_candidates.clear(); + m_authenticatedEmployee = nullptr; +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.h b/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.h index 6cd9518..3fe7ed6 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.h +++ b/Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.h @@ -24,16 +24,24 @@ #include "Notification.h" #include "Announcement.h" #include "Faq.h" +#include "Payroll.h" +#include "Payslip.h" -using employeeMap = std::map; +using employeeMap = std::map; +using payrollMap = std::map; +using payslipMap = std::map; using logMap = std::map; +using candidateMap = std::map; class DataStore { private: Employee* m_authenticatedEmployee; employeeMap m_employees; + payrollMap m_payrolls; + payslipMap m_payslips; logMap m_logs; + candidateMap m_candidates; DataStore() : m_authenticatedEmployee(nullptr) {}; public: static DataStore& getInstance(); @@ -41,9 +49,11 @@ public: DataStore& operator=(const DataStore&) = delete; DataStore(DataStore&&) = delete; DataStore& operator=(DataStore&&) = delete; - employeeMap& getEmployees(); - Employee* getAuthenticatedUser(); + employeeMap& getEmployees(); + payrollMap& getPayrolls(); + payslipMap& getPayslips(); logMap& getLogs(); + candidateMap& getCandidates(); Employee*& getAuthenticatedEmployee(); void setAuthenticatedEmployee(Employee*); ~DataStore(); diff --git a/Trenser.Zenvy/Trenser.Zenvy/factories/Factory.h b/Trenser.Zenvy/Trenser.Zenvy/factories/Factory.h index 216a823..40eaf40 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/factories/Factory.h +++ b/Trenser.Zenvy/Trenser.Zenvy/factories/Factory.h @@ -1,7 +1,7 @@ /* * File: Factory.h - * Description: Provides a generic factory utility to create shared_ptr instances of objects. - * Author: Ajmal J S + * Description: Provides a generic factory utility to create objects. + * Author: Trenser * Created: 01-Apr-2026 */ @@ -13,18 +13,17 @@ class Factory public: /* - * Function: getObject - * Description: Creates and returns a shared_ptr to an object of type T. - * Parameters: - * T - the type of object to be created - * Args - constructor arguments forwarded to T's constructor - * Returns: - * std::shared_ptr - a shared pointer managing the newly created object - */ - - template - static T* getObject(Args&&... args) - { - return T*(std::forward(args)...); - } -}; + * Function: getObject + * Description: Creates and returns a dynamically allocated object of type T. + * Parameters: + * T - the type of object to be created + * Args - constructor arguments forwarded to T's constructor + * Returns: + * T* - pointer to the newly created object + */ + template + static T* getObject(Args&&... args) + { + return new T(std::forward(args)...); + } +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Admin.h b/Trenser.Zenvy/Trenser.Zenvy/models/Admin.h index f507ccc..fdd5daa 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Admin.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Admin.h @@ -4,10 +4,35 @@ * Author: Trenser * Created: 31-Mar-2026 */ - #pragma once #include "Employee.h" class Admin : public Employee { -}; +public: + Admin() = default; + Admin( + const std::string& name, + const std::string& phone, + const std::string& email, + Payroll* payroll + ) :Employee(name, phone, email, Enums::EmployeeType::ADMIN, payroll) {}; + Admin(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::AccountStatus accountStatus) + : Employee(id, + name, + phone, + password, + email, + teamId, + teamStatus, + Enums::EmployeeType::ADMIN, + accountStatus) {} + ~Admin() = default; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.cpp index 8cdada4..ed34094 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.cpp @@ -6,7 +6,8 @@ */ #include "Announcement.h" -//Getters and Setters +int Announcement::m_uid = 0; + const std::string& Announcement::getAnnouncementId() const { return m_id; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.h b/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.h index 3006d0f..ed70c16 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Announcement.h @@ -11,14 +11,14 @@ class Announcement { private: + static int m_uid; std::string m_id; util::Timestamp m_timestamp; std::string m_message; public: - Announcement() : m_id(""), m_timestamp(), m_message("") {} - Announcement(const std::string& id, - const std::string& message) - : m_id(id), m_message(message) {} + Announcement() : m_id("AN" + std::to_string(++m_uid)), m_timestamp(), m_message("") {} + Announcement(const std::string& message) + : m_id("AN" + std::to_string(++m_uid)), m_message(message) {} const std::string& getAnnouncementId() const; const util::Timestamp& getAnnouncementTimestamp() const; const std::string& getAnnouncementMessage() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.cpp index 399fccd..46a12bc 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.cpp @@ -6,7 +6,8 @@ */ #include "Attendance.h" - //Getters and Setters +int Attendance::m_uid = 0; + const std::string& Attendance::getAttendanceId() const { return m_id; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.h b/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.h index 89f4ed3..0e43f92 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Attendance.h @@ -11,15 +11,15 @@ class Attendance { private: + static int m_uid; std::string m_id; util::Timestamp m_loginTime; util::Timestamp m_logoutTime; public: - Attendance() : m_id(""), m_loginTime(), m_logoutTime() {} - Attendance(const std::string& id, - const util::Timestamp& loginTime, + Attendance() : m_id("AD" + std::to_string(++m_uid)), m_loginTime(), m_logoutTime() {} + Attendance(const util::Timestamp& loginTime, const util::Timestamp& logoutTime) - : m_id(id), m_loginTime(loginTime), m_logoutTime(logoutTime) {} + : m_id("AD" + std::to_string(++m_uid)), m_loginTime(loginTime), m_logoutTime(logoutTime) {} const std::string& getAttendanceId() const; const util::Timestamp& getLoginTime() const; const util::Timestamp& getLogoutTime() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Booking.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Booking.cpp index a069f96..e2c7861 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Booking.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Booking.cpp @@ -6,7 +6,8 @@ */ #include "Booking.h" - //Getters and Setters +int Booking::m_uid = 0; + const std::string& Booking::getBookingId() const { return m_id; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Booking.h b/Trenser.Zenvy/Trenser.Zenvy/models/Booking.h index d99a5f3..db7dc26 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Booking.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Booking.h @@ -12,18 +12,19 @@ class Booking { private: + static int m_uid; std::string m_id; util::Timestamp m_startTime; util::Timestamp m_endTime; std::string m_employeeId; Team* m_team; public: - Booking() : m_id(""), m_startTime(), m_endTime(), m_employeeId(""), m_team(nullptr) {}; - Booking(const std::string& id, - const util::Timestamp& startTime, + Booking() : m_id("BK" + std::to_string(++m_uid)), m_startTime(), m_endTime(), m_employeeId(""), m_team(nullptr) {} + Booking(const util::Timestamp& startTime, const util::Timestamp& endTime, const std::string& employeeId, - Team* team) : m_id(id), m_startTime(startTime), m_endTime(endTime), m_employeeId(employeeId), m_team(team) {}; + Team* team) + : m_id("BK" + std::to_string(++m_uid)), m_startTime(startTime), m_endTime(endTime), m_employeeId(employeeId), m_team(team) {} const std::string& getBookingId() const; const util::Timestamp& getStartTime() const; const util::Timestamp& getEndTime() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.cpp index 182fedc..e9bc101 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.cpp @@ -6,7 +6,8 @@ */ #include "Candidate.h" - //Getters and Setters +int Candidate::m_uid = 0; + const std::string& Candidate::getCandidateId() const { return m_id; @@ -17,7 +18,7 @@ const std::string& Candidate::getCandidateName() const return m_name; } -long int Candidate::getCandidatePhone() const +const std::string& Candidate::getCandidatePhone() const { return m_phone; } @@ -42,7 +43,7 @@ void Candidate::setCandidateName(const std::string& name) m_name = name; } -void Candidate::setCandidatePhone(long int phone) +void Candidate::setCandidatePhone(const std::string& phone) { m_phone = phone; } diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.h b/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.h index aefb893..d5c5f79 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Candidate.h @@ -11,27 +11,27 @@ class Candidate { private: + static int m_uid; std::string m_id; std::string m_name; - long int m_phone; + std::string m_phone; std::string m_qualification; Enums::CandidateStatus m_status; public: - Candidate() : m_id(""), m_name(""), m_phone(0), m_qualification(""), m_status(Enums::CandidateStatus::PENDING) {} - Candidate(const std::string& id, - const std::string& name, - long int phone, + Candidate() : m_id("CD" + std::to_string(++m_uid)), m_name(""), m_phone(""), m_qualification(""), m_status(Enums::CandidateStatus::PENDING) {} + Candidate(const std::string& name, + const std::string& phone, const std::string& qualification, Enums::CandidateStatus status) - : m_id(id), m_name(name), m_phone(phone), m_qualification(qualification), m_status(status) {} + : m_id("CD" + std::to_string(++m_uid)), m_name(name), m_phone(phone), m_qualification(qualification), m_status(status) {} const std::string& getCandidateId() const; const std::string& getCandidateName() const; - long int getCandidatePhone() const; + const std::string& getCandidatePhone() const; const std::string& getCandidateQualification() const; Enums::CandidateStatus getCandidateStatus() const; void setCandidateId(const std::string& id); void setCandidateName(const std::string& name); - void setCandidatePhone(long int phone); + void setCandidatePhone(const std::string& phone); void setCandidateQualification(const std::string& qualification); void setCandidateStatus(Enums::CandidateStatus status); }; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Employee.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Employee.cpp index 83a1ca2..7795d56 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Employee.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Employee.cpp @@ -4,10 +4,48 @@ * Author: Trenser * Created: 31-Mar-2026 */ +#include #include "Employee.h" +#include "Factory.h" +#include "StringHelper.h" +#include "Admin.h" +#include "HRManager.h" +#include "ITExecutive.h" +#include "TalentExecutive.h" +#include "TeamExecutive.h" +#include "FinanceExecutive.h" +#include "GeneralEmployee.h" - //Getters and Setters -const std::string& Employee::getEmployeeId() const +int Employee::m_uid = 0; + +Employee::Employee(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::EmployeeType employeeType, + Enums::AccountStatus accountStatus) + : m_id(id), + m_password(password), + m_name(name), + m_phone(phone), + m_email(email), + m_accountStatus(accountStatus), + m_teamStatus(teamStatus), + m_teamId(teamId), + m_employeeType(employeeType), + m_payroll() +{ + int idNumber = util::extractNumber(m_id); + if (idNumber > m_uid) + { + m_uid = idNumber; + } +} + +const std::string& Employee::getId() const { return m_id; } @@ -67,6 +105,16 @@ const leaveMap& Employee::getEmployeeLeaves() const return m_leaves; } +Enums::EmployeeType Employee::getEmployeeType() const +{ + return m_employeeType; +} + +std::string Employee::getHeaders() +{ + return "EmployeeId,Email,Name,Phone,Password,TeamID,TeamStatus,AccountStatus,EmployeeType"; +} + void Employee::setEmployeeId(const std::string& id) { m_id = id; @@ -107,14 +155,30 @@ void Employee::setEmployeePayroll(Payroll* payroll) m_payroll = payroll; } +/* +* Function: addPayslip +* Description : Adds a payslip to the employee's payslip records +* Parameters : + payslip - Pointer to the Payslip object to be added +* Returns : + void + */ void Employee::addPayslip(Payslip* payslip) { if (payslip) { - m_payslips[payslip->getPayslipId()] = payslip; + m_payslips[payslip->getId()] = payslip; } } +/* + * Function: addAttendance + * Description: Adds an attendance record to the employee's attendance history + * Parameters: + * attendance - Pointer to the Attendance object containing login information + * Returns: + * void + */ void Employee::addAttendance(Attendance* attendance) { if (attendance) @@ -123,6 +187,14 @@ void Employee::addAttendance(Attendance* attendance) } } +/* + * Function: addLeave + * Description: Adds a leave record to the employee's leave history + * Parameters: + * leave - Pointer to the Leave object to be added + * Returns: + * void + */ void Employee::addLeave(Leave* leave) { if (leave) @@ -131,7 +203,125 @@ void Employee::addLeave(Leave* leave) } } -Enums::EmployeeType Employee::getEmployeeType() const +/* + * Function: serialize + * Description: Serializes the employee object's core details into a comma-separated string + * Parameters: + None + * Returns: + A string containing serialized employee data in CSV format + */ +std::string Employee::serialize() const { - return m_employeeType; + std::ostringstream serializedEmployee; + serializedEmployee << m_id << ',' + << m_email << ',' + << m_name << ',' + << m_phone << ',' + << m_password << ',' + << m_teamId << ',' + << Enums::getTeamStatusString(m_teamStatus) << ',' + << Enums::getAccountStatusString(m_accountStatus) << ',' + << Enums::getEmployeeTypeString(m_employeeType); + return serializedEmployee.str(); } + +/* + * Function: deserialize + * Description: Creates and returns an Employee object from a serialized comma-separated record string + * Parameters: + record - A string containing serialized employee data in CSV format + * Returns: + Pointer to a newly created Employee object based on the employee type + */ +Employee* Employee::deserialize(const std::string& record) +{ + std::string id, name, phone, password, email; + std::string teamId, teamStatusString, accountStatusString, employeeTypeString; + std::istringstream serializedEmployee(record); + getline(serializedEmployee, id, ','); + getline(serializedEmployee, email, ','); + getline(serializedEmployee, name, ','); + getline(serializedEmployee, phone, ','); + getline(serializedEmployee, password, ','); + getline(serializedEmployee, teamId, ','); + getline(serializedEmployee, teamStatusString, ','); + getline(serializedEmployee, accountStatusString, ','); + getline(serializedEmployee, employeeTypeString, ','); + Enums::TeamStatus teamStatus = Enums::getTeamStatus(teamStatusString); + Enums::AccountStatus accountStatus = Enums::getAccountStatus(accountStatusString); + Enums::EmployeeType employeeType = Enums::getEmployeeType(employeeTypeString); + switch (employeeType) + { + case Enums::EmployeeType::IT: + return Factory::getObject( + id, + name, + phone, + password, + email, + teamId, + teamStatus, + accountStatus + ); + case Enums::EmployeeType::FINANCE: + return Factory::getObject( + id, + name, + phone, + password, + email, + teamId, + teamStatus, + accountStatus + ); + case Enums::EmployeeType::HR: + return Factory::getObject( + id, + name, + phone, + password, + email, + teamId, + teamStatus, + accountStatus + ); + case Enums::EmployeeType::TEAM: + return Factory::getObject( + id, + name, + phone, + password, + email, + teamId, + teamStatus, + accountStatus + ); + case Enums::EmployeeType::TALENT_ACQUISITION: + return Factory::getObject( + id, + name, + phone, + password, + email, + teamId, + teamStatus, + accountStatus + ); + case Enums::EmployeeType::ADMIN: + return Factory::getObject( + id, + name, + phone, + password, + email, + teamId, + teamStatus, + accountStatus + ); + case Enums::EmployeeType::GENERAL: + throw std::runtime_error("Cannot deserialize GeneralEmployee!"); + default: + return nullptr; + } +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Employee.h b/Trenser.Zenvy/Trenser.Zenvy/models/Employee.h index e7ce4c7..214e89c 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Employee.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Employee.h @@ -12,13 +12,15 @@ #include "Leave.h" #include "Payroll.h" #include "Enums.h" +#include "ApplicationConfig.h" using payslipMap = std::map; using attendanceMap = std::map>; using leaveMap = std::map; class Employee { -private: +protected: + static int m_uid; std::string m_id; std::string m_password; std::string m_name; @@ -33,17 +35,42 @@ private: leaveMap m_leaves; Enums::EmployeeType m_employeeType; public: - Employee() : m_id(""), m_password(""), m_name(""), m_phone(""), m_email(""), m_accountStatus(Enums::AccountStatus::ACTIVE), m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM), m_teamId(""), m_employeeType(Enums::EmployeeType::GENERAL) {} - Employee(const std::string& id, - const std::string& password, - const std::string& name, + Employee() + : m_id("EMP" + std::to_string(++m_uid)), + m_password(Config::Authentication::DEFAULT_PASSWORD), + m_name(""), + m_phone(""), + m_email(""), + m_accountStatus(Enums::AccountStatus::ACTIVE), + m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM), + m_teamId(""), + m_payroll(nullptr), + m_employeeType(Enums::EmployeeType::GENERAL) {} + Employee(const std::string& name, const std::string& phone, const std::string& email, - const std::string& teamId, Enums::EmployeeType employeeType, Payroll* payroll) - : m_id(id), m_password(password), m_name(name), m_phone(phone), m_email(email), m_accountStatus(Enums::AccountStatus::ACTIVE), m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM), m_teamId(teamId), m_employeeType(employeeType), m_payroll(payroll) { } - const std::string& getEmployeeId() const; + : m_id("EMP" + std::to_string(++m_uid)), + m_password(Config::Authentication::DEFAULT_PASSWORD), + m_name(name), + m_phone(phone), + m_email(email), + m_accountStatus(Enums::AccountStatus::ACTIVE), + m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM), + m_teamId(""), + m_employeeType(employeeType), + m_payroll(payroll) {} + Employee(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::EmployeeType employeeType, + Enums::AccountStatus accountStatus); + const std::string& getId() const; const std::string& getEmployeePassword() const; const std::string& getEmployeeName() const; const std::string& getEmployeePhone() const; @@ -67,5 +94,8 @@ public: void addAttendance(Attendance* attendance); void addLeave(Leave* leave); Enums::EmployeeType getEmployeeType() const; + virtual std::string serialize() const; + static Employee* deserialize(const std::string&); + static std::string getHeaders(); virtual ~Employee() = default; }; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.cpp index a5e7b41..4badf93 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.cpp @@ -4,4 +4,4 @@ * Author: Trenser * Created: 02-Apr-2026 */ -#include "Faq.h" +#include "Faq.h" \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.h b/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.h index 3788612..a2ba8bf 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/FAQ.h @@ -8,5 +8,4 @@ class Faq { -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/FinanceExecutive.h b/Trenser.Zenvy/Trenser.Zenvy/models/FinanceExecutive.h index 2f529bb..1a58dfe 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/FinanceExecutive.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/FinanceExecutive.h @@ -9,5 +9,30 @@ class FinanceExecutive : public Employee { -}; - +public: + FinanceExecutive() = default; + FinanceExecutive( + const std::string& name, + const std::string& phone, + const std::string& email, + Payroll* payroll + ) :Employee(name, phone, email, Enums::EmployeeType::FINANCE, payroll) {}; + FinanceExecutive(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::AccountStatus accountStatus) + : Employee(id, + name, + phone, + password, + email, + teamId, + teamStatus, + Enums::EmployeeType::FINANCE, + accountStatus) {} + ~FinanceExecutive() = default; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.cpp index 2fd78e5..fcf784c 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.cpp @@ -4,15 +4,85 @@ * Author: Trenser * Created: 31-Mar-2026 */ +#include #include "GeneralEmployee.h" +#include "Factory.h" - //Getters and Setters -Enums::EmployeeDesignation GeneralEmployee::getDesignation() const +Enums::EmployeeDesignation GeneralEmployee::getDesignation() const { return m_designation; } +std::string GeneralEmployee::getHeaders() +{ + return "EmployeeId,Email,Name,Phone,Password,TeamID,TeamStatus,AccountStatus,EmployeeType,EmployeeDesignation"; +} + void GeneralEmployee::setDesignation(Enums::EmployeeDesignation designation) { m_designation = designation; +} + +/* + * Function: serialize + * Description: Serializes the general employee's details, including designation, into a comma-separated string + * Parameters: + None + * Returns: + A string containing serialized general employee data in CSV format + */ +std::string GeneralEmployee::serialize() const +{ + std::ostringstream serializedEmployee; + serializedEmployee << m_id << ',' + << m_email << ',' + << m_name << ',' + << m_phone << ',' + << m_password << ',' + << m_teamId << ',' + << Enums::getTeamStatusString(m_teamStatus) << ',' + << Enums::getAccountStatusString(m_accountStatus) << ',' + << Enums::getEmployeeTypeString(m_employeeType) << ',' + << Enums::getEmployeeDesignationString(m_designation); + return serializedEmployee.str(); +} + +/* + * Function: deserialize + * Description: Creates and returns a GeneralEmployee object from a serialized comma-separated record string + * Parameters: + record - A string containing serialized general employee data in CSV format + * Returns: + Pointer to a newly created GeneralEmployee object + */ +GeneralEmployee* GeneralEmployee::deserialize(const std::string& record) +{ + std::string id, name, phone, password, email; + std::string teamId, teamStatusString, accountStatusString, employeeTypeString, employeeDesignationString; + std::istringstream serializedEmployee(record); + getline(serializedEmployee, id, ','); + getline(serializedEmployee, email, ','); + getline(serializedEmployee, name, ','); + getline(serializedEmployee, phone, ','); + getline(serializedEmployee, password, ','); + getline(serializedEmployee, teamId, ','); + getline(serializedEmployee, teamStatusString, ','); + getline(serializedEmployee, accountStatusString, ','); + getline(serializedEmployee, employeeTypeString, ','); + getline(serializedEmployee, employeeDesignationString, ','); + Enums::TeamStatus teamStatus = Enums::getTeamStatus(teamStatusString); + Enums::AccountStatus accountStatus = Enums::getAccountStatus(accountStatusString); + Enums::EmployeeType employeeType = Enums::getEmployeeType(employeeTypeString); + Enums::EmployeeDesignation employeeDesignation = Enums::getEmployeeDesignation(employeeDesignationString); + return Factory::getObject( + id, + name, + phone, + password, + email, + teamId, + teamStatus, + employeeDesignation, + accountStatus + ); } \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.h b/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.h index 93a7d06..885349c 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.h @@ -13,16 +13,42 @@ class GeneralEmployee : public Employee private: Enums::EmployeeDesignation m_designation; public: - GeneralEmployee() : m_designation(Enums::EmployeeDesignation::JUNIOR) {} - GeneralEmployee(const std::string& id, - const std::string& password, - const std::string& name, + GeneralEmployee() + : m_designation(Enums::EmployeeDesignation::JUNIOR) {} + GeneralEmployee(const std::string& name, const std::string& phone, const std::string& email, - const std::string& teamId, Payroll* payroll, - Enums::EmployeeDesignation designation) : Employee(id, password, name, phone, email, teamId,Enums::EmployeeType::GENERAL, payroll), m_designation(designation) {} + Enums::EmployeeDesignation designation) + : Employee(name, + phone, + email, + Enums::EmployeeType::GENERAL, + payroll), + m_designation(designation) {} + GeneralEmployee(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::EmployeeDesignation employeeDesignation, + Enums::AccountStatus accountStatus) + : Employee(id, + name, + phone, + password, + email, + teamId, + teamStatus, + Enums::EmployeeType::GENERAL, + accountStatus), + m_designation(employeeDesignation) {} Enums::EmployeeDesignation getDesignation() const; void setDesignation(Enums::EmployeeDesignation designation); + std::string serialize() const override; + static GeneralEmployee* deserialize(const std::string&); + static std::string getHeaders(); ~GeneralEmployee() = default; }; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.cpp index 8f9615f..3a3733b 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.cpp @@ -4,4 +4,4 @@ * Author: Trenser * Created: 31-Mar-2026 */ -#include "HRManager.h" +#include "HRManager.h" \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.h b/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.h index fda356c..6a08f03 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/HRManager.h @@ -9,5 +9,30 @@ class HRManager : public Employee { -}; - +public: + HRManager() = default; + HRManager( + const std::string& name, + const std::string& phone, + const std::string& email, + Payroll* payroll + ) :Employee(name, phone, email, Enums::EmployeeType::HR, payroll) {}; + HRManager(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::AccountStatus accountStatus) + : Employee(id, + name, + phone, + password, + email, + teamId, + teamStatus, + Enums::EmployeeType::HR, + accountStatus) {} + ~HRManager() = default; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/ITExecutive.h b/Trenser.Zenvy/Trenser.Zenvy/models/ITExecutive.h index b839ae4..ab807e8 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/ITExecutive.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/ITExecutive.h @@ -9,5 +9,30 @@ class ITExecutive : public Employee { -}; - +public: + ITExecutive() = default; + ITExecutive( + const std::string& name, + const std::string& phone, + const std::string& email, + Payroll* payroll + ) :Employee(name, phone, email, Enums::EmployeeType::IT, payroll) {}; + ITExecutive(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::AccountStatus accountStatus) + : Employee(id, + name, + phone, + password, + email, + teamId, + teamStatus, + Enums::EmployeeType::IT, + accountStatus) {} + ~ITExecutive() = default; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.cpp index 910c0e8..ecb91d4 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.cpp @@ -4,10 +4,10 @@ File: JobListing.cpp * Author : Trenser * Created : 01-Apr-2026 */ - #include "JobListing.h" -//Getters and setters +int JobListing::m_uid = 0; + const std::string& JobListing::getJobId() const { return m_id; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.h b/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.h index a269cff..ddbf58d 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/JobListing.h @@ -4,11 +4,9 @@ File: JobListing.h * Author : Trenser * Created : 01-Apr-2026 */ - #pragma once #include #include -#include #include "Candidate.h" #include "Enums.h" using candidateMap = std::map; @@ -16,6 +14,7 @@ using candidateMap = std::map; class JobListing { private: + static int m_uid; std::string m_id; std::string m_name; std::string m_description; @@ -23,14 +22,13 @@ private: int m_numberOfVacancies; candidateMap m_candidates; public: - JobListing() : m_id(""), m_name(""), m_description(""), m_status(Enums::JobListingStatus::CLOSED), m_numberOfVacancies(0) {} - JobListing(const std::string& id, - const std::string& name, + JobListing() : m_id("JL" + std::to_string(++m_uid)), m_name(""), m_description(""), m_status(Enums::JobListingStatus::CLOSED), m_numberOfVacancies(0) {} + JobListing(const std::string& name, const std::string& description, Enums::JobListingStatus status, int numberOfVacancies, const candidateMap& candidates) - : m_id(id), m_name(name), m_description(description), m_status(status), m_numberOfVacancies(numberOfVacancies), m_candidates(candidates) {} + : m_id("JL" + std::to_string(++m_uid)), m_name(name), m_description(description), m_status(status), m_numberOfVacancies(numberOfVacancies), m_candidates(candidates) {} const std::string& getJobId() const; const std::string& getJobName() const; const std::string& getJobDescription() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Leave.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Leave.cpp index c8496c6..c3f8a2d 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Leave.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Leave.cpp @@ -4,10 +4,10 @@ File: Leave.cpp * Author : Trenser * Created : 31-Mar-2026 */ - #include "Leave.h" -//Getters and setters +int Leave::m_uid = 0; + const std::string& Leave::getLeaveId() const { return m_id; @@ -28,21 +28,6 @@ const std::string& Leave::getLeaveReason() const return m_reason; } -int Leave::getNumberOfGeneralLeave() -{ - return m_numberOfGeneralLeave; -} - -int Leave::getNumberOfRestrictedLeave() -{ - return m_numberOfRestrictedLeave; -} - -int Leave::getNumberOfMedicalLeave() -{ - return m_numberOfMedicalLeave; -} - Enums::LeaveType Leave::getLeaveType() const { return m_leaveType; @@ -68,28 +53,7 @@ void Leave::setLeaveReason(const std::string& reason) m_reason = reason; } -void Leave::setNumberOfGeneralLeave(int value) -{ - m_numberOfGeneralLeave = value; -} - -void Leave::setNumberOfRestrictedLeave(int value) -{ - m_numberOfRestrictedLeave = value; -} - -void Leave::setNumberOfMedicalLeave(int value) -{ - m_numberOfMedicalLeave = value; -} - void Leave::setLeaveType(Enums::LeaveType type) { m_leaveType = type; -} - -int Leave::m_numberOfGeneralLeave = 12; - -int Leave::m_numberOfRestrictedLeave = 2; - -int Leave::m_numberOfMedicalLeave = 6; \ No newline at end of file +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Leave.h b/Trenser.Zenvy/Trenser.Zenvy/models/Leave.h index 4aa0473..3bd731f 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Leave.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Leave.h @@ -4,7 +4,6 @@ File: Leave.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include #include "Enums.h" @@ -13,36 +12,27 @@ File: Leave.h class Leave { private: + static int m_uid; std::string m_id; std::string m_employeeId; util::Timestamp m_timestamp; std::string m_reason; - static int m_numberOfGeneralLeave; - static int m_numberOfRestrictedLeave; - static int m_numberOfMedicalLeave; Enums::LeaveType m_leaveType; public: - Leave() : m_id(""), m_employeeId(""), m_timestamp(), m_reason(""), m_leaveType(Enums::LeaveType::GENERAL) {} - Leave(const std::string& id, - const std::string& employeeId, + Leave() : m_id("LV" + std::to_string(++m_uid)), m_employeeId(""), m_timestamp(), m_reason(""), m_leaveType(Enums::LeaveType::GENERAL) {} + Leave(const std::string& employeeId, const util::Timestamp& timestamp, const std::string& reason, Enums::LeaveType leaveType) - : m_id(id), m_employeeId(employeeId), m_timestamp(timestamp), m_reason(reason), m_leaveType(leaveType) {} + : m_id("LV" + std::to_string(++m_uid)), m_employeeId(employeeId), m_timestamp(timestamp), m_reason(reason), m_leaveType(leaveType) {} const std::string& getLeaveId() const; const std::string& getEmployeeId() const; const util::Timestamp& getTimestamp() const; const std::string& getLeaveReason() const; - static int getNumberOfGeneralLeave(); - static int getNumberOfRestrictedLeave(); - static int getNumberOfMedicalLeave(); Enums::LeaveType getLeaveType() const; void setLeaveId(const std::string& id); void setEmployeeId(const std::string& employeeId); void setTimestamp(const util::Timestamp& timestamp); void setLeaveReason(const std::string& reason); - void setNumberOfGeneralLeave(int value); - void setNumberOfRestrictedLeave(int value); - void setNumberOfMedicalLeave(int value); void setLeaveType(Enums::LeaveType type); }; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Log.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Log.cpp index af1e9e2..579b908 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Log.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Log.cpp @@ -4,10 +4,8 @@ File: Log.cpp * Author : Trenser * Created : 01-Apr-2026 */ - #include "Log.h" -//Getters and setters const util::Timestamp& Log::getTimestamp() const { return m_timestamp; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Log.h b/Trenser.Zenvy/Trenser.Zenvy/models/Log.h index f258643..cfb830d 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Log.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Log.h @@ -4,7 +4,6 @@ File: Log.h * Author : Trenser * Created : 01-Apr-2026 */ - #pragma once #include #include "Timestamp.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Notification.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Notification.cpp index 0a7456e..3da5d9b 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Notification.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Notification.cpp @@ -4,10 +4,10 @@ File: Notification.cpp * Author : Trenser * Created : 31-Mar-2026 */ - #include "Notification.h" -//Getters and setters +int Notification::m_uid = 0; + const std::string& Notification::getNotificationId() const { return m_id; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Notification.h b/Trenser.Zenvy/Trenser.Zenvy/models/Notification.h index 28f2cad..196078a 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Notification.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Notification.h @@ -4,7 +4,6 @@ File: Notification.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include #include "Enums.h" @@ -13,18 +12,18 @@ File: Notification.h class Notification { private: + static int m_uid; std::string m_id; std::string m_employeeId; std::string m_message; util::Timestamp m_timestamp; Enums::NotificationStatus m_notificationStatus; public: - Notification() : m_id(""), m_employeeId(""), m_message(""), m_timestamp(), m_notificationStatus(Enums::NotificationStatus::UNREAD) {} - Notification(const std::string& id, - const std::string& employeeId, + Notification() : m_id("NF" + std::to_string(++m_uid)), m_employeeId(""), m_message(""), m_timestamp(), m_notificationStatus(Enums::NotificationStatus::UNREAD) {} + Notification(const std::string& employeeId, const std::string& message, Enums::NotificationStatus notificationStatus) - : m_id(id), m_employeeId(employeeId), m_message(message), m_notificationStatus(notificationStatus) {} + : m_id("NF" + std::to_string(++m_uid)), m_employeeId(employeeId), m_message(message), m_notificationStatus(notificationStatus) {} const std::string& getNotificationId() const; const std::string& getEmployeeId() const; const std::string& getNotificationMessage() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.cpp index a4659ce..ba958ce 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.cpp @@ -4,15 +4,50 @@ File: Payroll.cpp * Author : Trenser * Created : 31-Mar-2026 */ - +#include #include "Payroll.h" +#include "StringHelper.h" +#include "Factory.h" -//Getters and setters -const std::string& Payroll::getPayrollId() const +int Payroll::m_uid = 0; + +Payroll::Payroll(const std::string& id, + const std::string& employeeId, + double basicSalary, + double houseRentAllowance, + double foodAllowance, + double employeePFContribution, + double employerPFContribution) + : m_id(id), + m_employeeId(employeeId), + m_basicSalary(basicSalary), + m_houseRentAllowance(houseRentAllowance), + m_foodAllowance(foodAllowance), + m_employeePFContribution(employeePFContribution), + m_employerPFContribution(employerPFContribution) +{ + int idNumber = util::extractNumber(m_id); + if (idNumber > m_uid) + { + m_uid = idNumber; + } +} + +const std::string& Payroll::getId() const { return m_id; } +const std::string& Payroll::getEmployeeId() const +{ + return m_employeeId; +} + +void Payroll::setEmployeeId(const std::string& employeeId) +{ + m_employeeId = employeeId; +} + double Payroll::getBasicSalary() const { return m_basicSalary; @@ -38,9 +73,14 @@ double Payroll::getEmployerPFContribution() const return m_employerPFContribution; } -void Payroll::setPayrollID(const std::string& id) +std::string Payroll::getHeaders() { - m_id = id; + return "PayrollId,EmployeeId,BasicSalary,HouseRentAllowance,FoodAllowance,EmployeePFContribution,EmployerPFContribution"; +} + +void Payroll::setBasicSalary(double basicSalary) +{ + m_basicSalary = basicSalary; } void Payroll::setHouseRentAllowance(double value) @@ -61,4 +101,68 @@ void Payroll::setEmployeePFContribution(double value) void Payroll::setEmployerPFContribution(double value) { m_employerPFContribution = value; +} + +/* +Function: serialize +Description: Converts the payroll object into a comma-separated string. +Parameters: + None +Returns: + A serialized string representation of the payroll. +*/ +std::string Payroll::serialize() const +{ + std::ostringstream serializedPayroll; + serializedPayroll << m_id << ',' + << m_employeeId << ',' + << m_basicSalary << ',' + << m_houseRentAllowance << ',' + << m_foodAllowance << ',' + << m_employeePFContribution << ',' + << m_employerPFContribution; + return serializedPayroll.str(); +} + +/* +Function: deserialize +Description: Creates a Payroll object from a serialized comma-separated string. +Parameters: + record - Serialized payroll data. +Returns: + Pointer to a Payroll object. +*/ +Payroll* Payroll::deserialize(const std::string& record) +{ + std::string id, employeeId; + std::string basicSalaryString, houseRentAllowanceString, foodAllowanceString, employeePFString, employerPFString; + std::istringstream serializedPayroll(record); + std::getline(serializedPayroll, id, ','); + std::getline(serializedPayroll, employeeId, ','); + std::getline(serializedPayroll, basicSalaryString, ','); + std::getline(serializedPayroll, houseRentAllowanceString, ','); + std::getline(serializedPayroll, foodAllowanceString, ','); + std::getline(serializedPayroll, employeePFString, ','); + std::getline(serializedPayroll, employerPFString, ','); + try + { + double basicSalary = std::stod(basicSalaryString); + double houseRentAllowance = std::stod(houseRentAllowanceString); + double foodAllowance = std::stod(foodAllowanceString); + double employeePFContribution = std::stod(employeePFString); + double employerPFContribution = std::stod(employerPFString); + return Factory::getObject( + id, + employeeId, + basicSalary, + houseRentAllowance, + foodAllowance, + employeePFContribution, + employerPFContribution + ); + } + catch (...) + { + throw std::runtime_error("Failed to deserialize Payroll object"); + } } \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.h b/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.h index dcbaeab..7b4699b 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Payroll.h @@ -4,37 +4,62 @@ File: Payroll.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include +#include "Timestamp.h" class Payroll { private: + static int m_uid; std::string m_id; + std::string m_employeeId; double m_basicSalary; double m_houseRentAllowance; double m_foodAllowance; double m_employeePFContribution; double m_employerPFContribution; + util::Timestamp m_timestamp; public: - Payroll() : m_id(""), m_basicSalary(0.0), m_houseRentAllowance(0.0), m_foodAllowance(0.0), m_employeePFContribution(0.0), m_employerPFContribution(0.0) {} - Payroll(const std::string& id, - double basicSalary, + Payroll() + : m_id("PR" + std::to_string(++m_uid)), + m_basicSalary(0.0), + m_houseRentAllowance(0.0), + m_foodAllowance(0.0), + m_employeePFContribution(0.0), + m_employerPFContribution(0.0) {} + Payroll(double basicSalary, double houseRentAllowance, double foodAllowance, double employeePFContribution, double employerPFContribution) - : m_id(id), m_basicSalary(basicSalary), m_houseRentAllowance(houseRentAllowance), m_foodAllowance(foodAllowance), m_employeePFContribution(employeePFContribution), m_employerPFContribution(employerPFContribution) {} - const std::string& getPayrollId() const; + : m_id("PR" + std::to_string(++m_uid)), + m_basicSalary(basicSalary), + m_houseRentAllowance(houseRentAllowance), + m_foodAllowance(foodAllowance), + m_employeePFContribution(employeePFContribution), + m_employerPFContribution(employerPFContribution) {} + Payroll(const std::string& id, + const std::string& employeeId, + double basicSalary, + double houseRentAllowance, + double foodAllowance, + double employeePFContribution, + double employerPFContribution); + const std::string& getId() const; + const std::string& getEmployeeId() const; + void setEmployeeId(const std::string&); double getBasicSalary() const; double getHouseRentAllowance() const; double getFoodAllowance() const; double getEmployeePFContribution() const; double getEmployerPFContribution() const; - void setPayrollID(const std::string& id); - void setHouseRentAllowance(double value); - void setFoodAllowance(double value); - void setEmployeePFContribution(double value); - void setEmployerPFContribution(double value); + static std::string getHeaders(); + void setBasicSalary(double); + void setHouseRentAllowance(double); + void setFoodAllowance(double); + void setEmployeePFContribution(double); + void setEmployerPFContribution(double); + std::string serialize() const; + static Payroll* deserialize(const std::string&); }; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.cpp index cdbef42..1f4f705 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.cpp @@ -4,11 +4,30 @@ File: Payslip.cpp * Author : Trenser * Created : 31-Mar-2026 */ - +#include #include "Payslip.h" +#include "StringHelper.h" +#include "Factory.h" -//Getters and setters -const std::string& Payslip::getPayslipId() const +int Payslip::m_uid = 0; + +Payslip::Payslip(const std::string& id, + const std::string& employeeId, + double salary, + util::Timestamp timestamp) + : m_id(id), + m_employeeId(employeeId), + m_salary(salary), + m_timestamp(timestamp) +{ + int idNumber = util::extractNumber(m_id); + if (idNumber > m_uid) + { + m_uid = idNumber; + } +} + +const std::string& Payslip::getId() const { return m_id; } @@ -26,4 +45,72 @@ void Payslip::setPayslipId(const std::string& id) void Payslip::setSalary(double salary) { m_salary = salary; +} + +const util::Timestamp& Payslip::getTimestamp() const +{ + return m_timestamp; +} + +const std::string& Payslip::getEmployeeId() const +{ + return m_employeeId; +} + +std::string Payslip::getHeaders() +{ + return "PayslipId,EmployeeId,Salary,Timestamp"; +} + +/* +Function: serialize +Description: Converts the payslip object into a comma-separated string. +Parameters: + None +Returns: + A serialized string representation of the payslip. +*/ +std::string Payslip::serialize() const +{ + std::ostringstream serializedPayslip; + serializedPayslip << m_id << ',' + << m_employeeId << ',' + << m_salary << ',' + << m_timestamp.toString(); + return serializedPayslip.str(); +} + +/* +Function: deserialize +Description: Creates a Payslip object from a serialized comma-separated string. +Parameters: + record - Serialized payslip data. +Returns: + Pointer to a Payslip object. +*/ +Payslip* Payslip::deserialize(const std::string& record) +{ + std::string id, employeeId, timestampString; + std::string salaryString; + std::istringstream serializedPayslip(record); + std::getline(serializedPayslip, id, ','); + std::getline(serializedPayslip, employeeId, ','); + std::getline(serializedPayslip, salaryString, ','); + std::getline(serializedPayslip, timestampString, ','); + + try + { + double salary = std::stod(salaryString); + util::Timestamp timestamp = util::Timestamp::fromString(timestampString); + return Factory::getObject( + id, + employeeId, + salary, + timestamp + ); + } + catch (...) + { + throw std::runtime_error("Failed to deserialize Payslip object"); + } } \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.h b/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.h index b9b7aa1..108b9c5 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Payslip.h @@ -4,20 +4,32 @@ File: Payslip.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include +#include "Timestamp.h" class Payslip { private: + static int m_uid; std::string m_id; + std::string m_employeeId; double m_salary; + util::Timestamp m_timestamp; public: - Payslip() : m_id(""), m_salary(0.0) {} - Payslip(const std::string& id, double salary) : m_id(id), m_salary(salary) {} - const std::string& getPayslipId() const; + Payslip() : m_id("PS" + std::to_string(++m_uid)), m_employeeId(""), m_salary(0.0) {} + Payslip(const double salary, const std::string& employeeId) : m_id("PS" + std::to_string(++m_uid)), m_employeeId(employeeId), m_salary(salary) {} + Payslip(const std::string& id, + const std::string& employeeId, + double salary, + util::Timestamp timestamp); + const std::string& getId() const; double getSalary() const; + static std::string getHeaders(); void setPayslipId(const std::string& id); void setSalary(double salary); + const util::Timestamp& getTimestamp() const; + const std::string& getEmployeeId() const; + std::string serialize() const; + static Payslip* deserialize(const std::string&); }; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Room.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Room.cpp index 8b32aea..6c1df34 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Room.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Room.cpp @@ -4,10 +4,10 @@ File: Room.cpp * Author : Trenser * Created : 31-Mar-2026 */ - #include "Room.h" -//Getters and setters +int Room::m_uid = 0; + const std::string& Room::getRoomId() const { return m_id; @@ -33,6 +33,14 @@ void Room::setRoomName(const std::string& name) m_name = name; } +/* +Function: addBooking +Description: Adds a valid booking to the room’s booking list using the booking ID as the key. +Parameters: + booking - A pointer to a Booking object to be added to the room. +Returns: + void +*/ void Room::addBooking(Booking* booking) { if (booking) diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Room.h b/Trenser.Zenvy/Trenser.Zenvy/models/Room.h index 3f1811b..63a52a8 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Room.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Room.h @@ -4,23 +4,22 @@ File: Room.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include #include -#include #include "Booking.h" using bookingMap = std::map; class Room { private: + static int m_uid; std::string m_id; std::string m_name; bookingMap m_bookings; public: - Room() : m_id(""), m_name("") {} - Room(const std::string& id, const std::string& name) : m_id(id), m_name(name) {} + Room() : m_id("RM" + std::to_string(++m_uid)), m_name("") {} + Room(const std::string& name) : m_id("RM" + std::to_string(++m_uid)), m_name(name) {} const std::string& getRoomId() const; const std::string& getRoomName() const; const bookingMap& getBookings() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.cpp index 5c44816..7023cd6 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.cpp @@ -4,5 +4,4 @@ File: TalentExecutive.cpp * Author : Trenser * Created : 31-Mar-2026 */ - #include "TalentExecutive.h" \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.h b/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.h index 54382d4..9ddde43 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.h @@ -4,11 +4,36 @@ File: TalentExecutive.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include "Employee.h" class TalentExecutive : public Employee { -}; - +public: + TalentExecutive() = default; + TalentExecutive( + const std::string& name, + const std::string& phone, + const std::string& email, + Payroll* payroll + ) :Employee(name, phone, email, Enums::EmployeeType::TALENT_ACQUISITION, payroll) {}; + TalentExecutive(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::AccountStatus accountStatus) + : Employee(id, + name, + phone, + password, + email, + teamId, + teamStatus, + Enums::EmployeeType::TALENT_ACQUISITION, + accountStatus) { + } + ~TalentExecutive() = default; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Team.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Team.cpp index e345eb8..5168acb 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Team.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Team.cpp @@ -4,10 +4,10 @@ File: Team.cpp * Author : Trenser * Created : 31-Mar-2026 */ - #include "Team.h" -//Getters and setters +int Team::m_uid = 0; + const std::string& Team::getTeamId() const { return m_id; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Team.h b/Trenser.Zenvy/Trenser.Zenvy/models/Team.h index 9ef386f..7afcaae 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Team.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Team.h @@ -4,29 +4,28 @@ File: Team.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include #include -#include #include "Employee.h" using employeeMap = std::map; class Team { private: + static int m_uid; std::string m_id; std::string m_name; Employee* m_lead; employeeMap m_employees; int m_maximumNumberOfEmployees; public: - Team() : m_id(""), m_name(""), m_lead(nullptr), m_maximumNumberOfEmployees(0) {} - Team(const std::string& id, + Team() : m_id("TM" + std::to_string(++m_uid)), m_name(""), m_lead(nullptr), m_maximumNumberOfEmployees(0) {} + Team( const std::string& name, Employee* lead, int maximumNumberOfEmployees) - : m_id(id), m_name(name), m_lead(lead), m_maximumNumberOfEmployees(maximumNumberOfEmployees) { + : m_id("TM" + std::to_string(++m_uid)), m_name(name), m_lead(lead), m_maximumNumberOfEmployees(maximumNumberOfEmployees) { } const std::string& getTeamId() const; const std::string& getTeamName() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.cpp index c780ad7..91d1691 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.cpp @@ -4,5 +4,4 @@ File: TeamExecutive.cpp * Author : Trenser * Created : 31-Mar-2026 */ - #include "TeamExecutive.h" \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.h b/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.h index ee45b0a..b550be3 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.h @@ -4,11 +4,35 @@ File: TeamExecutive.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include "Employee.h" class TeamExecutive : public Employee { -}; - +public: + TeamExecutive() = default; + TeamExecutive( + const std::string& name, + const std::string& phone, + const std::string& email, + Payroll* payroll + ) :Employee(name, phone, email, Enums::EmployeeType::TEAM, payroll) {}; + TeamExecutive(const std::string& id, + const std::string& name, + const std::string& phone, + const std::string& password, + const std::string& email, + const std::string& teamId, + Enums::TeamStatus teamStatus, + Enums::AccountStatus accountStatus) + : Employee(id, + name, + phone, + password, + email, + teamId, + teamStatus, + Enums::EmployeeType::TEAM, + accountStatus) {} + ~TeamExecutive() = default; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.cpp b/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.cpp index ba7227d..a07174e 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.cpp @@ -4,10 +4,10 @@ File: Ticket.cpp * Author : Trenser * Created : 31-Mar-2026 */ - #include "Ticket.h" -//Getters and setters +int Ticket::m_uid = 0; + const std::string& Ticket::getTicketId() const { return m_id; diff --git a/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.h b/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.h index e8657e6..ba5f25e 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.h +++ b/Trenser.Zenvy/Trenser.Zenvy/models/Ticket.h @@ -4,7 +4,6 @@ File: Ticket.h * Author : Trenser * Created : 31-Mar-2026 */ - #pragma once #include #include "Enums.h" @@ -12,19 +11,20 @@ File: Ticket.h class Ticket { private: + static int m_uid; std::string m_id; Enums::TicketType m_type; std::string m_description; Enums::TicketStatus m_status; std::string m_employeeId; public: - Ticket() : m_id(""), m_type(Enums::TicketType::UNKNOWN), m_description(""), m_status(Enums::TicketStatus::OPEN), m_employeeId("") {} - Ticket(const std::string& id, + Ticket() : m_id("TKT" + std::to_string(++m_uid)), m_type(Enums::TicketType::UNKNOWN), m_description(""), m_status(Enums::TicketStatus::OPEN), m_employeeId("") {} + Ticket( Enums::TicketType type, const std::string& description, const std::string& employeeId, Enums::TicketStatus status) - : m_id(id), m_type(type), m_description(description), m_status(status), m_employeeId(employeeId) {} + : m_id("TKT" + std::to_string(++m_uid)), m_type(type), m_description(description), m_status(status), m_employeeId(employeeId) {} const std::string& getTicketId() const; Enums::TicketType getTicketType() const; const std::string& getDescription() const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.cpp index e5a0d0e..e612cbc 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 06-Apr-2026 */ - #include "ApplicationConfig.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.h b/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.h index bbeadd1..2658b8e 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 06-Apr-2026 */ - #pragma once namespace Config @@ -13,4 +12,36 @@ namespace Config { constexpr const char* DEFAULT_PASSWORD = "password"; } + + namespace Payroll + { + constexpr double SENIOR_BASIC_SALARY = 80000.0; + constexpr double SENIOR_HOUSE_RENT_ALLOWANCE = 32000.0; + constexpr double SENIOR_FOOD_ALLOWANCE = 3000.0; + constexpr double SENIOR_EMPLOYEE_PF_CONTRIBUTION = 9600.0; + constexpr double SENIOR_EMPLOYER_PF_CONTRIBUTION = 9600.0; + constexpr double JUNIOR_BASIC_SALARY = 25000.0; + constexpr double JUNIOR_HOUSE_RENT_ALLOWANCE = 10000.0; + constexpr double JUNIOR_FOOD_ALLOWANCE = 1500.0; + constexpr double JUNIOR_EMPLOYEE_PF_CONTRIBUTION = 3000.0; + constexpr double JUNIOR_EMPLOYER_PF_CONTRIBUTION = 3000.0; + constexpr double HR_MANAGER_BASIC_SALARY = 60000.0; + constexpr double HR_MANAGER_HOUSE_RENT_ALLOWANCE = 24000.0; + constexpr double HR_MANAGER_FOOD_ALLOWANCE = 2500.0; + constexpr double HR_MANAGER_EMPLOYEE_PF_CONTRIBUTION = 7200.0; + constexpr double HR_MANAGER_EMPLOYER_PF_CONTRIBUTION = 7200.0; + constexpr double EXECUTIVE_BASIC_SALARY = 45000.0; + constexpr double EXECUTIVE_HOUSE_RENT_ALLOWANCE = 18000.0; + constexpr double EXECUTIVE_FOOD_ALLOWANCE = 2000.0; + constexpr double EXECUTIVE_EMPLOYEE_PF_CONTRIBUTION = 5400.0; + constexpr double EXECUTIVE_EMPLOYER_PF_CONTRIBUTION = 5400.0; + } + + namespace File + { + constexpr const char* EMPLOYEES_FILE = "files/Employee.csv"; + constexpr const char* GENERAL_EMPLOYEES_FILE = "files/GeneralEmployee.csv"; + constexpr const char* PAYROLL_FILE = "files/Payroll.csv"; + constexpr const char* PAYSLIP_FILE = "files/Payslip.csv"; + } } diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.cpp index 2ab575a..35ae237 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 30-Apr-2026 */ - #include "AttendanceManagementService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.h index 5f12270..a97103e 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/AttendanceManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Apr-2026 */ - #pragma once class AttendanceManagementService { diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.cpp index 294c3b8..4abd1ea 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.cpp @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #include #include "AuthenticationManagementService.h" #include "ApplicationConfig.h" @@ -22,47 +21,51 @@ */ AuthenticationDTO AuthenticationManagementService::login(const std::string& email, const std::string& password) { - employeeMap& employees = m_dataStore.getEmployees(); - Enums::LoginStatus loginStatus = Enums::LoginStatus::USER_NOT_FOUND; - Enums::EmployeeType employeeType = Enums::EmployeeType::INVALID; - Enums::EmployeeDesignation employeeDesignation = Enums::EmployeeDesignation::INVALID; - for (const auto& employee : employees) - { - if (employee.second->getEmployeeEmail() == email) - { - if (employee.second->getEmployeePassword() == password) - { - if (password == Config::Authentication::DEFAULT_PASSWORD) - { - loginStatus = Enums::LoginStatus::FIRST_LOGIN; - } - else - { - loginStatus = Enums::LoginStatus::SUCCESS; - } - employeeType = employee.second->getEmployeeType(); - if (employeeType == Enums::EmployeeType::GENERAL) - { + employeeMap& employees = m_dataStore.getEmployees(); + Enums::LoginStatus loginStatus = Enums::LoginStatus::USER_NOT_FOUND; + Enums::EmployeeType employeeType = Enums::EmployeeType::INVALID; + Enums::EmployeeDesignation employeeDesignation = Enums::EmployeeDesignation::INVALID; + for (const auto& employee : employees) + { + if (employee.second->getEmployeeEmail() == email) + { + if (employee.second->getEmployeePassword() == password) + { + if (employee.second->getEmployeeAccountStatus() == Enums::AccountStatus::INACTIVE) + { + throw std::runtime_error("Your account has been disabled! Please contact your Administrator."); + } + if (password == Config::Authentication::DEFAULT_PASSWORD) + { + loginStatus = Enums::LoginStatus::FIRST_LOGIN; + } + else + { + loginStatus = Enums::LoginStatus::SUCCESS; + } + employeeType = employee.second->getEmployeeType(); + if (employeeType == Enums::EmployeeType::GENERAL) + { GeneralEmployee* generalEmployee = dynamic_cast(employee.second); - if (generalEmployee) - { - employeeDesignation = generalEmployee->getDesignation(); - } - else - { - throw std::runtime_error("Invalid Employee Type"); - } - } - m_dataStore.setAuthenticatedEmployee(employee.second); - } - else - { - loginStatus = Enums::LoginStatus::INVALID_PASSWORD; - } - break; - } - } - return std::make_tuple(loginStatus, employeeType, employeeDesignation); + if (generalEmployee) + { + employeeDesignation = generalEmployee->getDesignation(); + } + else + { + throw std::runtime_error("Invalid Employee Type"); + } + } + m_dataStore.setAuthenticatedEmployee(employee.second); + } + else + { + loginStatus = Enums::LoginStatus::INVALID_PASSWORD; + } + break; + } + } + return std::make_tuple(loginStatus, employeeType, employeeDesignation); } /* @@ -77,7 +80,7 @@ AuthenticationDTO AuthenticationManagementService::login(const std::string& emai */ void AuthenticationManagementService::changePassword(const std::string& password) { - Employee* authenticatedUser = m_dataStore.getAuthenticatedUser(); + Employee* authenticatedUser = m_dataStore.getAuthenticatedEmployee(); if (authenticatedUser) { authenticatedUser->setEmployeePassword(password); diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.h index 392065b..b4669d4 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once #include #include @@ -25,4 +24,4 @@ public: AuthenticationDTO login(const std::string& username, const std::string& password); void logout(); void changePassword(const std::string&); -}; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.cpp index cb032c3..2545535 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #include "BookingManagementService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.h index 7f343a4..258ad18 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/BookingManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once class BookingManagementService { diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.cpp deleted file mode 100644 index 5fdebfe..0000000 --- a/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.cpp +++ /dev/null @@ -1,8 +0,0 @@ -/* - * File: EmployeeManagementService.cpp - * Description: Handle operations related to employees - * Author: Trenser - * Created: 30-Mar-2026 - */ - -#include "EmployeeManagememtService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.h b/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.h deleted file mode 100644 index 3bb2294..0000000 --- a/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.h +++ /dev/null @@ -1,12 +0,0 @@ -/* - * File: EmployeeManagementService.h - * Description: Handle operations related to employees - * Author: Trenser - * Created: 30-Mar-2026 - */ - -#pragma once -class EmployeeManagememtService -{ -}; - diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.cpp new file mode 100644 index 0000000..c5751bf --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.cpp @@ -0,0 +1,341 @@ +/* + * File: EmployeeManagementService.h + * Description: Provides services for managing employees, including creation, deactivation, + * designation updates, profile modifications, searching, and retrieval of + * shortlisted candidates. + * Author: Trenser + * Created: 07-Apr-2026 + */ +#include +#include +#include +#include "EmployeeManagementService.h" +#include "Factory.h" +#include "Validator.h" +#include "AuthorizationHelper.h" +#include "Enums.h" +#include "HRManager.h" +#include "ITExecutive.h" +#include "TalentExecutive.h" +#include "TeamExecutive.h" +#include "FinanceExecutive.h" +#include "GeneralEmployee.h" +#include "FileManager.h" +#include "ApplicationConfig.h" + + /* + * Function: createEmployee + * Description: Creates a new employee of the specified type and designation, validates + * email and phone, enforces authorization, and associates payroll. + * Parameters: + * employeeType - type of employee (HR, IT, Finance, Team, Talent Acquisition, General) + * employeeDesignation - designation for general employees (Junior, Senior) + * email - employee email address + * name - employee name + * phone - employee phone number + * Returns: + * None + */ +void EmployeeManagementService::createEmployee(Enums::EmployeeType employeeType, Enums::EmployeeDesignation employeeDesignation, const std::string& email, const std::string& name, const std::string& phone) +{ + auto& employees = m_dataStore.getEmployees(); + Employee* authenticatedEmployee = m_dataStore.getAuthenticatedEmployee(); + if (!authenticatedEmployee) + { + throw std::runtime_error("No authenticated user"); + } + Enums::EmployeeType authenticatedEmployeeType = authenticatedEmployee->getEmployeeType(); + Employee* employee = nullptr; + Payroll* payroll = nullptr; + if (employeeType != Enums::EmployeeType::GENERAL && util::hasActiveEmployeeOfType(employeeType, employees)) + { + throw std::runtime_error("Cannot create more than one employee of type " + Enums::getEmployeeTypeString(employeeType)); + } + if (!util::isEmailValid(email)) + { + throw std::runtime_error("Invalid Email"); + } + if (!util::isPhoneNumberValid(phone)) + { + throw std::runtime_error("Invalid Phone"); + } + if (util::isEmailDuplicate(email, employees)) + { + throw std::runtime_error("Duplicate Email"); + } + if (util::isPhoneDuplicate(phone, employees)) + { + throw std::runtime_error("Duplicate Phone Number!"); + } + switch (employeeType) + { + case Enums::EmployeeType::HR: + util::enforceAuthorization(authenticatedEmployeeType, Enums::EmployeeType::ADMIN); + payroll = Factory::getObject(Config::Payroll::HR_MANAGER_BASIC_SALARY, + Config::Payroll::HR_MANAGER_HOUSE_RENT_ALLOWANCE, + Config::Payroll::HR_MANAGER_FOOD_ALLOWANCE, + Config::Payroll::HR_MANAGER_EMPLOYEE_PF_CONTRIBUTION, + Config::Payroll::HR_MANAGER_EMPLOYER_PF_CONTRIBUTION); + employee = Factory::getObject(name, phone, email, payroll); + break; + case Enums::EmployeeType::IT: + case Enums::EmployeeType::FINANCE: + case Enums::EmployeeType::TEAM: + case Enums::EmployeeType::TALENT_ACQUISITION: + util::enforceAuthorization(authenticatedEmployeeType, Enums::EmployeeType::ADMIN, Enums::EmployeeType::HR); + payroll = Factory::getObject(Config::Payroll::EXECUTIVE_BASIC_SALARY, + Config::Payroll::EXECUTIVE_HOUSE_RENT_ALLOWANCE, + Config::Payroll::EXECUTIVE_FOOD_ALLOWANCE, + Config::Payroll::EXECUTIVE_EMPLOYEE_PF_CONTRIBUTION, + Config::Payroll::EXECUTIVE_EMPLOYER_PF_CONTRIBUTION); + switch (employeeType) + { + case Enums::EmployeeType::IT: + employee = Factory::getObject(name, phone, email, payroll); + break; + case Enums::EmployeeType::FINANCE: + employee = Factory::getObject(name, phone, email, payroll); + break; + case Enums::EmployeeType::TEAM: + employee = Factory::getObject(name, phone, email, payroll); + break; + case Enums::EmployeeType::TALENT_ACQUISITION: + employee = Factory::getObject (name, phone, email, payroll); + break; + } + break; + case Enums::EmployeeType::GENERAL: + util::enforceAuthorization(authenticatedEmployeeType, Enums::EmployeeType::ADMIN, Enums::EmployeeType::HR); + switch (employeeDesignation) + { + case Enums::EmployeeDesignation::JUNIOR: + payroll = Factory::getObject(Config::Payroll::JUNIOR_BASIC_SALARY, + Config::Payroll::JUNIOR_HOUSE_RENT_ALLOWANCE, + Config::Payroll::JUNIOR_FOOD_ALLOWANCE, + Config::Payroll::JUNIOR_EMPLOYEE_PF_CONTRIBUTION, + Config::Payroll::JUNIOR_EMPLOYER_PF_CONTRIBUTION); + break; + case Enums::EmployeeDesignation::SENIOR: + payroll = Factory::getObject(Config::Payroll::SENIOR_BASIC_SALARY, + Config::Payroll::SENIOR_HOUSE_RENT_ALLOWANCE, + Config::Payroll::SENIOR_FOOD_ALLOWANCE, + Config::Payroll::SENIOR_EMPLOYEE_PF_CONTRIBUTION, + Config::Payroll::SENIOR_EMPLOYER_PF_CONTRIBUTION); + break; + default: + throw std::runtime_error("Invalid General Employee Designation"); + } + employee = Factory::getObject(name, phone, email, payroll, employeeDesignation); + break; + default: + throw std::runtime_error("Invalid Employee Type"); + } + payroll->setEmployeeId(employee->getId()); + m_dataStore.getPayrolls().emplace(std::make_pair(payroll->getId(), payroll)); + m_dataStore.getEmployees().emplace(std::make_pair(employee->getId(), employee)); +} + +/* + * Function: deactivateEmployee + * Description: Deactivates an employee account by setting its status to INACTIVE. + * Prevents deactivation of Admin accounts. + * Parameters: + * id - unique identifier of the employee + * Returns: + * bool - true if deactivation succeeded, false otherwise + */ +bool EmployeeManagementService::deactivateEmployee(const std::string& id) +{ + auto& authenticatedEmployee = m_dataStore.getAuthenticatedEmployee(); + util::enforceAuthorization(authenticatedEmployee->getEmployeeType(), Enums::EmployeeType::ADMIN, Enums::EmployeeType::HR); + auto& employee = m_dataStore.getEmployees(); + auto iterator = employee.find(id); + if (iterator == employee.end()) + { + return false; + } + if (iterator->second->getEmployeeType() == Enums::EmployeeType::ADMIN) + { + throw std::runtime_error("Cannot deactivate Admin Account"); + } + iterator->second->setEmployeeAccountStatus(Enums::AccountStatus::INACTIVE); + return true; +} + + /* + * Function: updateDesignation + * Description: Updates the designation of a general employee. + * Parameters: + * id - unique identifier of the employee + * designation - new designation to assign + * Returns: + * bool - true if update succeeded, false otherwise + */ +bool EmployeeManagementService::updateDesignation(const std::string& id, Enums::EmployeeDesignation designation) +{ + auto& authenticatedEmployee = m_dataStore.getAuthenticatedEmployee(); + util::enforceAuthorization(authenticatedEmployee->getEmployeeType(), Enums::EmployeeType::ADMIN, Enums::EmployeeType::HR); + std::map employees = m_dataStore.getEmployees(); + auto employeeIterator = employees.find(id); + if (employeeIterator == employees.end()) + { + return false; + } + auto generalEmployee = dynamic_cast((*employeeIterator).second); + if (generalEmployee) + { + generalEmployee->setDesignation(designation); + } + return true; +} + +/* + * Function: getCurrentEmployee + * Description: Retrieves the currently authenticated employee from the DataStore. + * Parameters: + * None + * Returns: + * const Employee* - pointer to the current employee + */ +const Employee* EmployeeManagementService::getCurrentEmployee() +{ + return m_dataStore.getAuthenticatedEmployee(); +} + +/* + * Function: updateProfile + * Description: Updates the name and phone number of the currently authenticated employee. + * Parameters: + * name - new employee name + * phone - new employee phone number + * Returns: + * None + */ +void EmployeeManagementService::updateProfile(const std::string& name,const std::string& phone) +{ + Employee* employee = m_dataStore.getAuthenticatedEmployee(); + employee->setEmployeeName(name); + employee->setEmployeePhone(phone); +} + +/* + * Function: searchEmployee + * Description: Searches employees by name and returns matches along + * with the type of the current authenticated employee. + * Parameters: + * name - search string for employee name + * Returns: + * pair> - current user type and matching employees + */ +std::pair> EmployeeManagementService::searchEmployee(const std::string& name) +{ + Employee* currentUser = m_dataStore.getAuthenticatedEmployee(); + Enums::EmployeeType employeeType = currentUser->getEmployeeType(); + employeeMap& employees = m_dataStore.getEmployees(); + std::vector employeeList; + if (employees.empty()) + { + return std::make_pair(employeeType, employeeList); + } + for (const auto& employeePair : employees) { + const auto& employee = employeePair.second; + if (!employee) + { + continue; + } + std::string employeeName = employee->getEmployeeName(); + std::transform(employeeName.begin(), employeeName.end(), employeeName.begin(), ::tolower); + std::string searchName = name; + std::transform(searchName.begin(), searchName.end(), searchName.begin(), ::tolower); + if (employeeName.find(searchName) != std::string::npos) + { + employeeList.push_back(employee); + } + } + return { employeeType, employeeList }; +} + +/* + * Function: getShorlistedCandidates + * Description: Retrieves candidates with status SHORTLISTED from the DataStore. + * Parameters: + * None + * Returns: + * vector - list of shortlisted candidates + */ +std::vector EmployeeManagementService::getShorlistedCandidates() +{ + candidateMap candidates = m_dataStore.getCandidates(); + std::vector shortlistedCandidates; + for (auto& candidate : candidates) + { + if (candidate.second->getCandidateStatus() == Enums::CandidateStatus::SHORTLISTED) + { + shortlistedCandidates.push_back(candidate.second); + } + } + return shortlistedCandidates; +} + +/* + * Function: loadEmployees + * Description: Loads employees and general employees from FileManager into the DataStore. + * Parameters: + * None + * Returns: + * None + */ +void EmployeeManagementService::loadEmployees() +{ + FileManager employeeFileManager(Config::File::EMPLOYEES_FILE); + FileManager generalEmployeeFileManager(Config::File::GENERAL_EMPLOYEES_FILE); + bool isAdminFound = false; + auto& employees = m_dataStore.getEmployees(); + auto employeesMap = employeeFileManager.load(); + auto generalEmployeesMap = generalEmployeeFileManager.load(); + employees.insert(employeesMap.begin(), employeesMap.end()); + employees.insert(generalEmployeesMap.begin(), generalEmployeesMap.end()); + for (auto& employeePair : employees) + { + if (employeePair.second->getEmployeeType() == Enums::EmployeeType::ADMIN) + { + isAdminFound = true; + break; + } + } + if (!isAdminFound) + { + auto admin = Factory::getObject("Admin", "", "admin@trenser.com", nullptr); + employees.emplace(std::make_pair(admin->getId(), admin)); + } +} + +/* + * Function: saveEmployees + * Description: Saves employees and general employees from the DataStore into FileManager. + * Parameters: + * None + * Returns: + * None + */ +void EmployeeManagementService::saveEmployees() +{ + FileManager employeeFileManager(Config::File::EMPLOYEES_FILE); + FileManager generalEmployeeFileManager(Config::File::GENERAL_EMPLOYEES_FILE); + const auto& allEmployees = m_dataStore.getEmployees(); + employeeMap employees; + std::map generalEmployees; + for (auto& employeePair : allEmployees) + { + if (employeePair.second->getEmployeeType() == Enums::EmployeeType::GENERAL) + { + generalEmployees.emplace(employeePair.first, static_cast(employeePair.second)); + } + else + { + employees.emplace(employeePair); + } + } + employeeFileManager.save(employees); + generalEmployeeFileManager.save(generalEmployees); +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.h new file mode 100644 index 0000000..b819a8b --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.h @@ -0,0 +1,81 @@ +/* + * File: EmployeeManagementService.h + * Description: Provides services for managing employees, including creation, deactivation, + * designation updates, profile modifications, searching, and retrieval of + * shortlisted candidates. + * Author: Trenser + * Created: 07-Apr-2026 + */ +#pragma once +#include +#include +#include +#include +#include "DataStore.h" +#include "Enums.h" +#include "StringHelper.h" + +using Employees = std::vector; + +class EmployeeManagementService +{ +private: + DataStore& m_dataStore; +public: + EmployeeManagementService() : m_dataStore(DataStore::getInstance()) {}; + void createEmployee(Enums::EmployeeType, Enums::EmployeeDesignation, const std::string&, const std::string&, const std::string&); + bool deactivateEmployee(const std::string&); + bool updateDesignation(const std::string&, Enums::EmployeeDesignation); + void updateProfile(const std::string&, const std::string&); + std::pair> searchEmployee(const std::string&); + const Employee* getCurrentEmployee(); + std::vector getShorlistedCandidates(); + void loadEmployees(); + void saveEmployees(); + + /* + * Function: getEmployees (template) + * Description: Retrieves active employees filtered by specified types. Excludes admin employees + * if no filter is provided. + * Parameters: + * types... - variadic list of employee types + * Returns: + * Employees - vector of pointers to filtered employees + */ + template + Employees getEmployees(Types... types) + { + Employees filteredEmployees; + const auto& employees = m_dataStore.getEmployees(); + std::vector filterTypes = { types... }; + for (const auto& employeePair : employees) + { + const auto& employee = employeePair.second; + if (employee->getEmployeeAccountStatus() != Enums::AccountStatus::ACTIVE) + continue; + auto employeeType = employee->getEmployeeType(); + if (filterTypes.empty()) + { + if (employeeType == Enums::EmployeeType::ADMIN) + continue; + } + else + { + if (std::find(filterTypes.begin(), filterTypes.end(), employeeType) == filterTypes.end()) + continue; + } + filteredEmployees.push_back(employee); + } + std::sort( + filteredEmployees.begin(), + filteredEmployees.end(), + [](const Employee* employeeOne, + const Employee* employeeTwo) + { + return util::extractNumber(employeeOne->getId()) < + util::extractNumber(employeeTwo->getId()); + } + ); + return filteredEmployees; + } +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.cpp index 733f9eb..647154e 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #include "LeaveManagementService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.h index 1010ec4..40b2c4b 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/LeaveManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once class LeaveManagementService { diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/LogService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/LogService.cpp index 6917cda..1f68ffe 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/LogService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/LogService.cpp @@ -4,16 +4,24 @@ * Author: Trenser * Created: 01-Apr-2026 */ - #include "LogService.h" #include "Log.h" #include "Factory.h" #include "DataStore.h" + /* + * Function: log + * Description: Creates a new log entry with the given message, assigns a timestamp, + * and stores it in the DataStore. + * Parameters: + * message - string containing the log message to be recorded + * Returns: + * void - no return value + */ void LogService::log(const std::string& message) { DataStore& dataStore = DataStore::getInstance(); logMap& logs = dataStore.getLogs(); Log* log = Factory::getObject(message); logs.emplace(std::make_pair(log->getTimestamp(), log)); -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/LogService.h b/Trenser.Zenvy/Trenser.Zenvy/services/LogService.h index c1cf644..416d4ba 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/LogService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/LogService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 01-Apr-2026 */ - #pragma once #include "Log.h" @@ -12,4 +11,4 @@ class LogService { public: static void log(const std::string&); -}; +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.cpp index 7eaa377..f7f94a7 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #include "NotificationManagementService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.h index 6b4aba1..cef9bfc 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/NotificationManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once class NotificationManagementService { diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.cpp index 57ca929..685d487 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.cpp @@ -4,5 +4,206 @@ * Author: Trenser * Created: 30-Mar-2026 */ - +#include +#include #include "PayslipManagementService.h" +#include "ApplicationConfig.h" +#include "AuthorizationHelper.h" +#include "Enums.h" +#include "FileManager.h" +#include "Factory.h" + + /* + * Function: updateSalary + * Description: Updates the payroll details of a given employee, including salary components + * and PF contributions. + * Parameters: + * employeeId - unique identifier of the employee + * basicSalary - basic salary of the employee + * houseRentAllowance - HRA component + * foodAllowance - food allowance component + * employeePFContribution - employee PF contribution + * employerPFContribution - employer PF contribution + * Returns: + * void - throws runtime_error if employee not found or unauthorized + */ +void PayslipManagementService::updateSalary(const std::string& employeeId, double basicSalary, double houseRentAllowance, double foodAllowance, double employeePFContribution, double employerPFContribution) +{ + util::enforceAuthorization(m_dataStore.getAuthenticatedEmployee()->getEmployeeType(), Enums::EmployeeType::FINANCE); + auto employee = m_dataStore.getEmployees().find(employeeId); + if (employee != m_dataStore.getEmployees().end() && employee->second->getEmployeeType() != Enums::EmployeeType::ADMIN) + { + auto payroll = employee->second->getPayroll(); + payroll->setBasicSalary(basicSalary); + payroll->setHouseRentAllowance(houseRentAllowance); + payroll->setFoodAllowance(foodAllowance); + payroll->setEmployeePFContribution(employeePFContribution); + payroll->setEmployerPFContribution(employerPFContribution); + } + else + { + throw std::runtime_error("Employee not found, unable to update the salary"); + } +} + + /* + * Function: generatePayslips + * Description: Generates payslips for all employees for the current month and year. + * Parameters: + * None + * Returns: + * void - creates and stores payslips in DataStore + */ +void PayslipManagementService::generatePayslips() +{ + util::enforceAuthorization(m_dataStore.getAuthenticatedEmployee()->getEmployeeType(), Enums::EmployeeType::FINANCE); + auto& employees = m_dataStore.getEmployees(); + auto& payslips = m_dataStore.getPayslips(); + util::Timestamp currentTimestamp; + int currentMonth = currentTimestamp.getMonth(); + int currentYear = currentTimestamp.getYear(); + for (const auto& employeePair : employees) + { + auto& employee = employeePair.second; + if (employee->getEmployeeType() == Enums::EmployeeType::ADMIN) + { + continue; + } + auto& employeePayslips = employee->getEmployeePayslips(); + auto payslipForTheMonth = std::find_if(employeePayslips.begin(), employeePayslips.end(), + [currentMonth, currentYear](const auto& payslipPair) + { + auto& payslip = payslipPair.second; + auto& timestamp = payslip->getTimestamp(); + return (timestamp.getMonth() == currentMonth && timestamp.getYear() == currentYear); + } + ); + if (payslipForTheMonth == employeePayslips.end()) + { + auto payroll = employee->getPayroll(); + double salary; + salary = payroll->getBasicSalary() + payroll->getFoodAllowance() + payroll->getHouseRentAllowance() - payroll->getEmployeePFContribution() - payroll->getEmployerPFContribution(); + Payslip* payslip = Factory::getObject(salary, employee->getId()); + employee->addPayslip(payslip); + payslips.emplace(payslip->getId(), payslip); + } + } +} + + /* + * Function: loadPayrolls + * Description: Loads payroll objects from persistent storage and associates them + * with existing employees. + * Parameters: + * None + * Returns: + * void - updates DataStore with loaded payrolls + */ +void PayslipManagementService::loadPayrolls() +{ + FileManager payrollFileManager(Config::File::PAYROLL_FILE); + auto& payrolls = m_dataStore.getPayrolls(); + auto& employees = m_dataStore.getEmployees(); + auto payrollObjects = payrollFileManager.load(); + for (const auto& payrollPair : payrollObjects) + { + auto employeeIterator = employees.find(payrollPair.second->getEmployeeId()); + if (employeeIterator == employees.end()) + { + throw std::runtime_error("Payroll Object not associated with an existing employee"); + } + employeeIterator->second->setEmployeePayroll(payrollPair.second); + } + payrolls.insert(payrollObjects.begin(), payrollObjects.end()); +} + + /* + * Function: savePayrolls + * Description: Saves all payroll objects from DataStore into persistent storage. + * Parameters: + * None + * Returns: + * None + */ +void PayslipManagementService::savePayrolls() +{ + FileManager payrollFileManager(Config::File::PAYROLL_FILE); + auto& payrolls = m_dataStore.getPayrolls(); + payrollFileManager.save(payrolls); +} + + /* + * Function: getPayslipForMonth + * Description: Retrieves the payroll and payslip of a given employee for a specific + * month and year. + * Parameters: + * employeeId - unique identifier of the employee + * year - year of the payslip + * month - month of the payslip + * Returns: + * pair - payroll and payslip for the given month. + */ +std::pair PayslipManagementService::getPayslipForMonth(const std::string& employeeId, int year, int month) +{ + auto& employees = m_dataStore.getEmployees(); + auto employeeIterator = employees.find(employeeId); + if (employeeIterator == employees.end()) + { + throw std::runtime_error("Employee not found!"); + } + auto payroll = employeeIterator->second->getPayroll(); + auto& payslips = employeeIterator->second->getEmployeePayslips(); + for (const auto& payslipPair : payslips) + { + const auto& payslip = payslipPair.second; + { + if (payslip->getTimestamp().getYear() == year && payslip->getTimestamp().getMonth() == month) + { + return { payroll, payslip }; + } + } + } + return { nullptr, nullptr }; +} + + /* + * Function: loadPayslips + * Description: Loads payslip objects from FileManager and associates them + * with existing employees. + * Parameters: + * None + * Returns: + * void - updates DataStore with loaded payslips + */ +void PayslipManagementService::loadPayslips() +{ + FileManager payslipFileManager(Config::File::PAYSLIP_FILE); + auto& payslips = m_dataStore.getPayslips(); + auto& employees = m_dataStore.getEmployees(); + auto payslipObjects = payslipFileManager.load(); + for (const auto& payslipPair : payslipObjects) + { + auto employeeIterator = employees.find(payslipPair.second->getEmployeeId()); + if (employeeIterator == employees.end()) + { + throw std::runtime_error("Payslip Object not associated with an existing employee"); + } + employeeIterator->second->addPayslip(payslipPair.second); + } + payslips.insert(payslipObjects.begin(), payslipObjects.end()); +} + + /* + * Function: savePayslips + * Description: Saves all payslip objects from DataStore into FileManager. + * Parameters: + * None + * Returns: + * void + */ +void PayslipManagementService::savePayslips() +{ + FileManager payslipFileManager(Config::File::PAYSLIP_FILE); + auto& payslips = m_dataStore.getPayslips(); + payslipFileManager.save(payslips); +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.h index 7f43806..6d1e5cc 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.h @@ -4,9 +4,24 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once +#include +#include +#include"DataStore.h" + +using payslipMap = std::map; + class PayslipManagementService { -}; - +private: + DataStore& m_dataStore; +public: + PayslipManagementService() : m_dataStore(DataStore::getInstance()) {}; + void updateSalary(const std::string&, double, double, double, double, double); + void generatePayslips(); + std::pairgetPayslipForMonth(const std::string&, int, int); + void loadPayrolls(); + void savePayrolls(); + void loadPayslips(); + void savePayslips(); +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.cpp index 9e0ef96..3fb9113 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #include "TalentAcquisitionManagementService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.h index ed0dd32..c120c72 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/TalentAcquisitionManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once class TalentAcquisitionManagementService { diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.cpp index 8b13b81..5db2995 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #include "TeamManagementService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.h index 21275da..eabb859 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/TeamManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once class TeamManagementService { diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.cpp b/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.cpp index bc995f9..0325609 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.cpp @@ -4,5 +4,4 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #include "TicketManagementService.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.h b/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.h index 8a38d98..caa6338 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.h +++ b/Trenser.Zenvy/Trenser.Zenvy/services/TicketManagementService.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 30-Mar-2026 */ - #pragma once class TicketManagementService { diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/AuthorizationHelper.cpp b/Trenser.Zenvy/Trenser.Zenvy/utilities/AuthorizationHelper.cpp new file mode 100644 index 0000000..d021692 --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/AuthorizationHelper.cpp @@ -0,0 +1 @@ +#include "AuthorizationHelper.h" diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/AuthorizationHelper.h b/Trenser.Zenvy/Trenser.Zenvy/utilities/AuthorizationHelper.h new file mode 100644 index 0000000..9f5690f --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/AuthorizationHelper.h @@ -0,0 +1,67 @@ +/* + * File: AuthorizationHelper.h + * Description : Provides utility functions to check and enforce authorization + * based on allowed employee types. + * Author : Trenser + * Created : 07-Apr-2026 + */ +#pragma once +#include +#include "Enums.h" + +namespace util +{ + /* + * Function: isAuthorized + * Description: Checks if the current employee type matches the specified allowed type. + * Parameters: + * current - the employee type of the current user + * first - the allowed employee type to compare against + * Returns: + * bool - true if current matches the allowed type, false otherwise + */ + inline bool isAuthorized(Enums::EmployeeType current, Enums::EmployeeType first) + { + return current == first; + } + + /* + * Function: isAuthorized + * Description: Checks if the current employee type matches any of the specified allowed types. + * Parameters: + * current - the employee type of the current user + * first - the first allowed employee type + * rest - additional allowed employee types + * Returns: + * bool - true if current matches any of the allowed types, false otherwise + */ + template + inline bool isAuthorized(Enums::EmployeeType current, Enums::EmployeeType first, + Rest... rest) + { + if (current == first) + { + return true; + } + return isAuthorized(current, rest...); + } + + /* + * Function: enforceAuthorization + * Description: Enforces authorization by checking if the current employee type + * is among the allowed types. + * Parameters: + * current - the employee type of the current user + * alloweds - one or more allowed employee types + * Returns: + * void - throws runtime_error if current is not authorized + */ + template + inline void enforceAuthorization(Enums::EmployeeType current, Allowed... allowed) + { + if (!isAuthorized(current, allowed...)) + { + throw std::runtime_error("You are unauthorized to perform this operation!"); + } + } +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/Enums.h b/Trenser.Zenvy/Trenser.Zenvy/utilities/Enums.h index 0d5111b..1bef70f 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/Enums.h +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/Enums.h @@ -6,26 +6,28 @@ */ #pragma once +#include namespace Enums { - enum class AccountStatus + enum class AccountStatus { ACTIVE, INACTIVE }; - enum class TeamStatus + enum class TeamStatus { IN_TEAM, NOT_IN_TEAM }; - enum class CandidateStatus + enum class CandidateStatus { PENDING, SHORTLISTED, - REJECTED + REJECTED, + HIRED }; enum class NotificationStatus @@ -82,7 +84,7 @@ namespace Enums { GENERAL, IT, FINANCE, - TAG, + TALENT_ACQUISITION, HR, TEAM, ADMIN, @@ -96,4 +98,333 @@ namespace Enums { USER_NOT_FOUND, INVALID_PASSWORD }; -} + + enum class Month + { + JANUARY, + FEBRUARY, + MARCH, + APRIL, + MAY, + JUNE, + JULY, + AUGUST, + SEPTEMBER, + OCTOBER, + NOVEMBER, + DECEMBER, + INVALID + }; + + /* + * Function: getAccountStatusString + * Description: Converts AccountStatus enum value to string. + * Parameters: + * status - account status enum + * Returns: + * std::string - string representation of status + */ + inline std::string getAccountStatusString(AccountStatus status) + { + switch (status) + { + case AccountStatus::ACTIVE: + return "ACTIVE"; + case AccountStatus::INACTIVE: + return "INACTIVE"; + default: + return "UNKNOWN"; + } + } + + /* + * Function: getEmployeeTypeString + * Description: Converts EmployeeType enum value to string. + * Parameters: + * type - employee type enum + * Returns: + * std::string - string representation of employee type + */ + inline std::string getEmployeeTypeString(EmployeeType type) + { + switch (type) + { + case EmployeeType::GENERAL: + return "GENERAL"; + case EmployeeType::IT: + return "IT"; + case EmployeeType::FINANCE: + return "FINANCE"; + case EmployeeType::TALENT_ACQUISITION: + return "TALENT_ACQUISITION"; + case EmployeeType::HR: + return "HR"; + case EmployeeType::TEAM: + return "TEAM"; + case EmployeeType::ADMIN: + return "ADMIN"; + case EmployeeType::INVALID: + return "INVALID"; + default: + return "UNKNOWN"; + } + } + + /* + * Function: getTeamStatusString + * Description: Converts TeamStatus enum value to string. + * Parameters: + * status - team status enum + * Returns: + * std::string - string representation of team status + */ + inline std::string getTeamStatusString(TeamStatus status) + { + switch (status) + { + case TeamStatus::IN_TEAM: + return "IN_TEAM"; + case TeamStatus::NOT_IN_TEAM: + return "NOT_IN_TEAM"; + default: + return "UNKNOWN"; + } + } + + /* + * Function: getEmployeeDesignationString + * Description: Converts EmployeeDesignation enum value to string. + * Parameters: + * designation - employee designation enum + * Returns: + * std::string - string representation of designation + */ + inline std::string getEmployeeDesignationString(EmployeeDesignation designation) + { + switch (designation) + { + case EmployeeDesignation::JUNIOR: + return "JUNIOR"; + case EmployeeDesignation::SENIOR: + return "SENIOR"; + case EmployeeDesignation::TEAM_LEAD: + return "TEAM_LEAD"; + case EmployeeDesignation::INVALID: + return "INVALID"; + default: + return "UNKNOWN"; + } + } + + /* + * Function: getCandidateStatusString + * Description: Converts CandidateStatus enum value to string. + * Parameters: + * status - candidate status enum + * Returns: + * std::string - string representation of candidate status + */ + inline std::string getCandidateStatusString(CandidateStatus status) + { + switch (status) + { + case CandidateStatus::PENDING: return "Pending"; + case CandidateStatus::SHORTLISTED: return "Shortlisted"; + case CandidateStatus::REJECTED: return "Rejected"; + default: return "Unknown"; + } + } + + /* + * Function: getMonthString + * Description: Converts Month enum value to month name. + * Parameters: + * month - month enum + * Returns: + * std::string - month name + */ + inline std::string getMonthString(Month month) + { + switch (month) + { + case Month::JANUARY: + return "January"; + case Month::FEBRUARY: + return "February"; + case Month::MARCH: + return "March"; + case Month::APRIL: + return "April"; + case Month::MAY: + return "May"; + case Month::JUNE: + return "June"; + case Month::JULY: + return "July"; + case Month::AUGUST: + return "August"; + case Month::SEPTEMBER: + return "September"; + case Month::OCTOBER: + return "October"; + case Month::NOVEMBER: + return "November"; + case Month::DECEMBER: + return "December"; + case Month::INVALID: + return "Invalid Month"; + default: + return "Unknown"; + } + } + + /* + * Function: getAccountStatus + * Description: Converts string to AccountStatus enum. + * Parameters: + * input - string representation of account status + * Returns: + * AccountStatus - enum value + */ + inline AccountStatus getAccountStatus(const std::string& input) + { + if (input == "ACTIVE") + { + return AccountStatus::ACTIVE; + } + if (input == "INACTIVE") + { + return AccountStatus::INACTIVE; + } + return AccountStatus::INACTIVE; + } + + /* + * Function: getEmployeeType + * Description: Converts string to EmployeeType enum. + * Parameters: + * input - string representation of employee type + * Returns: + * EmployeeType - enum value + */ + inline EmployeeType getEmployeeType(const std::string& input) + { + if (input == "GENERAL") + { + return EmployeeType::GENERAL; + } + if (input == "IT") + { + return EmployeeType::IT; + } + if (input == "FINANCE") + { + return EmployeeType::FINANCE; + } + if (input == "TALENT_ACQUISITION") + { + return EmployeeType::TALENT_ACQUISITION; + } + if (input == "HR") + { + return EmployeeType::HR; + } + if (input == "TEAM") + { + return EmployeeType::TEAM; + } + if (input == "ADMIN") + { + return EmployeeType::ADMIN; + } + return EmployeeType::INVALID; + } + + /* + * Function: getTeamStatus + * Description: Converts string to TeamStatus enum. + * Parameters: + * str - string representation of team status + * Returns: + * TeamStatus - enum value + */ + inline TeamStatus getTeamStatus(const std::string& str) + { + if (str == "IN_TEAM") + { + return TeamStatus::IN_TEAM; + } + if (str == "NOT_IN_TEAM") + { + return TeamStatus::NOT_IN_TEAM; + } + return TeamStatus::NOT_IN_TEAM; + } + + /* + * Function: getEmployeeDesignation + * Description: Converts string to EmployeeDesignation enum. + * Parameters: + * input - string representation of designation + * Returns: + * EmployeeDesignation - enum value + */ + inline EmployeeDesignation getEmployeeDesignation(const std::string& input) + { + if (input == "JUNIOR") + { + return EmployeeDesignation::JUNIOR; + } + if (input == "SENIOR") + { + return EmployeeDesignation::SENIOR; + } + if (input == "TEAM_LEAD") + { + return EmployeeDesignation::TEAM_LEAD; + } + return EmployeeDesignation::INVALID; + } + + /* + * Function: getMonth + * Description: Converts integer to Month enum. + * Parameters: + * inputMonth - month number (1–12) + * Returns: + * Month - enum value + */ + inline Month getMonth(const int inputMonth) + { + switch (inputMonth) + { + case 1: + return Month::JANUARY; + case 2: + return Month::FEBRUARY; + case 3: + return Month::MARCH; + case 4: + return Month::APRIL; + case 5: + return Month::MAY; + case 6: + return Month::JUNE; + case 7: + return Month::JULY; + case 8: + return Month::AUGUST; + case 9: + return Month::SEPTEMBER; + case 10: + return Month::OCTOBER; + case 11: + return Month::NOVEMBER; + case 12: + return Month::DECEMBER; + default: + return Month::INVALID; + } + } + +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/InputHelper.h b/Trenser.Zenvy/Trenser.Zenvy/utilities/InputHelper.h index 5de0e35..eb23b24 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/InputHelper.h +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/InputHelper.h @@ -4,7 +4,6 @@ * Author: Smitha * Created: 08-Apr-2026 */ - #pragma once #include #include @@ -21,7 +20,6 @@ namespace util * Returns: * void - throws runtime_error if input is invalid */ - template inline void read(T& value) { @@ -41,7 +39,6 @@ namespace util * Returns: * void - no return value */ - inline void read(std::string& value) { std::getline(std::cin >> std::ws, value); @@ -53,9 +50,9 @@ namespace util * Parameters: None * Returns: void - no return value */ - inline void pressEnter() { + std::cout << std::endl; system("pause"); } } \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.cpp b/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.cpp index ce37ac4..e113f4f 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.cpp @@ -4,7 +4,6 @@ * Author: Trenser * Created: 01-04-2026 */ - #include "outputHelper.h" /* @@ -14,7 +13,6 @@ * Returns: * void - no return value */ - void util::clear() { std::cout << "\x1B[2J\x1B[H" << std::flush; diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.h b/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.h index 08a5b5f..0c17c57 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.h +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/OutputHelper.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 01-04-2026 */ - #pragma once #include diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.cpp b/Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.cpp new file mode 100644 index 0000000..2f32a39 --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.cpp @@ -0,0 +1,29 @@ +/* + * File: StringHelper.cpp + * Description: Provides functions to help with string manipulation. + * Author: Trenser + * Created: 10-04-2026 +*/ +#include "StringHelper.h" +#include + +/* + * Function: extractNumber + * Description: Extracts and returns the numeric value formed by digits in the input string. + * Parameters: + * input - string containing numeric and non-numeric characters + * Returns: + * int - number extracted from the input string + */ +int util::extractNumber(const std::string& input) +{ + int result = 0; + for (char character : input) + { + if (std::isdigit(static_cast(character))) + { + result = result * 10 + (character - '0'); + } + } + return result; +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.h b/Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.h new file mode 100644 index 0000000..cc6e74a --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.h @@ -0,0 +1,13 @@ +/* + * File: StringHelper.h + * Description: Provides functions to help with string manipulation. + * Author: Trenser + * Created: 10-04-2026 +*/ +#pragma once +#include + +namespace util +{ + int extractNumber(const std::string&); +} diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.cpp b/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.cpp index 3a51132..ba581db 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.cpp @@ -6,21 +6,19 @@ * Author: Trenser * Created: 01-Apr-2026 */ - #include #include #include #include "Timestamp.h" -/* -* Function: Timestamp -* Description: Default constructor that initializes the timestamp to the current system time. -* Parameters: -* None -* Returns: -* Timestamp object -*/ - + /* + * Function: Timestamp + * Description: Default constructor that initializes the timestamp to the current system time. + * Parameters: + * None + * Returns: + * Timestamp object + */ util::Timestamp::Timestamp() { m_time = std::time(nullptr); @@ -34,7 +32,6 @@ util::Timestamp::Timestamp() * Returns: * Timestamp object */ - util::Timestamp::Timestamp(std::time_t timeValue) { m_time = timeValue; @@ -50,7 +47,6 @@ util::Timestamp::Timestamp(std::time_t timeValue) * Throws: * runtime_error if the string format is invalid */ - util::Timestamp util::Timestamp::fromString(const std::string& timeString) { std::tm timeStruct = {}; @@ -72,7 +68,6 @@ util::Timestamp util::Timestamp::fromString(const std::string& timeString) * Returns: * string - formatted as "YYYY-MM-DD HH:MM:SS" */ - std::string util::Timestamp::toString() const { std::tm timeStruct = {}; @@ -91,7 +86,6 @@ std::string util::Timestamp::toString() const * Returns: * double - duration in seconds */ - double util::Timestamp::getDurationInSeconds(const Timestamp& startTimestamp, const Timestamp& endTimestamp) { return std::difftime(endTimestamp.m_time, startTimestamp.m_time); @@ -105,7 +99,6 @@ double util::Timestamp::getDurationInSeconds(const Timestamp& startTimestamp, co * Returns: * int - date as YYYYMMDD */ - int util::Timestamp::getDateAsInt() const { std::tm timeStruct{}; @@ -116,6 +109,51 @@ int util::Timestamp::getDateAsInt() const return year * 10000 + month * 100 + day; } +/* +* Function: getMonth +* Description: Extracts the month value from the timestamp. +* Parameters: +* None +* Returns: +* int - month value (1 to 12) +*/ +int util::Timestamp::getMonth() const +{ + std::tm timeStruct{}; + localtime_s(&timeStruct, &m_time); + return timeStruct.tm_mon + 1; +} + +/* +* Function: getYear +* Description: Extracts the year value from the timestamp. +* Parameters: +* None +* Returns: +* int - year value +*/ +int util::Timestamp::getYear() const +{ + std::tm timeStruct{}; + localtime_s(&timeStruct, &m_time); + return timeStruct.tm_year + 1900; +} + +/* +* Function: getDay +* Description: Extracts the day value from the timestamp. +* Parameters: +* None +* Returns: +* int - day of the month +*/ +int util::Timestamp::getDay() const +{ + std::tm timeStruct{}; + localtime_s(&timeStruct, &m_time); + return timeStruct.tm_mday; +} + /* * Function: getDurationInMinutes * Description: Calculates the duration between two timestamps in minutes. @@ -125,7 +163,6 @@ int util::Timestamp::getDateAsInt() const * Returns: * double - duration in minutes */ - double util::Timestamp::getDurationInMinutes(const Timestamp& startTimestamp, const Timestamp& endTimestamp) { return getDurationInSeconds(startTimestamp, endTimestamp) / 60.0; @@ -140,7 +177,6 @@ double util::Timestamp::getDurationInMinutes(const Timestamp& startTimestamp, co * Returns: * double - duration in hours */ - double util::Timestamp::getDurationInHours(const Timestamp& startTimestamp, const Timestamp& endTimestamp) { return getDurationInSeconds(startTimestamp, endTimestamp) / 3600.0; @@ -154,7 +190,6 @@ double util::Timestamp::getDurationInHours(const Timestamp& startTimestamp, cons * Returns: * bool - true if current timestamp is earlier */ - bool util::Timestamp::operator<(const Timestamp& other) const { return m_time < other.m_time; @@ -168,7 +203,6 @@ bool util::Timestamp::operator<(const Timestamp& other) const * Returns: * bool - true if current timestamp is later */ - bool util::Timestamp::operator>(const Timestamp& other) const { return m_time > other.m_time; @@ -182,7 +216,6 @@ bool util::Timestamp::operator>(const Timestamp& other) const * Returns: * bool - true if current timestamp is earlier or equal */ - bool util::Timestamp::operator<=(const Timestamp& other) const { return m_time <= other.m_time; @@ -196,7 +229,6 @@ bool util::Timestamp::operator<=(const Timestamp& other) const * Returns: * bool - true if current timestamp is later or equal */ - bool util::Timestamp::operator>=(const Timestamp& other) const { return m_time >= other.m_time; @@ -210,8 +242,7 @@ bool util::Timestamp::operator>=(const Timestamp& other) const * Returns: * bool - true if both timestamps are equal */ - bool util::Timestamp::operator==(const Timestamp& other) const { return m_time == other.m_time; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.h b/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.h index ace001a..56a6a0b 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.h +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/Timestamp.h @@ -6,7 +6,6 @@ * Author: Trenser * Created: 01-Apr-2026 */ - #pragma once #include #include @@ -26,6 +25,9 @@ namespace util static double getDurationInMinutes(const Timestamp&, const Timestamp&); static double getDurationInSeconds(const Timestamp&, const Timestamp&); int getDateAsInt() const; + int getMonth() const; + int getYear() const; + int getDay() const; bool operator>(const Timestamp&) const; bool operator<(const Timestamp&) const; bool operator>=(const Timestamp&) const; diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.cpp b/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.cpp index 8510bdf..5b1631c 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.cpp @@ -8,17 +8,17 @@ #include #include #include "Validator.h" +#include "Employee.h" #include "ApplicationConfig.h" - /* - * Function: isPhoneNumberValid - * Description: Validates whether the given string is a valid phone number. - * Parameters: - * phoneNumber - string containing the phone number to validate - * Returns: - * bool - true if the phone number is valid (10 digits, all numeric), false otherwise - */ - +/* + * Function: isPhoneNumberValid + * Description: Validates whether the given string is a valid phone number. + * Parameters: + * phoneNumber - string containing the phone number to validate + * Returns: + * bool - true if the phone number is valid (10 digits, all numeric), false otherwise + */ bool util::isPhoneNumberValid(const std::string& phoneNumber) { if (phoneNumber.size() != 10) { @@ -40,10 +40,12 @@ bool util::isPhoneNumberValid(const std::string& phoneNumber) { * Returns: * bool - true if the email contains exactly one '@' character and is not at the start or end, false otherwise */ - bool util::isEmailValid(const std::string& email) { size_t index = email.find('@'); - if (index == std::string::npos) return false; + if (index == std::string::npos) + { + return false; + } if (email.find('@', index + 1) != std::string::npos) { return false; @@ -68,7 +70,6 @@ bool util::isEmailValid(const std::string& email) { * - Must contain at least one uppercase letter, one lowercase letter, one digit, and one special character * - Must not contain whitespace */ - bool util::isPasswordValid(const std::string& password) { if (password == Config::Authentication::DEFAULT_PASSWORD) @@ -107,3 +108,90 @@ bool util::isPasswordValid(const std::string& password) } return hasUpper && hasLower && hasDigit && hasSpecial; } + +/* + * Function: hasActiveEmployeeOfType + * Description: Checks whether there is any active employee of the given employee type. + * Parameters: + * employeeType - the type of employee to check against + * employees - map of employee ID to Employee* objects + * Returns: + * bool - true if an active employee of the given type exists, otherwise false + */ +bool util::hasActiveEmployeeOfType(Enums::EmployeeType employeeType, const std::map& employees) +{ + for (const auto& employeePair : employees) + { + const auto& employee = employeePair.second; + if (employee->getEmployeeType() == employeeType && employee->getEmployeeAccountStatus() == Enums::AccountStatus::ACTIVE) + { + return true; + } + } + return false; +} + +/* + * Function: isEmailDuplicate + * Description: Checks if an email already exists among the given employees. + * Parameters: + * email - the email address to check + * employees - map of employee ID to Employee* objects + * Returns: + * bool - true if a duplicate email is found, otherwise false + */ +bool util::isEmailDuplicate(const std::string& email, const std::map& employees) +{ + for (const auto& employeePair : employees) + { + const auto& employee = employeePair.second; + if (employee->getEmployeeEmail() == email) + { + return true; + } + } + return false; +} + +/* + * Function: isPhoneDuplicate + * Description: Checks if a phone number already exists among the given employees. + * Parameters: + * phone - the phone number to check + * employees - map of employee ID to Employee* objects + * Returns: + * bool - true if a duplicate phone number is found, otherwise false + */ +bool util::isPhoneDuplicate(const std::string& phone, const std::map& employees) +{ + for (const auto& employeePair : employees) + { + const auto& employee = employeePair.second; + if (employee->getEmployeePhone() == phone) + { + return true; + } + } + return false; +} + +/* + * Function: isPhoneDuplicate (overloaded) + * Description: Checks if a phone number already exists in a vector of employees. + * Parameters: + * phone - the phone number to check + * employees - vector of Employee* pointers + * Returns: + * bool - true if a duplicate phone number is found, otherwise false + */ +bool util::isPhoneDuplicate(const std::string& phone, const std::vector& employees) +{ + for (const auto& employee : employees) + { + if (employee->getEmployeePhone() == phone) + { + return true; + } + } + return false; +} diff --git a/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.h b/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.h index 3710604..eaef165 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.h +++ b/Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.h @@ -4,15 +4,24 @@ * Author: Trenser * Created: 01-Apr-2026 */ - #pragma once #include +#include +#include +#include #include #include +#include "Enums.h" + +class Employee; namespace util { bool isPhoneNumberValid(const std::string&); bool isEmailValid(const std::string&); bool isPasswordValid(const std::string&); + bool hasActiveEmployeeOfType(Enums::EmployeeType, const std::map&); + bool isEmailDuplicate(const std::string&, const std::map&); + bool isPhoneDuplicate(const std::string&, const std::map&); + bool isPhoneDuplicate(const std::string&, const std::vector&); } \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.cpp index 91a2445..c8b0019 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.cpp @@ -4,11 +4,11 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include "AdminMenu.h" #include"InputHelper.h" #include"OutputHelper.h" +#include "MenuHelper.h" /* * Function: AdminMenu::run @@ -28,7 +28,7 @@ void AdminMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - HR Management System\n1. Create HRManager\n2. Create Employee\n3. View Employee\n4. Deactivate Employee\n5. Logout\nEnter your Choice: "; + std::cout << "Admin Menu\n1. Create User\n2. View Employees\n3. Deactivate Employee\n4. Search Employee\n5. Update Profile\n6. Update Designation \n7. Add Shortlisted Candidate As Employee\n8. Logout\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -56,22 +56,32 @@ bool AdminMenu::handleOperation(int choice) { switch (choice) { - /*case 1: - m_zenvyController.createHRManager(); + case 1: + createEmployee(m_zenvyController); break; case 2: - m_zenvyController.createEmployee(); + viewEmployees(m_zenvyController); break; case 3: - m_zenvyController.viewEmployee(); + deactivateEmployee(m_zenvyController); break; case 4: - m_zenvyController.deactivateEmployee(); - break;*/ + searchEmployee(m_zenvyController); + break; case 5: + updateProfile(m_zenvyController); + break; + case 6: + updateDesignation(m_zenvyController); + break; + case 7: + addShortlistedCandidateAsEmployee(m_zenvyController); + break; + case 8: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; } \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.h index 6144d4e..39fda7c 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include"ZenvyController.h" @@ -16,5 +15,4 @@ public: AdminMenu() :m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.cpp index 4a0dd07..2a81bfc 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.cpp @@ -4,11 +4,12 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include +#include #include "EmployeeMenu.h" -#include"InputHelper.h" -#include"OutputHelper.h" +#include "InputHelper.h" +#include "OutputHelper.h" +#include "MenuHelper.h" /* * Function: EmployeeMenu::run @@ -27,7 +28,7 @@ void EmployeeMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. Raise Ticke\n5. View Ticket\n6. View Ticket History\n7. View Employees\n8. Search Employee\n9. View Team Members\n10. Book Meeting Room\n11. View Booking History\n12. View Notification\n13. View Announcements\n14. Logout\nEnter your Choice: "; + std::cout << "Employee Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. Raise Ticket\n5. View Ticket\n6. View Ticket History\n7. View Employees\n8. Search Employee\n9. View Team Members\n10. Book Meeting Room\n11. View Booking History\n12. View Notifications\n13. View Announcements\n14. Update Profile\n15. View Profile\n16. Exit\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -55,49 +56,29 @@ bool EmployeeMenu::handleOperation(int choice) { switch (choice) { - /*case 1: - m_zenvyController.applyLeave(); - break; case 2: - m_zenvyController.viewPayslip(); + viewPayslip(m_zenvyController); break; case 3: - m_zenvyController.viewPayslipHistory(); - break; - case 4 : - m_zenvyController.raiseTicket(); - break; - case 5 : - m_zenvyController.viewTicket(); - break; - case 6: - m_zenvyController.viewTicketHistory(); + viewPayslipHistory(m_zenvyController); break; case 7: - m_zenvyController.viewEmployees(); + viewEmployees(m_zenvyController); break; case 8: - m_zenvyController.searchEmployee(); + searchEmployee(m_zenvyController); break; - case 9: - m_zenvyController.viewTeamMembers(); - break; - case 10: - m_zenvyController.bookMeetingRoom(); - break; - case 11: - m_zenvyController.viewBookingHistory(); - break; - case 12: - m_zenvyController.viewNotifications(); - break; - case 13: - m_zenvyController.viewAnnouncements(); - break;*/ case 14: + updateProfile(m_zenvyController); + break; + case 15: + viewProfile(m_zenvyController); + break; + case 16: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; } \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.h index 907ab82..579903e 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.h @@ -4,17 +4,15 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include"ZenvyController.h" class EmployeeMenu { private: - ZenvyController m_zenvyController; + ZenvyController* m_zenvyController; public: EmployeeMenu() : m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.cpp index 4503969..b301167 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.cpp @@ -4,11 +4,12 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include "FinanceExecutiveMenu.h" -#include"InputHelper.h" -#include"OutputHelper.h" +#include "InputHelper.h" +#include "OutputHelper.h" +#include "MenuHelper.h" +#include "Timestamp.h" /* * Function: FinanceExecutiveMenu::run @@ -27,7 +28,7 @@ void FinanceExecutiveMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Resolve Ticket\n9. Generate Payslip\n10. Update Payroll\n11. Logout\nEnter your Choice: "; + std::cout << "Finance Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notifications\n7. View Announcements\n8. Resolve Ticket\n9. Generate Payslips\n10. Update Payroll\n11. Update Profile\n12. View Profile \n13. Logout\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -42,6 +43,38 @@ void FinanceExecutiveMenu::run() } } +void FinanceExecutiveMenu::updatePayroll() +{ + std::string employeeId; + double basicSalary, houseRentAllowance, foodAllowance, employeePFContribution, employerPFContribution; + employeeId = selectEmployeeId(m_zenvyController->getEmployees()); + util::clear(); + if (employeeId != "") { + std::cout << "Enter the New Basic Salary: "; + util::read(basicSalary); + std::cout << "Enter the New House Rent Allowance: "; + util::read(houseRentAllowance); + std::cout << "Enter the New Food Allowance: "; + util::read(foodAllowance); + std::cout << "Enter the New EmployeePFContribution: "; + util::read(employeePFContribution); + std::cout << "Enter the New EmployerPFContribution: "; + util::read(employerPFContribution); + m_zenvyController->updateSalary(employeeId, basicSalary, houseRentAllowance, foodAllowance, employeePFContribution, employerPFContribution); + std::cout << "Payroll Updated"; + util::pressEnter(); + } +} + +void FinanceExecutiveMenu::generatePayslips() +{ + util::Timestamp currentTimestamp; + util::clear(); + m_zenvyController->generatePayslips(); + std::cout << "Generated payslips for the month of " << currentTimestamp.getMonth() << "-" << currentTimestamp.getYear() << " successfully."; + util::pressEnter(); +} + /* * Function: FinanceExecutiveMenu::handleOperation * Description: Handles the finance executive’s menu choice and executes the corresponding action @@ -55,40 +88,35 @@ bool FinanceExecutiveMenu::handleOperation(int choice) { switch (choice) { - /*case 1: - m_zenvyController.applyLeave(); - break; case 2: - m_zenvyController.viewPayslip(); + viewPayslip(m_zenvyController); break; case 3: - m_zenvyController.viewPayslipHistory(); + viewPayslipHistory(m_zenvyController); break; case 4: - m_zenvyController.viewEmployees(); + viewEmployees(m_zenvyController); break; case 5: - m_zenvyController.searchEmployee(); - break; - case 6: - m_zenvyController.viewNotifications(); - break; - case 7: - m_zenvyController.viewAnnouncements(); - break; - case 8: - m_zenvyController.resolveTicket(); + searchEmployee(m_zenvyController); break; case 9: - m_zenvyController.generatePayslip(); + generatePayslips(); break; case 10: - m_zenvyController.updatePayroll(); - break;*/ + updatePayroll(); + break; case 11: + updateProfile(m_zenvyController); + break; + case 12: + viewProfile(m_zenvyController); + break; + case 13: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.h index 98dd6c8..69097da 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.h @@ -4,8 +4,11 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once +#include +#include +#include +#include #include"ZenvyController.h" class FinanceExecutiveMenu @@ -16,5 +19,6 @@ public: FinanceExecutiveMenu() : m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - + void updatePayroll(); + void generatePayslips(); +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.cpp index dff562a..d72e29f 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.cpp @@ -4,11 +4,11 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include "HRManagerMenu.h" -#include"InputHelper.h" -#include"OutputHelper.h" +#include "InputHelper.h" +#include "OutputHelper.h" +#include "MenuHelper.h" /* * Function: HRManagerMenu::run @@ -27,7 +27,7 @@ void HRManagerMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create Employee\n9. Regularize Attendance\n10. Update Leave Request\n11. Register CandidateAsEmployee\n12. Logout\nEnter your Choice: "; + std::cout << "HR Manager Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notifications\n7. View Announcements\n8. Create Employee\n9. Regularize Attendance\n10. Update Leave Request\n11. Update Profile\n12. Deactivate Employee\n13. View Profile\n14. Update Designation\n15. Add Shortlisted Candidate as Employee\n16. Logout\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -55,43 +55,41 @@ bool HRManagerMenu::handleOperation(int choice) { switch (choice) { - //case 1: - // m_zenvyController.applyLeave(); - // break; - //case 2: - // m_zenvyController.viewPayslip(); - // break; - //case 3: - // m_zenvyController.viewPayslipHistory(); - // break; - //case 4: - // m_zenvyController.viewEmployees(); - // break; - //case 5: - // m_zenvyController.searchEmployee(); - // break; - //case 6: - // m_zenvyController.viewNotifications(); - // break; - //case 7: - // m_zenvyController.viewAnnouncements(); - // break; - //case 8: - // m_zenvyController.createEmployee(); - // break; - //case 9: - // m_zenvyController.regularizeAttenance(); - // break; - //case 10: - // m_zenvyController.updateLeaveRequest(); - // break; - //case 11: - // m_zenvyController.registercandidateAsEmployee(); - // break; + case 2: + viewPayslip(m_zenvyController); + break; + case 3: + viewPayslipHistory(m_zenvyController); + break; + case 4: + viewEmployees(m_zenvyController); + break; + case 5: + searchEmployee(m_zenvyController); + break; + case 8: + createEmployee(m_zenvyController); + break; + case 11: + updateProfile(m_zenvyController); + break; case 12: + deactivateEmployee(m_zenvyController); + break; + case 13: + viewProfile(m_zenvyController); + break; + case 14: + updateDesignation(m_zenvyController); + break; + case 15: + addShortlistedCandidateAsEmployee(m_zenvyController); + break; + case 16: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.h index ed7c5fa..b455bc9 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include"ZenvyController.h" @@ -16,5 +15,4 @@ public: HRManagerMenu() : m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.cpp index b415d57..ec94afd 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.cpp @@ -4,11 +4,11 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include "ITExecutiveMenu.h" -#include"InputHelper.h" -#include"OutputHelper.h" +#include "InputHelper.h" +#include "OutputHelper.h" +#include "MenuHelper.h" /* * Function: ITExecutiveMenu::run @@ -27,7 +27,7 @@ void ITExecutiveMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Resolve Ticket\n9. Logout\nEnter your Choice: "; + std::cout << "IT Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notifications\n7. View Announcements\n8. Resolve Ticket\n9. Update Profile\n10. View Profile\n11. Logout\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -55,34 +55,29 @@ bool ITExecutiveMenu::handleOperation(int choice) { switch (choice) { - /*case 1: - m_zenvyController.applyLeave(); - break; case 2: - m_zenvyController.viewPayslip(); + viewPayslip(m_zenvyController); break; case 3: - m_zenvyController.viewPayslipHistory(); + viewPayslipHistory(m_zenvyController); break; case 4: - m_zenvyController.viewEmployees(); + viewEmployees(m_zenvyController); break; case 5: - m_zenvyController.searchEmployee(); + searchEmployee(m_zenvyController); break; - case 6: - m_zenvyController.viewNotifications(); - break; - case 7: - m_zenvyController.viewAnnouncements(); - break; - case 8: - m_zenvyController.resolveTicket(); - break;*/ case 9: + updateProfile(m_zenvyController); + break; + case 10: + viewProfile(m_zenvyController); + break; + case 11: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.h index 5d32d37..a1817cd 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include"ZenvyController.h" @@ -16,5 +15,4 @@ public: ITExecutiveMenu() : m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.cpp new file mode 100644 index 0000000..95d10d9 --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.cpp @@ -0,0 +1,253 @@ +/* + * File: MenuHelper.cpp + * Description: Inline functions and utilities for employee management, + * including profile handling, payslip viewing, search, + * and employee activation/deactivation. + * Author: Trenser + * Created: 08-Apr-2026 + */ +#include +#include "MenuHelper.h" + +/* + * Function: getEmployeeType + * Description: Retrieves a valid employee type based on the authority of the current user + * Parameters: + * employeeType - the type of the employee requesting to create another employee + * Returns: + * Enums::EmployeeType - selected employee type or INVALID if choice is invalid + */ +static Enums::EmployeeType getEmployeeType(Enums::EmployeeType employeeType) +{ + int choice; + util::clear(); + static const std::map> employeeTypeOptions = { + { Enums::EmployeeType::ADMIN, { + Enums::EmployeeType::HR, + Enums::EmployeeType::IT, + Enums::EmployeeType::TEAM, + Enums::EmployeeType::FINANCE, + Enums::EmployeeType::TALENT_ACQUISITION, + Enums::EmployeeType::GENERAL + }}, + { Enums::EmployeeType::HR, { + Enums::EmployeeType::IT, + Enums::EmployeeType::TEAM, + Enums::EmployeeType::FINANCE, + Enums::EmployeeType::TALENT_ACQUISITION, + Enums::EmployeeType::GENERAL + }} + }; + static const std::map labels = { + { Enums::EmployeeType::HR, "HR Employee" }, + { Enums::EmployeeType::IT, "IT Executive" }, + { Enums::EmployeeType::TEAM, "Team Executive" }, + { Enums::EmployeeType::FINANCE, "Finance Executive" }, + { Enums::EmployeeType::TALENT_ACQUISITION, "Talent Executive" }, + { Enums::EmployeeType::GENERAL, "General Employee" } + }; + auto employeeOptionsIterator = employeeTypeOptions.find(employeeType); + if (employeeOptionsIterator == employeeTypeOptions.end()) + { + throw std::runtime_error("You do not have the authority to create a new Employee!"); + } + const auto& options = employeeOptionsIterator->second; + std::cout << "Select Employee Type\n"; + for (int index = 0; index < options.size(); ++index) + { + std::cout << index + 1 << ". " << labels.at(options[index]) << "\n"; + } + std::cout << "Enter Choice: "; + util::read(choice); + if (choice >= 1 && choice <= options.size()) + { + return options[choice - 1]; + } + return Enums::EmployeeType::INVALID; +} + +/* + * Function: getEmployeeDesignation + * Description: Retrieves the designation (Senior or Junior) for a new employee + * Parameters: None + * Returns: + * Enums::EmployeeDesignation - selected designation or INVALID if choice is invalid + */ +static Enums::EmployeeDesignation getEmployeeDesignation() +{ + int choice; + util::clear(); + std::cout << "Select Employee Designation" + "\n1. SENIOR" + "\n2. JUNIOR" + "\nEnter Choice: "; + util::read(choice); + switch (choice) + { + case 1: + return Enums::EmployeeDesignation::SENIOR; + case 2: + return Enums::EmployeeDesignation::JUNIOR; + default: + return Enums::EmployeeDesignation::INVALID; + } +} + +/* + * Function: createEmployee + * Description: Creates a new employee record and adds it to the system + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +void createEmployee(ZenvyController* m_zenvyController) +{ + auto currentEmployee = m_zenvyController->getCurrentEmployee(); + Enums::EmployeeType employeeType = getEmployeeType(currentEmployee->getEmployeeType()); + Enums::EmployeeDesignation employeeDesignation = Enums::EmployeeDesignation::INVALID; + std::string name, email, phone; + switch (employeeType) + { + case Enums::EmployeeType::INVALID: + std::cout << "Invalid Choice"; + util::pressEnter(); + return; + case Enums::EmployeeType::GENERAL: + employeeDesignation = getEmployeeDesignation(); + if (employeeDesignation == Enums::EmployeeDesignation::INVALID) + { + std::cout << "Invalid Choice"; + util::pressEnter(); + return; + } + break; + } + std::cout << "Enter Name: "; + util::read(name); + std::cout << "Enter Email: "; + util::read(email); + std::cout << "Enter Phone: "; + util::read(phone); + m_zenvyController->createEmployee(employeeType, employeeDesignation, email, name, phone); + std::cout << "\nCreated Employee Successfully."; + util::pressEnter(); +} + +/* + * Function: updateDesignation + * Description: Updates the designation of an existing employee + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ + void updateDesignation(ZenvyController* m_zenvyController) +{ + std::string selectedEmployeeId = selectEmployeeId(m_zenvyController->getEmployees(Enums::EmployeeType::GENERAL)); + if (selectedEmployeeId.empty()) + { + return; + } + Enums::EmployeeDesignation designation = getEmployeeDesignation(); + if (m_zenvyController->updateDesignation(selectedEmployeeId, designation)) + { + std::cout << "Assigned Employee Role Successfully\n"; + util::pressEnter(); + } + else + { + std::cout << "Employee not found\n"; + util::pressEnter(); + } +} + + /* + * Function: displayCandidateDetails + * Description: Displays details of shortlisted candidates + * Parameters: + * shorlistedCandidates - vector of candidate pointers to display + * Returns: void + */ +void displayCandidateDetails(const std::vector shorlistedCandidates) +{ + util::clear(); + std::cout << std::left + << std::setw(10) << "Index" + << std::setw(10) << "ID" + << std::setw(20) << "Name" + << std::setw(15) << "Phone" + << std::setw(15) << "Qualification" + << std::setw(10) << "Status" + << std::endl; + int index = 0; + for (auto& candidate : shorlistedCandidates) + { + std::cout << std::left + << std::setw(10) << ++index + << std::setw(10) << candidate->getCandidateId() + << std::setw(20) << candidate->getCandidateName() + << std::setw(15) << candidate->getCandidatePhone() + << std::setw(15) << candidate->getCandidateQualification() + << std::setw(10) << Enums::getCandidateStatusString(candidate->getCandidateStatus()) + << std::endl; + } +} + +/* + * Function: addShortlistedCandidateAsEmployee + * Description: Converts a shortlisted candidate into an employee record + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +void addShortlistedCandidateAsEmployee(const ZenvyController* m_zenvyController) +{ + int index; + std::string name, email, phone; + util::clear(); + std::vector shortlistedCandidates = m_zenvyController->getShorlistedCandidates(); + if (shortlistedCandidates.empty()) + { + std::cout << "No candidates Found!"; + util::pressEnter(); + return; + } + displayCandidateDetails(shortlistedCandidates); + std::cout << "Enter the Index: "; + util::read(index); + auto currentEmployee = m_zenvyController->getCurrentEmployee(); + Enums::EmployeeType employeeType; + Enums::EmployeeDesignation employeeDesignation = Enums::EmployeeDesignation::INVALID; + if (index > 0 && index <= shortlistedCandidates.size()) + { + employeeType = getEmployeeType(currentEmployee->getEmployeeType()); + Candidate* candidate = shortlistedCandidates[index - 1]; + switch (employeeType) + { + case Enums::EmployeeType::INVALID: + std::cout << "Invalid Choice"; + util::pressEnter(); + return; + case Enums::EmployeeType::GENERAL: + employeeDesignation = getEmployeeDesignation(); + if (employeeDesignation == Enums::EmployeeDesignation::INVALID) + { + std::cout << "Invalid Choice"; + util::pressEnter(); + return; + } + break; + } + std::cout << "Enter email: "; + util::read(email); + name = candidate->getCandidateName(); + phone = candidate->getCandidatePhone(); + m_zenvyController->createEmployee(employeeType, employeeDesignation, email, name, phone); + candidate->setCandidateStatus(Enums::CandidateStatus::HIRED); + std::cout << "\nCreated Employee Successfully."; + util::pressEnter(); + } + else + { + throw std::runtime_error("Enter a valid Index."); + } +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.h b/Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.h new file mode 100644 index 0000000..1f892fb --- /dev/null +++ b/Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.h @@ -0,0 +1,435 @@ +/* + * File: MenuHelper.h + * Description: Inline functions and utilities for employee management, + * including profile handling, payslip viewing, search, + * and employee activation/deactivation. + * Author: Trenser + * Created: 08-Apr-2026 + */ +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include "Enums.h" +#include"InputHelper.h" +#include"OutputHelper.h" +#include "Employee.h" +#include "ZenvyController.h" +#include "MenuHelper.h" +#include "Validator.h" + +void createEmployee(ZenvyController* m_zenvyController); +void updateDesignation(ZenvyController* m_zenvyController); +void displayCandidateDetails(const std::vector shorlistedCandidates); +void addShortlistedCandidateAsEmployee(const ZenvyController* m_zenvyController); + +/* + * Function: viewPayslipHistory + * Description: Displays the payslip history of the current employee + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +inline void viewPayslipHistory(ZenvyController* m_zenvyController) +{ + auto& employeePayslips = m_zenvyController->getCurrentEmployee()->getEmployeePayslips(); + util::clear(); + if (employeePayslips.empty()) + { + std::cout << "No Payslips Generated"; + util::pressEnter(); + return; + } + std::cout << "Payslips\n" << std::endl; + std::cout << std::left + << std::setw(15) << "Date" + << std::setw(15) << "Payslip ID" + << std::setw(15) << "Employee ID" + << std::setw(12) << "Salary" + << std::setw(25) << "TimeStamp" + << std::endl; + for (const auto& payslip : employeePayslips) + { + std::ostringstream dateStream; + dateStream << payslip.second->getTimestamp().getYear() << " - " << Enums::getMonthString(Enums::getMonth(payslip.second->getTimestamp().getMonth())); + std::cout << std::left + << std::setw(15) << dateStream.str() + << std::setw(15) << payslip.first + << std::setw(15) << payslip.second->getEmployeeId() + << std::setw(12) << payslip.second->getSalary() + << std::setw(25) << payslip.second->getTimestamp().toString() + << std::endl; + } + util::pressEnter(); +} + +/* + * Function: viewProfile + * Description: Displays the profile details of the current employee + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +inline void viewProfile(ZenvyController* m_zenvyController) +{ + util::clear(); + const Employee* currentEmployee = m_zenvyController->getCurrentEmployee(); + if (currentEmployee) + { + std::cout << std::left + << "Employee ID: " << currentEmployee->getId() << std::endl + << "Name: " << currentEmployee->getEmployeeName() << std::endl + << "Role: " << Enums::getEmployeeTypeString(currentEmployee->getEmployeeType()) << std::endl + << "Email: " << currentEmployee->getEmployeeEmail() << std::endl + << "Phone: " << currentEmployee->getEmployeePhone() << std::endl; + if (currentEmployee->getEmployeeType() == Enums::EmployeeType::GENERAL) { + if (auto generalEmployee = dynamic_cast(currentEmployee)) + { + std::cout << "Designation: " << Enums::getEmployeeDesignationString(generalEmployee->getDesignation()) << std::endl; + } + } + std::cout << "Team ID: " << (currentEmployee->getEmployeeTeamId().empty() ? "NULL " : (currentEmployee->getEmployeeTeamId())) << std::endl + << "Team Status: " << Enums::getTeamStatusString(currentEmployee->getEmployeeTeamStatus()) << std::endl; + if (const auto& payroll = currentEmployee->getPayroll()) + { + std::cout << std::endl + << "Payroll Details" << std::endl + << "Payroll ID: " << payroll->getId() << std::endl + << "Basic Salary: " << payroll->getBasicSalary() << std::endl + << "Employee PF Contribution: " << payroll->getEmployeePFContribution() << std::endl + << "Employer PF Contribution: " << payroll->getEmployerPFContribution() << std::endl + << "Food Allowance: " << payroll->getFoodAllowance() << std::endl + << "House Rent Allowance: " << payroll->getHouseRentAllowance() << std::endl; + } + else + { + std::cout << "Unable to fetch the payroll details\n"; + } + util::pressEnter(); + } + else + { + throw std::runtime_error("Unexpected Error Occured"); + } +} + +/* + * Function: updateProfile + * Description: Allows the current employee to update their profile information + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +inline void updateProfile(ZenvyController* m_zenvyController) +{ + int choice; + std::string name, phone; + name = m_zenvyController->getCurrentEmployee()->getEmployeeName(); + phone = m_zenvyController->getCurrentEmployee()->getEmployeePhone(); + while (true) + { + util::clear(); + std::cout << "Please choose the information you want to update:\n" + "1. Name\n" + "2. Phone Number\n" + "3. Exit\n" + "Enter your choice: "; + util::read(choice); + switch (choice) + { + case 1: + std::cout << "Enter your updated Name: "; + util::read(name); + m_zenvyController->updateProfile(name, phone); + std::cout << "Profile Updated Successfully\n"; + util::pressEnter(); + break; + case 2: + std::cout << "Enter your updated phone Number: "; + util::read(phone); + if (!util::isPhoneNumberValid(phone)) + { + std::cout << "Error: Invalid Phone Number"; + util::pressEnter(); + } + if (util::isPhoneDuplicate(phone, m_zenvyController->getEmployees())) + { + std::cout << "Error: Duplicate Phone Number!"; + util::pressEnter(); + return; + } + m_zenvyController->updateProfile(name, phone); + std::cout << "Profile Updated Successfully\n"; + util::pressEnter(); + break; + case 3: + return; + default: + std::cout << "Enter a valid choice!" << std::endl; + break; + } + } +} + +/* + * Function: selectEmployeeId + * Description: Displays a list of employees and allows selection by index + * Parameters: + * allEmployees - vector of employee pointers to choose from + * Returns: + * string - selected employee ID + */ +inline std::string selectEmployeeId(const std::vector& allEmployees) +{ + int choice; + std::map employeeList; + int index = 0; + util::clear(); + if (allEmployees.empty()) + { + std::cout << "No employees found!"; + util::pressEnter(); + return ""; + } + std::cout << "Select the Employee\n"; + for (auto& currentEmployee : allEmployees) + { + if (currentEmployee->getEmployeeType() == Enums::EmployeeType::ADMIN) + { + continue; + } + employeeList[++index] = currentEmployee; + } + std::cout << std::left + << std::setw(10) << "Index" + << std::setw(15) << "Employee ID" + << std::setw(20) << "Name" + << std::setw(20) << "Employee Type" + << std::setw(20) << "Employee Designation" << std::endl; + for (const auto& employee : employeeList) + { + auto generalEmployee = dynamic_cast(employee.second); + std::cout << std::left + << std::setw(10) << employee.first + << std::setw(15) << employee.second->getId() + << std::setw(20) << employee.second->getEmployeeName() + << std::setw(20) << Enums::getEmployeeTypeString(employee.second->getEmployeeType()); + if (generalEmployee) + { + std::cout << std::left + << std::setw(20) << Enums::getEmployeeDesignationString(generalEmployee->getDesignation()) + << std::endl; + } + else + { + std::cout << std::left + << std::setw(20) << "NULL" + << std::endl; + } + } + std::cout << "Enter the Index: "; + util::read(choice); + auto employeeIterator = employeeList.find(choice); + if (employeeIterator != employeeList.end()) + { + return (employeeIterator->second->getId()); + } + else + { + throw std::runtime_error("Invalid Index"); + } +} + +/* + * Function: deactivateEmployee + * Description: Deactivates an employee based on selection + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +inline void deactivateEmployee(const ZenvyController* m_zenvyController) +{ + std::string selectedEmployeeId = selectEmployeeId(m_zenvyController->getEmployees()); + if (selectedEmployeeId.empty()) + { + return; + } + if (m_zenvyController->deactivateEmployee(selectedEmployeeId)) + { + std::cout << "Employee deactivated successfully\n"; + util::pressEnter(); + } + else + { + std::cout << "Employee not found\n"; + util::pressEnter(); + } +} + +/* + * Function: viewEmployees + * Description: Displays a list of all employees in the system + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +inline void viewEmployees(ZenvyController* m_zenvyController) +{ + util::clear(); + std::cout << "Employee List\n"; + auto employees = m_zenvyController->getEmployees(); + if (employees.empty()) + { + std::cout << "No employees found\n"; + util::pressEnter(); + return; + } + std::cout << std::left + << std::setw(15) << "Employee ID" + << std::setw(25) << "Name" + << std::setw(25) << "Role" + << std::setw(25) << "Email" + << std::setw(15) << "Phone" + << std::setw(10) << "TeamId" + << std::endl; + for (const auto& iterator : employees) + { + std::cout << std::left + << std::setw(15) << iterator->getId() + << std::setw(25) << iterator->getEmployeeName() + << std::setw(25) << Enums::getEmployeeTypeString(iterator->getEmployeeType()) + << std::setw(25) << iterator->getEmployeeEmail() + << std::setw(15) << iterator->getEmployeePhone() + << std::setw(10) << (iterator->getEmployeeTeamId().empty() ? "NULL" : iterator->getEmployeeTeamId()) + << std::endl; + } + util::pressEnter(); +} + +/* + * Function: searchEmployee + * Description: Searches for employees by name and displays matching results + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +inline void searchEmployee(ZenvyController* m_zenvyController) +{ + std::string name; + util::clear(); + std::cout << "Enter Employee Name: "; + util::read(name); + std::pair> searchResults = m_zenvyController->searchEmployee(name); + if (!(searchResults.second).empty()) + { + std::cout << std::left + << std::setw(10) << "ID" + << std::setw(20) << "Name" + << std::setw(25) << "Email" + << std::setw(15) << "Phone" + << std::setw(20) << "Type" + << std::setw(20) << "TeamStatus" + << std::setw(15) << "TeamID"; + if (searchResults.first == Enums::EmployeeType::FINANCE + || searchResults.first == Enums::EmployeeType::HR + || searchResults.first == Enums::EmployeeType::ADMIN) + { + std::cout << std::left + << std::setw(17) << "PayrollID" + << std::setw(20) << "BasicSalary" + << std::setw(15) << "EmployeePF" + << std::setw(15) << "EmployerPF" + << std::setw(15) << "FoodAllowance" + << std::setw(15) << "HouseRentAllowance"; + } + std::cout << std::endl; + for (const auto& employee : searchResults.second) + { + if (employee->getEmployeeAccountStatus() == Enums::AccountStatus::ACTIVE) + { + std::cout << std::left + << std::setw(10) << employee->getId() + << std::setw(20) << employee->getEmployeeName() + << std::setw(25) << employee->getEmployeeEmail() + << std::setw(15) << employee->getEmployeePhone() + << std::setw(20) << Enums::getEmployeeTypeString(employee->getEmployeeType()) + << std::setw(20) << Enums::getTeamStatusString(employee->getEmployeeTeamStatus()); + if (employee->getEmployeeTeamId() == "") + { + std::cout << std::setw(15) << "NULL"; + } + else + { + std::cout << std::setw(15) << employee->getEmployeeTeamId(); + } + if (searchResults.first == Enums::EmployeeType::FINANCE + || searchResults.first == Enums::EmployeeType::HR + || searchResults.first == Enums::EmployeeType::ADMIN) + { + std::cout << std::left + << std::setw(17) << employee->getPayroll()->getId() + << std::setw(20) << employee->getPayroll()->getBasicSalary() + << std::setw(15) << employee->getPayroll()->getEmployeePFContribution() + << std::setw(15) << employee->getPayroll()->getEmployerPFContribution() + << std::setw(15) << employee->getPayroll()->getFoodAllowance() + << std::setw(15) << employee->getPayroll()->getHouseRentAllowance(); + } + std::cout << std::endl; + } + } + } + else + { + std::cout << "No Employee found with this name" << std::endl; + } + util::pressEnter(); +} + +/* + * Function: viewPayslip + * Description: Displays the payslip of the current employee for a given month and year + * Parameters: + * m_zenvyController - pointer to the ZenvyController managing employees + * Returns: void + */ +inline void viewPayslip(ZenvyController* m_zenvyController) +{ + int year, month; + util::clear(); + std::cout << "Enter the year: "; + util::read(year); + std::cout << "Enter the month: "; + util::read(month); + auto employee = m_zenvyController->getCurrentEmployee(); + if (!employee) + { + std::cout << "No authenticated employee.\n"; + util::pressEnter(); + return; + } + auto result = m_zenvyController->getPayslipForMonth(employee->getId(), year, month); + auto payroll = result.first; + auto payslip = result.second; + if (payroll && payslip) + { + util::clear(); + std::cout << "Payslip for " << employee->getEmployeeName() << " (" << year << "-" << std::setw(2) << month << ")\n\n"; + std::cout << "Basic Salary : " << payroll->getBasicSalary() << "\n"; + std::cout << "House Rent Allowance : " << payroll->getHouseRentAllowance() << "\n"; + std::cout << "Food Allowance : " << payroll->getFoodAllowance() << "\n"; + std::cout << "Employee PF Contribution : " << payroll->getEmployeePFContribution() << "\n"; + std::cout << "Employer PF Contribution : " << payroll->getEmployerPFContribution() << "\n"; + std::cout << "----------------------------------------\n"; + std::cout << "Net Salary (after deductions): " << payslip->getSalary() << "\n"; + std::cout << "Generated on: " << payslip->getTimestamp().toString() << "\n"; + } + else + { + std::cout << "Payslip not available for " << year << "-" << month << ".\n"; + } + util::pressEnter(); +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.cpp index 250da5a..a4897f0 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.cpp @@ -4,11 +4,11 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include "TalentExecutiveMenu.h" -#include"InputHelper.h" -#include"OutputHelper.h" +#include "InputHelper.h" +#include "OutputHelper.h" +#include "MenuHelper.h" /* * Function: TalentExecutiveMenu::run @@ -27,7 +27,7 @@ void TalentExecutiveMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create New Job\n9. View Job Opening\n10. Add Candidate\n11. UpdateCandidate Status\n12. View Shortlisted Candidate\n13. Logout\nEnter your Choice: "; + std::cout << "Talent Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notifications\n7. View Announcements\n8. Create New Job\n9. View Job Opening\n10. Add Candidate\n11. Update Candidate Status\n12. View Shortlisted Candidate\n13. Update Profile\n14. View Profile\n15. Logout\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -55,46 +55,29 @@ bool TalentExecutiveMenu::handleOperation(int choice) { switch (choice) { - //case 1: - // m_zenvyController.applyLeave(); - // break; - //case 2: - // m_zenvyController.viewPayslip(); - // break; - //case 3: - // m_zenvyController.viewPayslipHistory(); - // break; - //case 4: - // m_zenvyController.viewEmployees(); - // break; - //case 5: - // m_zenvyController.searchEmployee(); - // break; - //case 6: - // m_zenvyController.viewNotifications(); - // break; - //case 7: - // m_zenvyController.viewAnnouncements(); - // break; - //case 8: - // m_zenvyController.createNewJob(); - // break; - //case 9: - // m_zenvyController.viewJobOpenings(); - // break; - //case 10: - // m_zenvyController.addCandidate(); - // break; - //case 11: - // m_zenvyController.updateCandidateStatus(); - // break; - //case 12: - // m_zenvyController.viewShortlistedCandidates(); - // break; + case 2: + viewPayslip(m_zenvyController); + break; + case 3: + viewPayslipHistory(m_zenvyController); + break; + case 4: + viewEmployees(m_zenvyController); + break; + case 5: + searchEmployee(m_zenvyController); + break; case 13: + updateProfile(m_zenvyController); + break; + case 14: + viewProfile(m_zenvyController); + break; + case 15: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.h index 93946ae..e6847bc 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include"ZenvyController.h" @@ -16,5 +15,4 @@ public: TalentExecutiveMenu() : m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.cpp index 97401b2..3110402 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.cpp @@ -4,11 +4,11 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include "TeamExecutiveMenu.h" -#include"InputHelper.h" -#include"OutputHelper.h" +#include "InputHelper.h" +#include "OutputHelper.h" +#include "MenuHelper.h" /* * Function: TeamExecutiveMenu::run @@ -27,7 +27,7 @@ void TeamExecutiveMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create Team\n9. Update Team\n10. Remove Team\n11. Assign Employee\n12. Unassign Employee\n13. View Teams\n14. Logout\nEnter your Choice: "; + std::cout << "Team Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notifications\n7. View Announcements\n8. Create Team\n9. Update Team\n10. Remove Team\n11. Assign Employee\n12. Unassign Employee\n13. View Teams\n14. Update Profile\n15. View Profile\n16. Logout\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -55,49 +55,29 @@ bool TeamExecutiveMenu::handleOperation(int choice) { switch (choice) { - //case 1: - // m_zenvyController.applyLeave(); - // break; - //case 2: - // m_zenvyController.viewPayslip(); - // break; - //case 3: - // m_zenvyController.viewPayslipHistory(); - // break; - //case 4: - // m_zenvyController.viewEmployees(); - // break; - //case 5: - // m_zenvyController.searchEmployee(); - // break; - //case 6: - // m_zenvyController.viewNotifications(); - // break; - //case 7: - // m_zenvyController.viewAnnouncements(); - // break; - //case 8: - // m_zenvyController.createTeam(); - // break; - //case 9: - // m_zenvyController.updateTeam(); - // break; - //case 10: - // m_zenvyController.removeTeam(); - // break; - //case 11: - // m_zenvyController.assignEmployee(); - // break; - //case 12: - // m_zenvyController.unassignEmployee(); - // break; - //case 13: - // m_zenvyController.viewTeams(); - // break; + case 2: + viewPayslip(m_zenvyController); + break; + case 3: + viewPayslipHistory(m_zenvyController); + break; + case 4: + viewEmployees(m_zenvyController); + break; + case 5: + searchEmployee(m_zenvyController); + break; case 14: + updateProfile(m_zenvyController); + break; + case 15: + viewProfile(m_zenvyController); + break; + case 16: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.h index 747b5d4..21fd70a 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include"ZenvyController.h" @@ -16,5 +15,4 @@ public: TeamExecutiveMenu() : m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.cpp index 31143d1..40ca7c2 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.cpp @@ -4,11 +4,11 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include "TeamLeadMenu.h" -#include"InputHelper.h" -#include"OutputHelper.h" +#include "InputHelper.h" +#include "OutputHelper.h" +#include "MenuHelper.h" /* * Function: TeamLeadMenu::run @@ -27,7 +27,7 @@ void TeamLeadMenu::run() { int choice; util::clear(); - std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. Raise Ticke\n5. View Ticket\n6. View Ticket History\n7. View Employees\n8. Search Employee\n9. View Team Members\n10. Book Meeting Room\n11. View Booking History\n12. View Notification\n13. View Announcements\n4. Regularize Attendance\n15. Update Leave Request\n16. Logout\nEnter your Choice: "; + std::cout << "Team Lead Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. Raise Ticket\n5. View Ticket\n6. View Ticket History\n7. View Employees\n8. Search Employee\n9. View Team Members\n10. Book Meeting Room\n11. View Booking History\n12. View Notifications\n13. View Announcements\n14. Regularize Attendance\n15. Update Leave Request\n16. Update Profile\n17. View Profile\n18. Logout\nEnter your Choice: "; util::read(choice); if (!handleOperation(choice)) { @@ -55,55 +55,29 @@ bool TeamLeadMenu::handleOperation(int choice) { switch (choice) { - /*case 1: - m_zenvyController.applyLeave(); - break; case 2: - m_zenvyController.viewPayslip(); + viewPayslip(m_zenvyController); break; case 3: - m_zenvyController.viewPayslipHistory(); - break; - case 4: - m_zenvyController.raiseTicket(); - break; - case 5: - m_zenvyController.viewTicket(); - break; - case 6: - m_zenvyController.viewTicketHistory(); + viewPayslipHistory(m_zenvyController); break; case 7: - m_zenvyController.viewEmployees(); + viewEmployees(m_zenvyController); break; case 8: - m_zenvyController.searchEmployee(); + searchEmployee(m_zenvyController); break; - case 9: - m_zenvyController.viewTeamMembers(); - break; - case 10: - m_zenvyController.bookMeetingRoom(); - break; - case 11: - m_zenvyController.viewBookingHistory(); - break; - case 12: - m_zenvyController.viewNotifications(); - break; - case 13: - m_zenvyController.viewAnnouncements(); - break; - case 14: - m_zenvyController.regularizeAttendance(); - break; - case 15: - m_zenvyController.updateLeaveRequest(); - break;*/ case 16: + updateProfile(m_zenvyController); + break; + case 17: + viewProfile(m_zenvyController); + break; + case 18: return false; default: std::cout << "Enter a valid choice!" << std::endl; + util::pressEnter(); } return true; -} +} \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.h b/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.h index 159f485..2eabf24 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include"ZenvyController.h" @@ -16,5 +15,4 @@ public: TeamLeadMenu() : m_zenvyController(new ZenvyController()) {}; void run(); bool handleOperation(int); -}; - +}; \ No newline at end of file diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.cpp b/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.cpp index cefe64a..50acbe5 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.cpp +++ b/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.cpp @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #include #include #include @@ -33,6 +32,15 @@ void UserInterface::run() { bool isMenuActive = true; + try + { + m_controller->loadStates(); + } + catch (const std::exception& e) + { + std::cout << "Exception: " << e.what() << std::endl; + return; + } while (isMenuActive) { try @@ -52,6 +60,15 @@ void UserInterface::run() util::pressEnter(); } } + try + { + m_controller->persistStates(); + } + catch (const std::exception& e) + { + std::cout << "Exception: " << e.what() << std::endl; + return; + } } /* @@ -125,7 +142,7 @@ void UserInterface::login() } else { - std::cout << "\nInvalid Password"; + std::cout << "Error: Invalid Password\n"; util::pressEnter(); return; } @@ -163,7 +180,7 @@ void UserInterface::login() menu.run(); break; } - case Enums::EmployeeType::TAG: + case Enums::EmployeeType::TALENT_ACQUISITION: { TalentExecutiveMenu menu; menu.run(); diff --git a/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.h b/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.h index e400ba6..6952830 100644 --- a/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.h +++ b/Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.h @@ -4,7 +4,6 @@ * Author: Trenser * Created: 02-Apr-2026 */ - #pragma once #include #include "AdminMenu.h"