Minor fixes and formatting updates in payroll, enums, and menus

<SRS> SRS02 : Employee Management </SRS> <Changes> - Fixed variable naming issue in Payroll deserialization - Added braces for consistency in enum string-to-value helpers - Improved readability in validation logic - Corrected typo in Finance Executive payroll menu text </Changes> <Review> Smitha Mohan </Review>
Merge branch 'feature-employee-management' into feature-employee-management-emp007
2026-04-13 11:46:55 +05:30 · 2026-04-13 11:37:24 +05:30 · 2026-04-13 10:44:14 +05:30 · 2026-04-11 17:54:20 +05:30 · 2026-04-11 17:41:57 +05:30 · 2026-04-11 14:59:41 +05:30
117 changed files with 2052 additions and 1551 deletions
@@ -426,3 +426,6 @@ FodyWeavers.xsd
 *.msix
 *.msm
 *.msp
+
+# CSV Files
+*.csv
@@ -0,0 +1,27 @@
+#include "pch.h"
+#include "FileIO.h"
+
+std::vector<std::string> 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<std::string> 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<std::string>& 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';
+}
@@ -0,0 +1,18 @@
+#pragma once
+#include<memory>
+#include<vector>
+#include<fstream>
+#include<string>
+#include<stdexcept>
+
+#ifdef TRENSERFILEMANAGER_EXPORTS
+#define TRENSERFILEMANAGER_API __declspec(dllexport)
+#else
+#define TRENSERFILEMANAGER_API __declspec(dllimport)
+#endif
+
+class TRENSERFILEMANAGER_API FileIO {
+public:
+    static std::vector<std::string> readAllLines(const std::string& path);
+    static void writeAllLines(const std::string& path, const std::vector<std::string>& lines);
+};
@@ -0,0 +1,52 @@
+#pragma once
+#include <stdexcept>
+#include "FileIO.h"
+
+template <typename T> using objects = std::map<std::string, std::shared_ptr<T>>;
+
+template <typename T>
+class FileManager
+{
+private:
+	std::string m_filePath;
+public:
+	FileManager() : m_filePath("") {}
+	FileManager(const std::string& filePath) : m_filePath(filePath) {}
+	objects<T> load();
+	void save(const objects<T>&);
+};
+
+template <typename T>
+objects<T> FileManager<T>::load()
+{
+	objects<T> 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 <typename T>
+void FileManager<T>::save(const objects<T>& records)
+{
+	std::vector<std::string> lines;
+	lines.push_back(T::getHeaders());
+	for (const auto& recordPair : records)
+	{
+		lines.push_back(recordPair.second->serialize());
+	}
+	FileIO::writeAllLines(m_filePath, lines);
+}
@@ -135,11 +135,14 @@
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
+    <ClInclude Include="FileIO.h" />
+    <ClInclude Include="FileManager.h" />
    <ClInclude Include="framework.h" />
    <ClInclude Include="pch.h" />
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="FileIO.cpp" />
    <ClCompile Include="pch.cpp">
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
@@ -21,6 +21,12 @@
    <ClInclude Include="pch.h">
      <Filter>Header Files</Filter>
    </ClInclude>
+    <ClInclude Include="FileManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="FileIO.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="dllmain.cpp">
@@ -29,5 +35,8 @@
    <ClCompile Include="pch.cpp">
      <Filter>Source Files</Filter>
    </ClCompile>
+    <ClCompile Include="FileIO.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
  </ItemGroup>
 </Project>
@@ -9,5 +9,10 @@

 // add headers that you want to pre-compile here
 #include "framework.h"
+#include<memory>
+#include<vector>
+#include<fstream>
+#include<string>
+#include<stdexcept>

 #endif //PCH_H
@@ -1,12 +1,5 @@
-/*
- * File: Trenser.Zenvy.cpp
- * Description: Zenvy Main
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include "UserInterface.h"
-
+#include "FileManager.h"
 int main()
 {
 	UserInterface userInterFace;
@@ -102,12 +102,17 @@
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)factories;$(ProjectDir)datastores;$(ProjectDir)views;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(ProjectDir)models;$(ProjectDir)controllers;$(ProjectDir)services;$(ProjectDir)utilities;$(ProjectDir)factories;$(ProjectDir)datastores;$(ProjectDir)views;%(AdditionalIncludeDirectories);..\..\Trenser.FileManager\Trenser.FileManager</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\Trenser.FileManager\$(IntDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>Trenser.FileManager.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
+    <PostBuildEvent>
+      <Command>xcopy /y /d "..\..\Trenser.FileManager\$(IntDir)Trenser.FileManager.dll" "$(OutDir)"</Command>
+    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
    <ClCompile>
@@ -117,11 +122,17 @@
      <SDLCheck>true</SDLCheck>
      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
+      <AdditionalIncludeDirectories>;..\..\Trenser.FileManager\Trenser.FileManager</AdditionalIncludeDirectories>
    </ClCompile>
    <Link>
      <SubSystem>Console</SubSystem>
      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>..\..\Trenser.FileManager\$(IntDir);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>Trenser.FileManager.lib;%(AdditionalDependencies)</AdditionalDependencies>
    </Link>
+    <PostBuildEvent>
+      <Command>xcopy /y /d "..\..\Trenser.FileManager\$(IntDir)Trenser.FileManager.dll" "$(OutDir)"</Command>
+    </PostBuildEvent>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="controllers\ZenvyController.cpp" />
@@ -150,7 +161,7 @@
    <ClCompile Include="services\AttendanceManagementService.cpp" />
    <ClCompile Include="services\AuthenticationManagementService.cpp" />
    <ClCompile Include="services\BookingManagementService.cpp" />
-    <ClCompile Include="services\EmployeeManagememtService.cpp" />
+    <ClCompile Include="services\EmployeeManagementService.cpp" />
    <ClCompile Include="services\LeaveManagementService.cpp" />
    <ClCompile Include="services\LogService.cpp" />
    <ClCompile Include="services\NotificationManagementService.cpp" />
@@ -162,9 +173,11 @@
    <ClCompile Include="models\Employee.cpp" />
    <ClCompile Include="models\HRManager.cpp" />
    <ClCompile Include="Trenser.Zenvy.cpp" />
+    <ClCompile Include="utilities\AuthorizationHelper.cpp" />
    <ClCompile Include="utilities\Enums.cpp" />
    <ClCompile Include="utilities\InputHelper.cpp" />
    <ClCompile Include="utilities\OutputHelper.cpp" />
+    <ClCompile Include="utilities\StringHelper.cpp" />
    <ClCompile Include="utilities\Timestamp.cpp" />
    <ClCompile Include="utilities\Validator.cpp" />
    <ClCompile Include="views\AdminMenu.cpp" />
@@ -172,6 +185,7 @@
    <ClCompile Include="views\FinanceExecutiveMenu.cpp" />
    <ClCompile Include="views\HRManagerMenu.cpp" />
    <ClCompile Include="views\ITExecutiveMenu.cpp" />
+    <ClCompile Include="views\MenuHelper.cpp" />
    <ClCompile Include="views\TalentExecutiveMenu.cpp" />
    <ClCompile Include="views\TeamExecutiveMenu.cpp" />
    <ClCompile Include="views\TeamLeadMenu.cpp" />
@@ -204,7 +218,7 @@
    <ClInclude Include="services\AttendanceManagementService.h" />
    <ClInclude Include="services\AuthenticationManagementService.h" />
    <ClInclude Include="services\BookingManagementService.h" />
-    <ClInclude Include="services\EmployeeManagememtService.h" />
+    <ClInclude Include="services\EmployeeManagementService.h" />
    <ClInclude Include="services\LeaveManagementService.h" />
    <ClInclude Include="services\LogService.h" />
    <ClInclude Include="services\NotificationManagementService.h" />
@@ -212,9 +226,11 @@
    <ClInclude Include="services\TalentAcquisitionManagementService.h" />
    <ClInclude Include="services\TeamManagementService.h" />
    <ClInclude Include="services\TicketManagementService.h" />
+    <ClInclude Include="utilities\AuthorizationHelper.h" />
    <ClInclude Include="utilities\Enums.h" />
    <ClInclude Include="utilities\InputHelper.h" />
    <ClInclude Include="utilities\OutputHelper.h" />
+    <ClInclude Include="utilities\StringHelper.h" />
    <ClInclude Include="utilities\Timestamp.h" />
    <ClInclude Include="utilities\Validator.h" />
    <ClInclude Include="views\AdminMenu.h" />
@@ -222,6 +238,7 @@
    <ClInclude Include="views\FinanceExecutiveMenu.h" />
    <ClInclude Include="views\HRManagerMenu.h" />
    <ClInclude Include="views\ITExecutiveMenu.h" />
+    <ClInclude Include="views\MenuHelper.h" />
    <ClInclude Include="views\TalentExecutiveMenu.h" />
    <ClInclude Include="views\TeamExecutiveMenu.h" />
    <ClInclude Include="views\TeamLeadMenu.h" />
@@ -39,9 +39,6 @@
    <ClCompile Include="services\AuthenticationManagementService.cpp">
      <Filter>Services</Filter>
    </ClCompile>
-    <ClCompile Include="services\EmployeeManagememtService.cpp">
-      <Filter>Services</Filter>
-    </ClCompile>
    <ClCompile Include="services\AttendanceManagementService.cpp">
      <Filter>Services</Filter>
    </ClCompile>
@@ -192,14 +189,23 @@
    <ClCompile Include="services\ApplicationConfig.cpp">
      <Filter>Services</Filter>
    </ClCompile>
+    <ClCompile Include="services\EmployeeManagementService.cpp">
+      <Filter>Services</Filter>
+    </ClCompile>
+    <ClCompile Include="views\MenuHelper.cpp">
+      <Filter>Views</Filter>
+    </ClCompile>
+    <ClCompile Include="utilities\AuthorizationHelper.cpp">
+      <Filter>Services</Filter>
+    </ClCompile>
+    <ClCompile Include="utilities\StringHelper.cpp">
+      <Filter>Utilities</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="services\AuthenticationManagementService.h">
      <Filter>Services</Filter>
    </ClInclude>
-    <ClInclude Include="services\EmployeeManagememtService.h">
-      <Filter>Services</Filter>
-    </ClInclude>
    <ClInclude Include="services\TicketManagementService.h">
      <Filter>Services</Filter>
    </ClInclude>
@@ -338,6 +344,18 @@
    <ClInclude Include="services\ApplicationConfig.h">
      <Filter>Services</Filter>
    </ClInclude>
+    <ClInclude Include="services\EmployeeManagementService.h">
+      <Filter>Services</Filter>
+    </ClInclude>
+    <ClInclude Include="views\MenuHelper.h">
+      <Filter>Views</Filter>
+    </ClInclude>
+    <ClInclude Include="utilities\AuthorizationHelper.h">
+      <Filter>Services</Filter>
+    </ClInclude>
+    <ClInclude Include="utilities\StringHelper.h">
+      <Filter>Utilities</Filter>
+    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="models\Employee.h">
@@ -1,68 +1,60 @@
-/*
- * File: ZenvyController.cpp
- * Description : Controls data flow between UI and Service Layers.
- * Author: Trenser
- * Created : 01-Apr-2026
- */
-
 #include "ZenvyController.h"

-/*
- * Function: login
- * Description: authenticates the employee based on email and password
- * Parameters:
- *    email - email of the employee
- *    password - password of the employee
- * Returns:
- *    Tuple - login status, employee type, employee designation
- *	  login status - success or failed
- *    employee type - type of the employee logged in
- *    employee designation - designation if employee type is GENERAL.
- */
-
+//Authentication
 AuthenticationDTO ZenvyController::login(const std::string& email, const std::string& password)
 {
 	return m_authenticationManagementService->login(email, password);
 }

-/*
- * Function: changePassword
- * 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::logout()
 {
 	m_authenticationManagementService->logout();
 }

-/*
- * Function: changePassword
- * 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);
 }

-ZenvyController::~ZenvyController()
+//Employee Management
+void ZenvyController::createEmployee(Enums::EmployeeType employeeType, Enums::EmployeeDesignation employeeDesignation, const std::string& email,  const std::string& name, const std::string& phone)
 {
-    delete m_authenticationManagementService;
-    delete m_attendanceManagementService;
-    delete m_bookingManagementService;
-    delete m_employeeManagememtService;
-    delete m_leaveManagementService;
-    delete m_notificationManagementService;
-    delete m_payslipManagementService;
-    delete m_talentAcquisitionManagementService;
-    delete m_teamManagementService;
-    delete m_ticketManagementService;
+	m_employeeManagementService->createEmployee(employeeType, employeeDesignation, email, name, phone);
+}
+
+bool ZenvyController::deactivateEmployee(const std::string& id)
+{
+	return m_employeeManagementService->deactivateEmployee(id);
+}
+
+void ZenvyController::updateProfile(const std::string& name, const std::string& phone)
+{
+	m_employeeManagementService->updateProfile(name,phone);
+}
+
+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);
+}
+
+std::shared_ptr<const Employee> ZenvyController::getCurrentEmployee()
+{
+	return m_employeeManagementService->getCurrentEmployee();
+}
+
+Employees ZenvyController::getEmployees()
+{
+	return m_employeeManagementService->getEmployees();
+}
+
+void ZenvyController::loadStates()
+{
+	m_employeeManagementService->loadEmployees();
+	m_payslipManagementService->loadPayrolls();
+}
+
+void ZenvyController::persistStates()
+{
+	m_employeeManagementService->saveEmployees();
+	m_payslipManagementService->savePayrolls();
 }
@@ -1,16 +1,10 @@
-/*
- * File: ZenvyController.h
- * Description : Controls data flow between UI and Service Layers.
- * Author: Trenser
- * Created : 01-Apr-2026
- */
-
 #pragma once
+#include <memory>
 #include <utility>
 #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 +16,45 @@
 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;
+	std::shared_ptr<AuthenticationManagementService> m_authenticationManagementService;
+	std::shared_ptr<AttendanceManagementService> m_attendanceManagementService;
+	std::shared_ptr<BookingManagementService> m_bookingManagementService;
+	std::shared_ptr<EmployeeManagementService> m_employeeManagementService;
+	std::shared_ptr<LeaveManagementService> m_leaveManagementService;
+	std::shared_ptr<NotificationManagementService> m_notificationManagementService;
+	std::shared_ptr<PayslipManagementService> m_payslipManagementService;
+	std::shared_ptr<TalentAcquisitionManagementService> m_talentAcquisitionManagementService;
+	std::shared_ptr<TeamManagementService> m_teamManagementService;
+	std::shared_ptr<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(std::make_shared<AuthenticationManagementService>()), 
+		m_attendanceManagementService(std::make_shared<AttendanceManagementService>()), 
+		m_bookingManagementService(std::make_shared<BookingManagementService>()),
+		m_employeeManagementService(std::make_shared<EmployeeManagementService>()),
+		m_leaveManagementService(std::make_shared<LeaveManagementService>()),
+		m_notificationManagementService(std::make_shared<NotificationManagementService>()),
+		m_payslipManagementService(std::make_shared<PayslipManagementService>()),
+		m_talentAcquisitionManagementService(std::make_shared<TalentAcquisitionManagementService>()),
+		m_teamManagementService(std::make_shared<TeamManagementService>()),
+		m_ticketManagementService(std::make_shared<TicketManagementService>()) {};
+		
+		//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&);
+		bool deactivateEmployee(const std::string&);
+		Employees getEmployees();
+		std::shared_ptr<const Employee> getCurrentEmployee();
+		void updateProfile(const std::string&,const std::string&);
+
+		//Payslip management
+		void updateSalary(const std::string&, double, double, double, double, double);
+
+		//File Management
+		void loadStates();
+		void persistStates();
+};
@@ -1,20 +1,5 @@
-/*
- * File: DataStore.cpp
- * Description: Central Storage for all the System Data.
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
 #include "DataStore.h"
-
-/*
- * Function: getInstance
- * Description: provides a singleton instance of the DataStore.
- * Parameters:
- *    None
- * Returns:
- *    DataStore& - reference to the single DataStore object.
- */
+#include "EmployeeManagementService.h"

 DataStore& DataStore::getInstance()
 {
@@ -22,91 +7,27 @@ DataStore& DataStore::getInstance()
 	return dataStore;
 }

-/*
- * Function: getLogs
- * Description: retrieves the log map containing system logs.
- * Parameters:
- *    None
- * Returns:
- *    logMap& - reference to the log map.
- */
-
 logMap& DataStore::getLogs()
 {
 	return m_logs;
 }

-/*
- * Function: getAuthenticatedEmployee
- * Description: returns the currently authenticated employee.
- * Parameters:
- *    None
- * Returns:
- *    std::shared_ptr<Employee>& - reference to the authenticated employee object.
- */
-
-Employee*& DataStore::getAuthenticatedEmployee()
+std::shared_ptr<Employee>& DataStore::getAuthenticatedEmployee()
 {
 	return m_authenticatedEmployee;
 }

-/*
- * Function: setAuthenticatedEmployee
- * Description: sets the currently authenticated employee.
- * Parameters:
- *    authenticatedEmployee - shared pointer to the employee object to be set as authenticated.
- * Returns:
- *    void - no return value.
- */
-
-void DataStore::setAuthenticatedEmployee(Employee* authenticatedEmployee)
+void DataStore::setAuthenticatedEmployee(std::shared_ptr<Employee> authenticatedEmployee)
 {
 	m_authenticatedEmployee = authenticatedEmployee;
 }

-/*
- * Function: getEmployees
- * Description: retrieves the employee map containing all employees.
- * Parameters:
- *    None
- * Returns:
- *    employeeMap& - reference to the employee map.
- */
-
 employeeMap& DataStore::getEmployees()
 {
 	return m_employees;
 }

-/*
- * Function: getAuthenticatedUser
- * Description: alias for getAuthenticatedEmployee, returns the currently authenticated employee.
- * Parameters:
- *    None
- * Returns:
- *    std::shared_ptr<Employee>& - reference to the authenticated employee object.
- */
-
-Employee* DataStore::getAuthenticatedUser()
+payrollMap& DataStore::getPayrolls()
 {
-	return m_authenticatedEmployee;
+	return m_payrolls;
 }
-DataStore::~DataStore()
-{
-    for (auto& pair : m_employees)
-    {
-        delete pair.second;
-    }
-    m_employees.clear();
-    for (auto& pair : m_logs)
-    {
-        delete pair.second;
-    }
-    m_logs.clear();
-    if (m_authenticatedEmployee)
-    {
-        delete m_authenticatedEmployee;
-        m_authenticatedEmployee = nullptr;
-    }
-}
-
@@ -1,11 +1,5 @@
-/*
- * File: DataStore.h
- * Description: Central Storage for all the System Data.
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
 #pragma once
+#include <memory>
 #include <map>
 #include "Employee.h"
 #include "Log.h"
@@ -24,17 +18,20 @@
 #include "Notification.h"
 #include "Announcement.h"
 #include "Faq.h"
+#include "Payroll.h"

-using employeeMap = std::map<std::string,Employee*>;
-using logMap = std::map<util::Timestamp, Log*>;
+using employeeMap = std::map<std::string, std::shared_ptr<Employee>>;
+using payrollMap = std::map<std::string, std::shared_ptr<Payroll>>;
+using logMap = std::map<util::Timestamp, std::shared_ptr<Log>>;

 class DataStore
 {
 private:
-    Employee* m_authenticatedEmployee;
+    std::shared_ptr<Employee> m_authenticatedEmployee;
    employeeMap m_employees;
+    payrollMap m_payrolls;
    logMap m_logs;
-    DataStore() : m_authenticatedEmployee(nullptr) {};
+    DataStore() = default;
 public:
    static DataStore& getInstance();
    DataStore(const DataStore&) = delete;
@@ -42,9 +39,8 @@ public:
    DataStore(DataStore&&) = delete;
    DataStore& operator=(DataStore&&) = delete;
 	employeeMap& getEmployees();
-    Employee* getAuthenticatedUser();
+    payrollMap& getPayrolls();
    logMap& getLogs();
-    Employee*& getAuthenticatedEmployee();
-    void setAuthenticatedEmployee(Employee*);
-    ~DataStore();
+    std::shared_ptr<Employee>& getAuthenticatedEmployee();
+    void setAuthenticatedEmployee(std::shared_ptr < Employee>);
 };
@@ -1,30 +1,13 @@
-/*
- * File: Factory.h
- * Description: Provides a generic factory utility to create shared_ptr instances of objects.
- * Author: Ajmal J S
- * Created: 01-Apr-2026
- */
-
 #pragma once
+#include <memory>
 #include <utility>

 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<T> - a shared pointer managing the newly created object
-    */
-
 	template<typename T, typename... Args>
-	static T* getObject(Args&&... args)
+	static std::shared_ptr<T> getObject(Args&&... args)
 	{
-		return T*(std::forward<Args>(args)...);
+		return std::make_shared<T>(std::forward<Args>(args)...);
 	}
 };
@@ -1,7 +1 @@
-/*
- * File: Admin.cpp
- * Description: Admin model class
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "Admin.h"
@@ -1,13 +1,32 @@
-/*
- * File: Admin.h
- * Description: Admin model class
- * 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,
+        std::shared_ptr<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;
 };
@@ -1,12 +1,7 @@
-/*
- * File: Announcement.cpp
- * Description: The Announcement class defines a simple object for managing announcement details.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "Announcement.h"

-//Getters and Setters
+int Announcement::m_uid = 0;
+
 const std::string& Announcement::getAnnouncementId() const
 {
    return m_id;
@@ -1,9 +1,3 @@
-/*
- * File: Announcement.h
- * Description: The Announcement class defines a simple object for managing announcement details.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include <string>
 #include "Timestamp.h"
@@ -11,14 +5,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;
@@ -1,12 +1,7 @@
-/*
- * File: Attendance.cpp
- * Description: The Attendance class represents an attendance record by storing an ID, login and logout timestamps.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "Attendance.h"

- //Getters and Setters
+int Attendance::m_uid = 0;
+
 const std::string& Attendance::getAttendanceId() const
 {
    return m_id;
@@ -1,9 +1,3 @@
-/*
- * File: Attendance.h
- * Description: The Attendance class represents an attendance record by storing an ID, login and logout timestamps.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include <string>
 #include "Timestamp.h"
@@ -11,15 +5,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;
@@ -1,12 +1,7 @@
-/*
- * File: Booking.cpp
- * Description: The Booking class represents a time‑based booking with employee and team details and supports duration calculation.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "Booking.h"

- //Getters and Setters
+int Booking::m_uid = 0;
+
 const std::string& Booking::getBookingId() const
 {
    return m_id;
@@ -27,7 +22,7 @@ const std::string& Booking::getEmployeeId() const
    return m_employeeId;
 }

-Team* Booking::getTeam() const
+std::shared_ptr<Team> Booking::getTeam() const
 {
    return m_team;
 }
@@ -52,7 +47,7 @@ void Booking::setEmployeeId(const std::string& employeeId)
    m_employeeId = employeeId;
 }

-void Booking::setTeam(Team* team)
+void Booking::setTeam(std::shared_ptr<Team> team)
 {
    m_team = team;
 }
@@ -1,39 +1,35 @@
-/*
- * File: Booking.h
- * Description: The Booking class represents a time?based booking with employee and team details and supports duration calculation.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include <string>
+#include <memory>
 #include "Team.h"
 #include "Timestamp.h"

 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;
+    std::shared_ptr<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) {};
+        std::shared_ptr<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;
    const std::string& getEmployeeId() const;
-    Team* getTeam() const;
+    std::shared_ptr<Team> getTeam() const;
    void setBookingId(const std::string& id);
    void setStartTime(const util::Timestamp& startTime);
    void setEndTime(const util::Timestamp& endTime);
    void setEmployeeId(const std::string& employeeId);
-    void setTeam(Team* team);
+    void setTeam(std::shared_ptr<Team> team);
    double getDurationInHours() const;
    double getDurationInMinutes() const;
 };
@@ -1,12 +1,7 @@
-/*
- * File: Candidate.cpp
- * Description: The Candidate class stores and manages a candidate’s information.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "Candidate.h"

- //Getters and Setters
+int Candidate::m_uid = 0;
+
 const std::string& Candidate::getCandidateId() const
 {
    return m_id;
@@ -1,9 +1,3 @@
-/*
- * File: Candidate.h
- * Description: The Candidate class stores and manages a candidate’s information.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include <string>
 #include "Enums.h"
@@ -11,19 +5,19 @@
 class Candidate
 {
 private:
+    static int m_uid;
    std::string m_id;
    std::string m_name;
    long int 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,
+    Candidate() : m_id("CD" + std::to_string(++m_uid)), m_name(""), m_phone(0), m_qualification(""), m_status(Enums::CandidateStatus::PENDING) {}
+    Candidate(const std::string& name,
        long int 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;
@@ -1,13 +1,45 @@
-/*
- * File: Employee.cpp
- * Description: The Employee class manages employee information and associated work records such as payroll, attendance, leaves, and payslips.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
+#include <sstream>
 #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;
 }
@@ -47,7 +79,7 @@ const std::string& Employee::getEmployeeTeamId() const
    return m_teamId;
 }

-Payroll* Employee::getPayroll() const
+std::shared_ptr<Payroll> Employee::getPayroll() const
 {
    return m_payroll;
 }
@@ -102,12 +134,12 @@ void Employee::setEmployeeTeamId(const std::string& teamId)
    m_teamId = teamId;
 }

-void Employee::setEmployeePayroll(Payroll* payroll)
+void Employee::setEmployeePayroll(std::shared_ptr<Payroll> payroll)
 {
    m_payroll = payroll;
 }

-void Employee::addPayslip(Payslip* payslip)
+void Employee::addPayslip(std::shared_ptr<Payslip> payslip)
 {
    if (payslip)
    {
@@ -115,7 +147,7 @@ void Employee::addPayslip(Payslip* payslip)
    }
 }

-void Employee::addAttendance(Attendance* attendance)
+void Employee::addAttendance(std::shared_ptr<Attendance> attendance)
 {
    if (attendance)
    {
@@ -123,7 +155,7 @@ void Employee::addAttendance(Attendance* attendance)
    }
 }

-void Employee::addLeave(Leave* leave)
+void Employee::addLeave(std::shared_ptr<Leave> leave)
 {
    if (leave)
    {
@@ -135,3 +167,115 @@ Enums::EmployeeType Employee::getEmployeeType() const
 {
    return m_employeeType;
 }
+
+std::string Employee::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);
+    return serializedEmployee.str();
+}
+
+std::shared_ptr<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<ITExecutive>(
+            id,
+            name,
+            phone,
+            password,
+            email,
+            teamId,
+            teamStatus,
+            accountStatus
+        );
+    case Enums::EmployeeType::FINANCE:
+        return Factory::getObject<FinanceExecutive>(
+            id,
+            name,
+            phone,
+            password,
+            email,
+            teamId,
+            teamStatus,
+            accountStatus
+        );
+    case Enums::EmployeeType::HR:
+        return Factory::getObject<HRManager>(
+            id,
+            name,
+            phone,
+            password,
+            email,
+            teamId,
+            teamStatus,
+            accountStatus
+        );
+    case Enums::EmployeeType::TEAM:
+        return Factory::getObject<TeamExecutive>(
+            id,
+            name,
+            phone,
+            password,
+            email,
+            teamId,
+            teamStatus,
+            accountStatus
+        );
+    case Enums::EmployeeType::TALENT_ACQUISITION:
+        return Factory::getObject<TalentExecutive>(
+            id,
+            name,
+            phone,
+            password,
+            email,
+            teamId,
+            teamStatus,
+            accountStatus
+        );
+    case Enums::EmployeeType::ADMIN:
+        return Factory::getObject<Admin>(
+            id,
+            name,
+            phone,
+            password,
+            email,
+            teamId,
+            teamStatus,
+            accountStatus
+        );
+    case Enums::EmployeeType::GENERAL:
+        throw std::runtime_error("Cannot deserialize GeneralEmployee!");
+    default:
+        return nullptr;
+    }
+}
+
+std::string Employee::getHeaders()
+{
+    return "EmployeeId,Email,Name,Phone,Password,TeamID,TeamStatus,AccountStatus,EmployeeType";
+}
@@ -1,24 +1,21 @@
-/*
- * File: Employee.h
- * Description: The Employee class manages employee information and associated work records such as payroll, attendance, leaves, and payslips.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include <string>
+#include <memory>
 #include <map>
 #include "Payslip.h"
 #include "Attendance.h"
 #include "Leave.h"
 #include "Payroll.h"
 #include "Enums.h"
-using payslipMap = std::map<std::string, Payslip*>;
-using attendanceMap = std::map<int, std::map<std::string, Attendance*>>;
-using leaveMap = std::map<std::string, Leave*>;
+#include "ApplicationConfig.h"
+using payslipMap = std::map<std::string, std::shared_ptr<Payslip>>;
+using attendanceMap = std::map<int, std::map<std::string, std::shared_ptr<Attendance>>>;
+using leaveMap = std::map<std::string, std::shared_ptr<Leave>>;

 class Employee
 {
-private:
+protected:
+    static int m_uid;
    std::string m_id;
    std::string m_password;
    std::string m_name;
@@ -27,23 +24,47 @@ private:
    Enums::AccountStatus m_accountStatus;
    Enums::TeamStatus m_teamStatus;
    std::string m_teamId;
-    Payroll* m_payroll;
+    std::shared_ptr<Payroll> m_payroll;
    payslipMap m_payslips;
    attendanceMap m_attendances;
    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_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;
+        std::shared_ptr<Payroll> payroll)
+        : 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;
@@ -51,7 +72,7 @@ public:
    Enums::AccountStatus getEmployeeAccountStatus() const;
    Enums::TeamStatus getEmployeeTeamStatus() const;
    const std::string& getEmployeeTeamId() const;
-    Payroll* getPayroll() const;
+    std::shared_ptr<Payroll> getPayroll() const;
    const payslipMap& getEmployeePayslips() const;
    const attendanceMap& getEmployeeAttendances() const;
    const leaveMap& getEmployeeLeaves() const;
@@ -62,10 +83,13 @@ public:
    void setEmployeeAccountStatus(Enums::AccountStatus status);
    void setEmployeeTeamStatus(Enums::TeamStatus status);
    void setEmployeeTeamId(const std::string& teamId);
-    void setEmployeePayroll(Payroll* payroll);
-    void addPayslip(Payslip* payslip);
-    void addAttendance(Attendance* attendance);
-    void addLeave(Leave* leave);
+    void setEmployeePayroll(std::shared_ptr<Payroll> payroll);
+    void addPayslip(std::shared_ptr<Payslip> payslip);
+    void addAttendance(std::shared_ptr<Attendance> attendance);
+    void addLeave(std::shared_ptr<Leave> leave);
    Enums::EmployeeType getEmployeeType() const;
+    virtual std::string serialize() const;
+    static std::shared_ptr<Employee> deserialize(const std::string&);
+    static std::string getHeaders();
    virtual ~Employee() = default;
 };
@@ -1,7 +1 @@
-/*
- * File: Faq.h
- * Description: Faq model class.
- * Author: Trenser
- * Created: 02-Apr-2026
- */
 #include "Faq.h"
@@ -1,9 +1,3 @@
-/*
- * File: Faq.h
- * Description: Faq model class.
- * Author: Trenser
- * Created: 02-Apr-2026
- */
 #pragma once

 class Faq
@@ -1,7 +1 @@
-/*
- * File: FinanceExecutive.h
- * Description: FinanceExecutive model class.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "FinanceExecutive.h"
@@ -1,13 +1,33 @@
-/*
- * File: FinanceExecutive.h
- * Description: FinanceExecutive model class.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include "Employee.h"

 class FinanceExecutive : public Employee
 {
+public:
+	FinanceExecutive() = default;
+	FinanceExecutive(
+        const std::string& name,
+        const std::string& phone,
+        const std::string& email,
+        std::shared_ptr<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;
 };

@@ -1,12 +1,7 @@
-/*
- * File: GeneralEmployee.h
- * Description: The GeneralEmployee class represents a general employee with a specific designation.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
+#include <sstream>
 #include "GeneralEmployee.h"
+#include "Factory.h"

- //Getters and Setters
 Enums::EmployeeDesignation GeneralEmployee::getDesignation() const
 {
    return m_designation;
@@ -15,4 +10,57 @@ Enums::EmployeeDesignation GeneralEmployee::getDesignation() const
 void GeneralEmployee::setDesignation(Enums::EmployeeDesignation designation)
 {
    m_designation = designation;
+}
+
+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();
+}
+
+std::shared_ptr<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<GeneralEmployee>(
+        id,
+        name,
+        phone,
+        password,
+        email,
+        teamId,
+        teamStatus,
+        employeeDesignation,
+        accountStatus
+    );
+}
+
+std::string GeneralEmployee::getHeaders()
+{
+    return "EmployeeId,Email,Name,Phone,Password,TeamID,TeamStatus,AccountStatus,EmployeeType,EmployeeDesignation";
 }
@@ -1,9 +1,3 @@
-/*
- * File: GeneralEmployee.h
- * Description: The GeneralEmployee class represents a general employee with a specific designation.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include "Employee.h"
 #include "Enums.h"
@@ -13,16 +7,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,
+        std::shared_ptr<Payroll> payroll,
+        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,
-        Payroll* payroll,
-        Enums::EmployeeDesignation designation) : Employee(id, password, name, phone, email, teamId,Enums::EmployeeType::GENERAL, payroll), m_designation(designation) {}
+        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 std::shared_ptr<GeneralEmployee> deserialize(const std::string&);
+    static std::string getHeaders();
    ~GeneralEmployee() = default;
 };
@@ -1,7 +1 @@
-/*
- * File: HRManager.cpp
- * Description: HRManager model class.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "HRManager.h"
@@ -1,13 +1,33 @@
-/*
- * File: HRManager.h
- * Description: HRManager model class.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include "Employee.h"

 class HRManager : public Employee
 {
+public:
+    HRManager() = default;
+    HRManager(
+        const std::string& name,
+        const std::string& phone,
+        const std::string& email,
+        std::shared_ptr<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;
 };

@@ -1,7 +1 @@
-/*
- * File: ITExecutive.cpp
- * Description: ITExecutive model class.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #include "ITExecutive.h"
@@ -1,13 +1,33 @@
-/*
- * File: ITExecutive.h
- * Description: ITExecutive model class.
- * Author: Trenser
- * Created: 31-Mar-2026
- */
 #pragma once
 #include "Employee.h"

 class ITExecutive : public Employee
 {
+public:
+    ITExecutive() = default;
+    ITExecutive(
+        const std::string& name,
+        const std::string& phone,
+        const std::string& email,
+        std::shared_ptr<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;
 };

@@ -1,13 +1,7 @@
-/*
-File: JobListing.cpp
-* Description : Represents a job opening along with its details and applied candidates.
-* 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;
@@ -1,21 +1,15 @@
-/*
-File: JobListing.h
-* Description : Represents a job opening along with its details and applied candidates.
-* Author : Trenser
-* Created : 01-Apr-2026
-*/
-
 #pragma once
 #include <string>
 #include <map>
 #include <memory>
 #include "Candidate.h"
 #include "Enums.h"
-using candidateMap = std::map<std::string, Candidate*>;
+using candidateMap = std::map<std::string, std::shared_ptr<Candidate>>;

 class JobListing
 {
 private:
+    static int m_uid;
    std::string m_id;
    std::string m_name;
    std::string m_description;
@@ -23,14 +17,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;
@@ -1,13 +1,7 @@
-/*
-File: Leave.cpp
-* Description : Stores information related to an employee’s leave application.
-* 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;
@@ -1,10 +1,3 @@
-/*
-File: Leave.h
-* Description : Stores information related to an employee’s leave application.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #pragma once
 #include <string>
 #include "Enums.h"
@@ -13,6 +6,7 @@ File: Leave.h
 class Leave
 {
 private:
+    static int m_uid;
    std::string m_id;
    std::string m_employeeId;
    util::Timestamp m_timestamp;
@@ -22,13 +16,12 @@ private:
    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;
@@ -1,13 +1,5 @@
-/*
-File: Log.cpp
-* Description : Represents a log entry containing a timestamp and an associated message.
-* Author : Trenser
-* Created : 01-Apr-2026
-*/
-
 #include "Log.h"

-//Getters and setters
 const util::Timestamp& Log::getTimestamp() const
 {
    return m_timestamp;
@@ -1,10 +1,3 @@
-/*
-File: Log.h
-* Description : Represents a log entry containing a timestamp and an associated message.
-* Author : Trenser
-* Created : 01-Apr-2026
-*/
-
 #pragma once
 #include <string>
 #include "Timestamp.h"
@@ -1,13 +1,7 @@
-/*
-File: Notification.cpp
-* Description : Represents an employee notification with message and status details.
-* 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;
@@ -1,10 +1,3 @@
-/*
-File: Notification.h
-* Description : Represents an employee notification with message and status details.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #pragma once
 #include <string>
 #include "Enums.h"
@@ -13,18 +6,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;
@@ -1,18 +1,48 @@
-/*
-File: Payroll.cpp
-* Description : Stores payroll and salary breakdown details for an employee.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
+#include <sstream>
+#include <stdexcept>
 #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 +68,9 @@ double Payroll::getEmployerPFContribution() const
    return m_employerPFContribution;
 }

-void Payroll::setPayrollID(const std::string& id)
+void Payroll::setBasicSalary(double basicSalary)
 {
-    m_id = id;
+    m_basicSalary = basicSalary;
 }

 void Payroll::setHouseRentAllowance(double value)
@@ -61,4 +91,58 @@ void Payroll::setEmployeePFContribution(double value)
 void Payroll::setEmployerPFContribution(double value)
 {
    m_employerPFContribution = value;
+}
+
+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();
+}
+
+std::shared_ptr<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<Payroll>(
+            id,
+            employeeId,
+            basicSalary,
+            houseRentAllowance,
+            foodAllowance,
+            employeePFContribution,
+            employerPFContribution
+        );
+    }
+    catch (...)
+	{
+        throw std::runtime_error("Failed to deserialize Payroll object");
+    }
+}
+
+std::string Payroll::getHeaders()
+{
+    return "PayrollId,EmployeeId,BasicSalary,HouseRentAllowance,FoodAllowance,EmployeePFContribution,EmployerPFContribution";
 }
@@ -1,40 +1,58 @@
-/*
-File: Payroll.h
-* Description : Stores payroll and salary breakdown details for an employee.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #pragma once
 #include <string>
+#include <memory>

 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;
 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);
+    void setBasicSalary(double);
+    void setHouseRentAllowance(double);
+    void setFoodAllowance(double);
+    void setEmployeePFContribution(double);
+    void setEmployerPFContribution(double);
+    virtual std::string serialize() const;
+    static std::shared_ptr<Payroll> deserialize(const std::string&);
+    static std::string getHeaders();
 };
@@ -1,13 +1,7 @@
-/*
-File: Payslip.cpp
-* Description : Models a payslip entity that stores salary information.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #include "Payslip.h"

-//Getters and setters
+int Payslip::m_uid = 0;
+
 const std::string& Payslip::getPayslipId() const
 {
    return m_id;
@@ -1,21 +1,15 @@
-/*
-File: Payslip.h
-* Description : Models a payslip entity that stores salary information.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #pragma once
 #include <string>

 class Payslip
 {
 private:
+    static int m_uid;
    std::string m_id;
    double m_salary;
 public:
-    Payslip() : m_id(""), m_salary(0.0) {}
-    Payslip(const std::string& id, double salary) : m_id(id), m_salary(salary) {}
+    Payslip() : m_id("PS" + std::to_string(++m_uid)), m_salary(0.0) {}
+    Payslip(const double salary) : m_id("PS" + std::to_string(++m_uid)), m_salary(salary) {}
    const std::string& getPayslipId() const;
    double getSalary() const;
    void setPayslipId(const std::string& id);
@@ -1,13 +1,7 @@
-/*
-File: Room.cpp
-* Description : Models a room entity that maintains room details and manages its bookings.
-* 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,7 +27,7 @@ void Room::setRoomName(const std::string& name)
    m_name = name;
 }

-void Room::addBooking(Booking* booking)
+void Room::addBooking(std::shared_ptr<Booking> booking)
 {
    if (booking)
    {
@@ -1,30 +1,24 @@
-/*
-File: Room.h
-* Description : Models a room entity that maintains room details and manages its bookings.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #pragma once
 #include <string>
 #include <map>
 #include <memory>
 #include "Booking.h"
-using bookingMap = std::map<std::string, Booking*>;
+using bookingMap = std::map<std::string, std::shared_ptr<Booking>>;

 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;
    void setRoomId(const std::string& id);
    void setRoomName(const std::string& name);
-    void addBooking(Booking* booking);
+    void addBooking(std::shared_ptr<Booking> booking);
 };
@@ -1,8 +1 @@
-/*
-File: TalentExecutive.cpp
-* Description : Represents information related to a talent executive in the system.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #include "TalentExecutive.h"
@@ -1,14 +1,34 @@
-/*
-File: TalentExecutive.h
-* Description : Represents information related to a talent executive in the system.
-* 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,
+        std::shared_ptr<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;
 };

@@ -1,13 +1,7 @@
-/*
-File: Team.cpp
-* Description : Models a team entity that maintains team identity, leadership, employee list, and size limitations.
-* 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;
@@ -18,7 +12,7 @@ const std::string& Team::getTeamName() const
    return m_name;
 }

-Employee* Team::getTeamLead() const
+std::shared_ptr<Employee> Team::getTeamLead() const
 {
    return m_lead;
 }
@@ -43,7 +37,7 @@ void Team::setTeamName(const std::string& name)
    m_name = name;
 }

-void Team::setTeamLead(Employee* lead)
+void Team::setTeamLead(std::shared_ptr<Employee> lead)
 {
    m_lead = lead;
 }
@@ -1,41 +1,35 @@
-/*
-File: Team.h
-* Description : Models a team entity that maintains team identity, leadership, employee list, and size limitations.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #pragma once
 #include <string>
 #include <map>
 #include <memory>
 #include "Employee.h"
-using employeeMap = std::map<std::string, Employee*>;
+using employeeMap = std::map<std::string, std::shared_ptr<Employee>>;

 class Team
 {
 private:
+    static int m_uid;
    std::string m_id;
    std::string m_name;
-    Employee* m_lead;
+    std::shared_ptr<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,
+        std::shared_ptr<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;
-    Employee* getTeamLead() const;
+    std::shared_ptr<Employee> getTeamLead() const;
    const employeeMap& getEmployeesInTeam() const;
    int getMaximumNumberOfEmployeesInTeam() const;
    void setTeamId(const std::string& id);
    void setTeamName(const std::string& name);
-    void setTeamLead(Employee* lead);
+    void setTeamLead(std::shared_ptr<Employee> lead);
    void setEmployeesInTeam(const employeeMap& employees);
    void setMaximumNumberOfEmployeesInTeam(int maximumNumberOfEmployees);
 };
@@ -1,8 +1 @@
-/*
-File: TeamExecutive.cpp
-* Description : Represents information related to a team executive within the system.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #include "TeamExecutive.h"
@@ -1,14 +1,33 @@
-/*
-File: TeamExecutive.h
-* Description : Represents information related to a team executive within the system.
-* 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,
+        std::shared_ptr<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;
 };

@@ -1,13 +1,7 @@
-/*
-File: Ticket.cpp
-* Description : Represents a support ticket with its associated details and status.
-* 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;
@@ -1,10 +1,3 @@
-/*
-File: Ticket.h
-* Description : Represents a support ticket with its associated details and status.
-* Author : Trenser
-* Created : 31-Mar-2026
-*/
-
 #pragma once
 #include <string>
 #include "Enums.h"
@@ -12,19 +5,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;
@@ -1,8 +1 @@
-/*
- * File: ApplicationConfig.cpp
- * Description: Global Application Config
- * Author: Trenser
- * Created: 06-Apr-2026
- */
-
 #include "ApplicationConfig.h"
@@ -1,10 +1,3 @@
-/*
- * File: ApplicationConfig.h
- * Description: Global Application Config
- * Author: Trenser
- * Created: 06-Apr-2026
- */
-
 #pragma once

 namespace Config
@@ -13,4 +6,35 @@ 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";
+	}
 }
@@ -1,8 +1 @@
-/*
- * File: AttendanceManagementService.cpp
- * Description: Handles Attendance related operations
- * Author: Trenser
- * Created: 30-Apr-2026
- */
-
 #include "AttendanceManagementService.h"
@@ -1,10 +1,3 @@
-/*
- * File: AttendanceManagementService.h
- * Description: Handles Attendance related operations
- * Author: Trenser
- * Created: 30-Apr-2026
- */
-
 #pragma once
 class AttendanceManagementService
 {
@@ -1,110 +1,70 @@
-/*
- * File: AuthenticationManagementService.cpp
- * Description: Handles authentication related operations
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include <stdexcept>
 #include "AuthenticationManagementService.h"
 #include "ApplicationConfig.h"

-/*
- * Function: login
- * Description: Authenticates a user using email and password, determines login status,
- *              employee type, and designation, and sets the authenticated employee
- *              in the data store.
- * Parameters:
- *    email - employee email address
- *    password - employee password
- * Returns:
- *    AuthenticationDTO containing login status, employee type, and employee designation
- */
 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)
-                {
-                    GeneralEmployee* generalEmployee = dynamic_cast<GeneralEmployee*>(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);
+	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)
+				{
+					std::shared_ptr<GeneralEmployee> generalEmployee = std::dynamic_pointer_cast<GeneralEmployee>(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);
 }

-/*
- * Function: changePassword
- * Description: Updates the password of the currently authenticated user.
- * Parameters:
- *    password - new password to be set
- * Returns:
- *    None
- * Throws:
- *    runtime_error if no authenticated user is found
- */
 void AuthenticationManagementService::changePassword(const std::string& password)
 {
-    Employee* authenticatedUser = m_dataStore.getAuthenticatedUser();
-    if (authenticatedUser)
-    {
-        authenticatedUser->setEmployeePassword(password);
-    }
-    else
-    {
-        throw std::runtime_error("User not found");
-    }
+	std::shared_ptr<Employee> authenticatedUser = m_dataStore.getAuthenticatedEmployee();
+	if (authenticatedUser)
+	{
+		authenticatedUser->setEmployeePassword(password);
+	}
+	else
+	{
+		throw std::runtime_error("User not found");
+	}
 }

-/*
- * Function: logout
- * Description: Logs out the currently authenticated user by clearing authentication data.
- * Parameters:
- *    None
- * Returns:
- *    None
- * Throws:
- *    runtime_error if no user is currently logged in
- */
 void AuthenticationManagementService::logout() {
-	if (m_dataStore.getAuthenticatedEmployee()) 
-    {
+	if (m_dataStore.getAuthenticatedEmployee()) {
 		m_dataStore.getAuthenticatedEmployee() = nullptr;
 	}
-	else 
-    {
+	else {
 		throw std::runtime_error("No user currently logged In...");
 	}
 }
@@ -1,10 +1,3 @@
-/*
- * File: AuthenticationManagementService.h
- * Description: Handles authentication related operations
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
 #include <string>
 #include <map>
@@ -26,3 +19,4 @@ public:
 	void logout();
 	void changePassword(const std::string&);
 };
+
@@ -1,8 +1 @@
-/*
- * File: BookingManagementService.cpp
- * Description: Handle operations related to booking meetings
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include "BookingManagementService.h"
@@ -1,10 +1,3 @@
-/*
- * File: BookingManagementService.h
- * Description: Handle operations related to booking meetings
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
 class BookingManagementService
 {
@@ -1,8 +0,0 @@
-/*
- * File: EmployeeManagementService.cpp
- * Description: Handle operations related to employees
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
-#include "EmployeeManagememtService.h"
@@ -1,12 +0,0 @@
-/*
- * File: EmployeeManagementService.h
- * Description: Handle operations related to employees
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
-#pragma once
-class EmployeeManagememtService
-{
-};
-
@@ -0,0 +1,209 @@
+#include <map>
+#include <stdexcept>
+#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"
+
+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();
+	std::shared_ptr<Employee> authenticatedEmployee = m_dataStore.getAuthenticatedEmployee();
+	if (!authenticatedEmployee)
+	{
+		throw std::runtime_error("No authenticated user");
+	}
+	Enums::EmployeeType authenticatedEmployeeType = authenticatedEmployee->getEmployeeType();
+	std::shared_ptr<Employee> employee;
+	std::shared_ptr<Payroll> payroll;
+	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<Payroll>(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<HRManager>(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<Payroll>(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<ITExecutive>(name, phone, email, payroll);
+			break;
+		case Enums::EmployeeType::FINANCE:
+			employee = Factory::getObject<FinanceExecutive>(name, phone, email, payroll);
+			break;
+		case Enums::EmployeeType::TEAM:
+			employee = Factory::getObject<TeamExecutive>(name, phone, email, payroll);
+			break;
+		case Enums::EmployeeType::TALENT_ACQUISITION:
+			employee = Factory::getObject <TalentExecutive> (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<Payroll>(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<Payroll>(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<GeneralEmployee>(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));
+}
+
+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;
+}
+
+Employees EmployeeManagementService::getEmployees()
+{
+	Employees result;
+	auto& employees = m_dataStore.getEmployees();
+	if (employees.size() <= 0)
+	{
+		return result;
+	}
+	for (const auto& iterator : employees)
+	{
+		if (iterator.second->getEmployeeAccountStatus() == Enums::AccountStatus::ACTIVE)
+		{
+			result.push_back(iterator.second);
+		}
+	}
+	return result;
+}
+
+std::shared_ptr<const Employee> EmployeeManagementService::getCurrentEmployee()
+{
+	return m_dataStore.getAuthenticatedEmployee();
+}
+
+void EmployeeManagementService::updateProfile(const std::string& name,const std::string& phone)
+{
+	std::shared_ptr<Employee> employee = m_dataStore.getAuthenticatedEmployee();
+	employee->setEmployeeName(name);
+	employee->setEmployeePhone(phone);
+}
+
+void EmployeeManagementService::loadEmployees()
+{
+	FileManager<Employee> employeeFileManager(Config::File::EMPLOYEES_FILE);
+	FileManager<GeneralEmployee> 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", "", "admin@trenser.com", nullptr);
+		employees.emplace(std::make_pair(admin->getId(), admin));
+	}
+}
+
+void EmployeeManagementService::saveEmployees()
+{
+	FileManager<Employee> employeeFileManager(Config::File::EMPLOYEES_FILE);
+	FileManager<GeneralEmployee> generalEmployeeFileManager(Config::File::GENERAL_EMPLOYEES_FILE);
+	const auto& allEmployees = m_dataStore.getEmployees();
+	employeeMap employees;
+	std::map<std::string, std::shared_ptr<GeneralEmployee>> generalEmployees;
+	for (auto& employeePair : allEmployees)
+	{
+		if (employeePair.second->getEmployeeType() == Enums::EmployeeType::GENERAL)
+		{
+			generalEmployees.emplace(employeePair.first, std::static_pointer_cast<GeneralEmployee>(employeePair.second));
+		}
+		else
+		{
+			employees.emplace(employeePair);
+		}
+	}
+	employeeFileManager.save(employees);
+	generalEmployeeFileManager.save(generalEmployees);
+}
@@ -0,0 +1,22 @@
+#pragma once
+#include <vector>
+#include <tuple>
+#include "DataStore.h"
+#include "Enums.h"
+
+using Employees = std::vector<std::shared_ptr<const Employee>>;
+
+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&);
+	Employees getEmployees();
+	void updateProfile(const std::string&,const std::string&);
+	std::shared_ptr<const Employee> getCurrentEmployee();
+	void loadEmployees();
+	void saveEmployees();
+};
@@ -1,8 +1 @@
-/*
- * File: LeaveManagementService.cpp
- * Description: Handle operations related to leaves
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include "LeaveManagementService.h"
@@ -1,10 +1,3 @@
-/*
- * File: LeaveManagementService.h
- * Description: Handle operations related to leaves
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
 class LeaveManagementService
 {
@@ -1,10 +1,3 @@
-/*
- * File: Log.cpp
- * Description: Handle operations related to logging
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
 #include "LogService.h"
 #include "Log.h"
 #include "Factory.h"
@@ -14,6 +7,6 @@ void LogService::log(const std::string& message)
 {
 	DataStore& dataStore = DataStore::getInstance();
 	logMap& logs = dataStore.getLogs();
-	Log* log = Factory::getObject<Log>(message);
+	std::shared_ptr<Log> log = Factory::getObject<Log>(message);
 	logs.emplace(std::make_pair(log->getTimestamp(), log));
 }
@@ -1,10 +1,3 @@
-/*
- * File: Log.h
- * Description: Handle operations related to logging
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
 #pragma once
 #include "Log.h"

@@ -1,8 +1 @@
-/*
- * File: NotificationManagementService.cpp
- * Description: Handle operations related to notifications
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include "NotificationManagementService.h"
@@ -1,11 +1,5 @@
-/*
- * File: NotificationManagementService.h
- * Description: Handle operations related to notifications
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
 class NotificationManagementService
 {
 };
+
@@ -1,8 +1,50 @@
-/*
- * File: PayslipManagementService.cpp
- * Description: Handle operations related to employee payslips
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
+#include <stdexcept>
 #include "PayslipManagementService.h"
+#include "ApplicationConfig.h"
+#include "AuthorizationHelper.h"
+#include "Enums.h"
+#include "FileManager.h"
+
+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");
+	}
+}
+
+void PayslipManagementService::loadPayrolls()
+{
+	FileManager<Payroll> 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());
+}
+
+void PayslipManagementService::savePayrolls()
+{
+	FileManager<Payroll> payrollFileManager(Config::File::PAYROLL_FILE);
+	auto& payrolls = m_dataStore.getPayrolls();
+	payrollFileManager.save(payrolls);
+}
@@ -1,12 +1,15 @@
-/*
- * File: PayslipManagementService.h
- * Description: Handle operations related to employee payslips
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
+#include <string>
+#include<stdexcept>
+#include"DataStore.h"
+
 class PayslipManagementService
 {
+private:
+	DataStore& m_dataStore;
+public:
+	PayslipManagementService() : m_dataStore(DataStore::getInstance()) {};
+	void updateSalary(const std::string&, double, double, double, double, double);
+	void loadPayrolls();
+	void savePayrolls();
 };
-
@@ -1,8 +1 @@
-/*
- * File: TalentAcquisitionManagementService.cpp
- * Description: Handle operations related to Talent Acquisition
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include "TalentAcquisitionManagementService.h"
@@ -1,11 +1,5 @@
-/*
- * File: TalentAcquisitionManagementService.h
- * Description: Handle operations related to Talent Acquisition
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
 class TalentAcquisitionManagementService
 {
 };
+
@@ -1,8 +1 @@
-/*
- * File: TeamManagementService.cpp
- * Description: Handle operations related to Team Management
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include "TeamManagementService.h"
@@ -1,10 +1,3 @@
-/*
- * File: TeamManagementService.h
- * Description: Handle operations related to Team Management
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
 class TeamManagementService
 {
@@ -1,8 +1 @@
-/*
- * File: TicketManagementService.h
- * Description: Handle operations related to Ticket Management
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #include "TicketManagementService.h"
@@ -1,10 +1,3 @@
-/*
- * File: TicketManagementService.h
- * Description: Handle operations related to Ticket Management
- * Author: Trenser
- * Created: 30-Mar-2026
- */
-
 #pragma once
 class TicketManagementService
 {
@@ -0,0 +1 @@
+#include "AuthorizationHelper.h"
@@ -0,0 +1,31 @@
+#pragma once
+#include <stdexcept>
+#include "Enums.h"
+
+namespace util
+{
+    inline bool isAuthorized(Enums::EmployeeType current, Enums::EmployeeType first)
+    {
+        return current == first;
+    }
+
+    template <typename... Rest>
+    inline bool isAuthorized(Enums::EmployeeType current, Enums::EmployeeType first,
+        Rest... rest)
+    {
+        if (current == first)
+        {
+            return true;
+        }
+        return isAuthorized(current, rest...);
+    }
+
+    template <typename... Allowed>
+    inline void enforceAuthorization(Enums::EmployeeType current, Allowed... allowed)
+    {
+        if (!isAuthorized(current, allowed...))
+        {
+            throw std::runtime_error("You are unauthorized to perform this operation!");
+        }
+    }
+}
@@ -1,11 +1,5 @@
-/*
- * File: Enums.h
- * Description: Defines strongly typed enumerations for statuses, types, and designations used across the HRMS system.
- * Author: Smitha
- * Created: 01-04-2026
- */
-
 #pragma once
+#include <string>

 namespace Enums {

@@ -82,7 +76,7 @@ namespace Enums {
        GENERAL,
        IT,
        FINANCE,
-        TAG,
+        TALENT_ACQUISITION,
        HR,
        TEAM,
        ADMIN,
@@ -96,4 +90,148 @@ namespace Enums {
        USER_NOT_FOUND,
        INVALID_PASSWORD
    };
+
+    inline std::string getAccountStatusString(AccountStatus status)
+    {
+        switch (status)
+        {
+        case AccountStatus::ACTIVE:
+            return "ACTIVE";
+        case AccountStatus::INACTIVE:
+            return "INACTIVE";
+        default:
+            return "UNKNOWN";
+        }
+    }
+
+    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";
+        }
+    }
+
+    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";
+        }
+    }
+
+    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";
+        }
+    }
+
+    inline AccountStatus getAccountStatus(const std::string& input)
+    {
+        if (input == "ACTIVE")
+        {
+            return AccountStatus::ACTIVE;
+        }
+        if (input == "INACTIVE")
+        {
+            return AccountStatus::INACTIVE;
+        }
+        return AccountStatus::INACTIVE;
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    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;
+    }
 }
@@ -1,11 +1,5 @@
-/*
- * File: InputHelper.h
- * Description: Handles input validation and error handling
- * Author: Smitha
- * Created: 08-Apr-2026
- */
-
 #pragma once
+
 #include <iostream>
 #include <limits>
 #include <string>
@@ -13,15 +7,6 @@

 namespace util
 {
-    /*
-    * Function: read
-    * Description: Reads input from console into a variable of type T.
-    * Parameters:
-    * value - reference to a variable of type T where the input will be stored
-    * Returns:
-    * void - throws runtime_error if input is invalid
-    */
-
    template <typename T>
    inline void read(T& value)
    {
@@ -33,29 +18,14 @@ namespace util
        }
    }

-    /*
-    * Function: read
-    * Description: Reads a line of text input from console into a string.
-    * Parameters:
-    * value - reference to a string where the input will be stored
-    * Returns:
-    * void - no return value
-    */
-
    inline void read(std::string& value)
    {
        std::getline(std::cin >> std::ws, value);
    }

-    /*
-    * Function: pressEnter
-    * Description: Pauses execution until the user presses Enter.
-    * Parameters: None
-    * Returns: void - no return value
-    */
-
    inline void pressEnter()
    {
+        std::cout << std::endl;
 	    system("pause");
    }
 }
@@ -1,20 +1,5 @@
-/*
- * File: OutputHelper.cpp
- * Description: Provides functions to help with console output.
- * Author: Trenser
- * Created: 01-04-2026
-*/
-
 #include "outputHelper.h"

-/*
-* Function: clear
-* Description: Clears the console screen output.
-* Parameters: None
-* Returns:
-*    void - no return value
-*/
-
 void util::clear()
 {
 	std::cout << "\x1B[2J\x1B[H" << std::flush;
@@ -1,10 +1,3 @@
-/*
- * File: OutputHelper.h
- * Description: Provides functions to help with console output.
- * Author: Trenser
- * Created: 01-04-2026
-*/
-
 #pragma once
 #include <iostream>

@@ -0,0 +1,15 @@
+#include "StringHelper.h"
+#include <cctype>
+
+int util::extractNumber(const std::string& input)
+{
+    int result = 0;
+    for (char character : input)
+    {
+        if (std::isdigit(static_cast<unsigned char>(character)))
+        {
+            result = result * 10 + (character - '0');
+        }
+    }
+    return result;
+}
@@ -0,0 +1,7 @@
+#pragma once
+#include <string>
+
+namespace util
+{
+    int extractNumber(const std::string&);
+}
@@ -1,56 +1,18 @@
-/*
- * File: Timestamp.cpp
- * Description: Provides a utility class for representing and manipulating time values.
- *              Supports conversion between string and time formats, duration calculations
- *              (hours, minutes, seconds), date extraction, and comparison operators.
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
 #include <sstream>
 #include <iomanip>
 #include <stdexcept>
 #include "Timestamp.h"

-/*
-* 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);
 }

-/*
-* Function: Timestamp (overloaded)
-* Description: Constructor that initializes the timestamp with a given time value.
-* Parameters:
-*    timeValue - time_t value representing a specific time
-* Returns:
-*    Timestamp object
-*/
-
 util::Timestamp::Timestamp(std::time_t timeValue)
 {
    m_time = timeValue;
 }

-/*
-* Function: fromString
-* Description: Creates a Timestamp object from a formatted string.
-* Parameters:
-*    timeString - string in the format "YYYY-MM-DD HH:MM:SS"
-* Returns:
-*    Timestamp object representing the parsed time
-* Throws:
-*    runtime_error if the string format is invalid
-*/
-
 util::Timestamp util::Timestamp::fromString(const std::string& timeString)
 {
    std::tm timeStruct = {};
@@ -64,15 +26,6 @@ util::Timestamp util::Timestamp::fromString(const std::string& timeString)
    return Timestamp(parsedTimestamp);
 }

-/*
-* Function: toString
-* Description: Converts the Timestamp object into a formatted string.
-* Parameters:
-*    None
-* Returns:
-*    string - formatted as "YYYY-MM-DD HH:MM:SS"
-*/
-
 std::string util::Timestamp::toString() const
 {
    std::tm timeStruct = {};
@@ -82,30 +35,11 @@ std::string util::Timestamp::toString() const
    return outputStream.str();
 }

-/*
-* Function: getDurationInSeconds
-* Description: Calculates the duration between two timestamps in seconds.
-* Parameters:
-*    startTimestamp - starting time
-*    endTimestamp - ending time
-* Returns:
-*    double - duration in seconds
-*/
-
 double util::Timestamp::getDurationInSeconds(const Timestamp& startTimestamp, const Timestamp& endTimestamp)
 {
    return std::difftime(endTimestamp.m_time, startTimestamp.m_time);
 }

-/*
-* Function: getDateAsInt
-* Description: Returns the date portion of the timestamp as an integer in YYYYMMDD format.
-* Parameters:
-*    None
-* Returns:
-*    int - date as YYYYMMDD
-*/
-
 int util::Timestamp::getDateAsInt() const
 {
    std::tm timeStruct{};
@@ -116,101 +50,36 @@ int util::Timestamp::getDateAsInt() const
    return year * 10000 + month * 100 + day;
 }

-/*
-* Function: getDurationInMinutes
-* Description: Calculates the duration between two timestamps in minutes.
-* Parameters:
-*    startTimestamp - starting time
-*    endTimestamp - ending time
-* Returns:
-*    double - duration in minutes
-*/
-
 double util::Timestamp::getDurationInMinutes(const Timestamp& startTimestamp, const Timestamp& endTimestamp)
 {
    return getDurationInSeconds(startTimestamp, endTimestamp) / 60.0;
 }

-/*
-* Function: getDurationInHours
-* Description: Calculates the duration between two timestamps in hours.
-* Parameters:
-*    startTimestamp - starting time
-*    endTimestamp - ending time
-* Returns:
-*    double - duration in hours
-*/
-
 double util::Timestamp::getDurationInHours(const Timestamp& startTimestamp, const Timestamp& endTimestamp)
 {
    return getDurationInSeconds(startTimestamp, endTimestamp) / 3600.0;
 }

-/*
-* Function: operator<
-* Description: Compares two timestamps to check if one is earlier than the other.
-* Parameters:
-*    other - Timestamp to compare against
-* Returns:
-*    bool - true if current timestamp is earlier
-*/
-
 bool util::Timestamp::operator<(const Timestamp& other) const
 {
    return m_time < other.m_time;
 }

-/*
-* Function: operator>
-* Description: Compares two timestamps to check if one is later than the other.
-* Parameters:
-*    other - Timestamp to compare against
-* Returns:
-*    bool - true if current timestamp is later
-*/
-
 bool util::Timestamp::operator>(const Timestamp& other) const
 {
    return m_time > other.m_time;
 }

-/*
-* Function: operator<=
-* Description: Compares two timestamps to check if one is earlier or equal.
-* Parameters:
-*    other - Timestamp to compare against
-* Returns:
-*    bool - true if current timestamp is earlier or equal
-*/
-
 bool util::Timestamp::operator<=(const Timestamp& other) const
 {
    return m_time <= other.m_time;
 }

-/*
-* Function: operator>=
-* Description: Compares two timestamps to check if one is later or equal.
-* Parameters:
-*    other - Timestamp to compare against
-* Returns:
-*    bool - true if current timestamp is later or equal
-*/
-
 bool util::Timestamp::operator>=(const Timestamp& other) const
 {
    return m_time >= other.m_time;
 }

-/*
-* Function: operator==
-* Description: Compares two timestamps for equality.
-* Parameters:
-*    other - Timestamp to compare against
-* Returns:
-*    bool - true if both timestamps are equal
-*/
-
 bool util::Timestamp::operator==(const Timestamp& other) const
 {
    return m_time == other.m_time;
@@ -1,12 +1,3 @@
-/*
- * File: Timestamp.h
- * Description: Provides a utility class for representing and manipulating time values.
- *              Supports conversion between string and time formats, duration calculations
- *              (hours, minutes, seconds), date extraction, and comparison operators.
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
 #pragma once
 #include <ctime>
 #include <string>
@@ -1,24 +1,8 @@
-/*
- * File: Validator.cpp
- * Description: Validates inputs like phone number, email, password
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
-#include <string>
 #include <cctype>
 #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
-  */
-
 bool util::isPhoneNumberValid(const std::string& phoneNumber) {
 	if (phoneNumber.size() != 10)
 	{
@@ -32,18 +16,12 @@ bool util::isPhoneNumberValid(const std::string& phoneNumber) {
 	);
 }

-/*
- * Function: isEmailValid
- * Description: Validates whether the given string is a properly formatted email address.
- * Parameters:
- *    email - string containing the email address to validate
- * 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;
@@ -55,19 +33,6 @@ bool util::isEmailValid(const std::string& email) {
 	return true;
 }

-/*
- * Function: isPasswordValid
- * Description: Validates whether the given string meets password requirements.
- * Parameters:
- *    password - string containing the password to validate
- * Returns:
- *    bool - true if the password is valid, false otherwise
- * Notes:
- *    - Must not equal the default password
- *    - Must be at least 8 characters long
- *    - 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)
 {
@@ -107,3 +72,54 @@ bool util::isPasswordValid(const std::string& password)
 	}
 	return hasUpper && hasLower && hasDigit && hasSpecial;
 }
+
+bool util::hasActiveEmployeeOfType(Enums::EmployeeType employeeType, const std::map<std::string, std::shared_ptr<Employee>> & employees)
+{
+	for (const auto& employeePair : employees)
+	{
+		const auto& employee = employeePair.second;
+		if (employee->getEmployeeType() == employeeType && employee->getEmployeeAccountStatus() == Enums::AccountStatus::ACTIVE)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+bool util::isEmailDuplicate(const std::string& email, const std::map<std::string, std::shared_ptr<Employee>>& employees)
+{
+	for (const auto& employeePair : employees)
+	{
+		const auto& employee = employeePair.second;
+		if (employee->getEmployeeEmail() == email)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+bool util::isPhoneDuplicate(const std::string& phone, const std::map<std::string, std::shared_ptr<Employee>>& employees)
+{
+	for (const auto& employeePair : employees)
+	{
+		const auto& employee = employeePair.second;
+		if (employee->getEmployeePhone() == phone)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+bool util::isPhoneDuplicate(const std::string& phone, const std::vector<std::shared_ptr<const Employee>>& employees)
+{
+	for (const auto& employee : employees)
+	{
+		if (employee->getEmployeePhone() == phone)
+		{
+			return true;
+		}
+	}
+	return false;
+}
@@ -1,18 +1,21 @@
-/*
- * File: Validator.h
- * Description: Validates inputs like phone number, email, password
- * Author: Trenser
- * Created: 01-Apr-2026
- */
-
 #pragma once
 #include<string>
+#include<map>
+#include<memory>
+#include<vector>
 #include<algorithm>
 #include<cctype>
+#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<std::string, std::shared_ptr<Employee>>&);
+	bool isEmailDuplicate(const std::string&, const std::map<std::string, std::shared_ptr<Employee>>&);
+	bool isPhoneDuplicate(const std::string&, const std::map<std::string, std::shared_ptr<Employee>>&);
+	bool isPhoneDuplicate(const std::string&, const std::vector<std::shared_ptr<const Employee>>&);
 }
@@ -1,24 +1,9 @@
-/*
- * File: AdminMenu.cpp
- * Description: Handles user-related operations such as creation, authentication, and validation.
- * Author: Trenser
- * Created: 02-Apr-2026
- */
-
 #include <iostream>
 #include "AdminMenu.h"
 #include"InputHelper.h"
 #include"OutputHelper.h"
+#include "MenuHelper.h"

- /*
-  * Function: AdminMenu::run
-  * Description: Starts and manages the administrator menu loop. Continuously displays
-  *              options to the administrator until logout is selected or an exception occurs.
-  * Parameters:
-  *    None
-  * Returns:
-  *    None
-  */
 void AdminMenu::run()
 {
 	bool isMenuActive = true;
@@ -28,7 +13,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. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -43,35 +28,27 @@ void AdminMenu::run()
 	}
 }

-/*
- * Function: AdminMenu::handleOperation
- * Description: Processes the administrator’s menu choice and executes the corresponding action.
- * Parameters:
- *    choice - integer representing the selected menu option
- * Returns:
- *    true  - if the menu should remain active
- *    false - if the administrator chooses to logout
- */
 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;*/
 	case 5:
+		updateProfile(m_zenvyController);
+		break;
+	case 6:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
-}
+}
@@ -1,19 +1,13 @@
-/*
- * File: AdminMenu.h
- * Description: Declaration of the AdminMenu class and related functions.
- * Author: Trenser
- * Created: 02-Apr-2026
- */
-
 #pragma once
+#include<memory>
 #include"ZenvyController.h"

 class AdminMenu
 {
 private:
-	ZenvyController* m_zenvyController;
+	std::shared_ptr<ZenvyController> m_zenvyController;
 public:
-	AdminMenu() :m_zenvyController(new ZenvyController()) {};
+	AdminMenu() :m_zenvyController(std::make_shared<ZenvyController>()) {};
 	void run();
 	bool handleOperation(int);
 };
@@ -1,23 +1,10 @@
-/*
- * File: EmployeeMenu.cpp
- * Description: Implements the EmployeeMenu class functions including menu loop and operation handling.
- * Author: Trenser
- * Created: 02-Apr-2026
- */
-
 #include <iostream>
+#include<iomanip>
 #include "EmployeeMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"

- /*
-  * Function: EmployeeMenu::run
-  * Description: Starts the employee menu loop and displays available options until logout is selected
-  * Parameters:
-  *    None
-  * Returns:
-  *    None
-  */
 void EmployeeMenu::run()
 {
 	bool isMenuActive = true;
@@ -27,7 +14,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 Notification\n13. View Announcements\n14. Update Profile\n15. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -42,20 +29,12 @@ void EmployeeMenu::run()
 	}
 }

-/*
- * Function: EmployeeMenu::handleOperation
- * Description: Handles the employee’s menu choice and executes the corresponding action
- * Parameters:
- *    choice - integer representing the selected menu option
- * Returns:
- *    true  - if the menu should remain active
- *    false - if the employee chooses to logout
- */
 bool EmployeeMenu::handleOperation(int choice)
 {
 	switch (choice)
 	{
-	/*case 1:
+	/*
+	case 1:
 		m_zenvyController.applyLeave();
 		break;
 	case 2:
@@ -72,11 +51,11 @@ bool EmployeeMenu::handleOperation(int choice)
 		break;
 	case 6:
 		m_zenvyController.viewTicketHistory();
-		break;
+		break;*/
 	case 7:
-		m_zenvyController.viewEmployees();
+		viewEmployees(m_zenvyController);
 		break;
-	case 8:
+	/*case 8:
 		m_zenvyController.searchEmployee();
 		break;
 	case 9:
@@ -95,9 +74,13 @@ bool EmployeeMenu::handleOperation(int choice)
 		m_zenvyController.viewAnnouncements();
 		break;*/
 	case 14:
+		updateProfile(m_zenvyController);
+		break;
+	case 15:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
-}
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
joelthomastrenser	ed1cf4e306	Minor fixes and formatting updates in payroll, enums, and menus <SRS> SRS02 : Employee Management </SRS> <Changes> - Fixed variable naming issue in Payroll deserialization - Added braces for consistency in enum string-to-value helpers - Improved readability in validation logic - Corrected typo in Finance Executive payroll menu text </Changes> <Review> Smitha Mohan </Review>	2026-04-13 11:46:55 +05:30
joelthomastrenser	7fc468ac4b	Merge branch 'feature-employee-management' into feature-employee-management-emp007	2026-04-13 11:37:24 +05:30
joelthomastrenser	8668a615ea	Merged PR 957: Employee system updates - Cleaned up employee menus and selection flow - Fixed payroll ID issues and update logic - Added saving/loading for employees and payroll - Improved and centralized validation checks - Added FileManager for file handling and cleanup	2026-04-13 10:44:14 +05:30
joelthomastrenser	282ab721b5	Improved employee view formatting and menu text <SRS> SRS02 : Employee Management </SRS> <Changes> - Updated "View Employee" to "View Employees" in Admin Menu - Added clear screen and header for employee list display - Improved column spacing and alignment for better readability - Reordered fields for a cleaner layout - Added pressEnter prompt after viewing employees </Changes> <Review> Smitha Mohan </Review>	2026-04-11 17:54:20 +05:30
joelthomastrenser	2c9740e776	Merge branch 'feature-employee-management' into feature-employee-management-emp007	2026-04-11 17:41:57 +05:30
joelthomastrenser	aa21853a65	Refactored employee selection and cleaned up menu logic <SRS> SRS02 : Employee Management </SRS> <Changes> - Removed getSelectedUserId() from FinanceExecutiveMenu - Added reusable selectEmployeeId() in MenuHelper - Simplified deactivateEmployee() using common selection logic - Fixed missing break in HRManagerMenu </Changes> <Review> Smitha Mohan </Review>	2026-04-11 14:59:41 +05:30
joelthomastrenser	66c80fd055	Fixed payroll ID handling and improved payroll update flow <SRS> SRS02 : Employee Management </SRS> <Changes> - Fixed Payroll constructor to use given ID during deserialization - Cleaned up salary update logic in PayslipManagementService - Improved employee selection display in Finance menu - Added employee type column in selection list - Fixed typo in Employee menu (Ticket) - Added confirmation message after payroll update </Changes> <Review> Smitha Mohan </Review>	2026-04-11 12:58:09 +05:30
joelthomastrenser	47b44ccaa0	Added payroll persistance and updated Talent Acquisition role <SRS> SRS02 : Employee Management </SRS> <Changes> - Added Payroll getHeaders, serialize and deserialize functions - Stored payrolls in DataStore - Loaded and saved payrolls along with employees - Linked payroll to employees during creation and load - Added employeeId to Payroll - Renamed TAG role to TALENT_ACQUISITION across the project - Added missing TalentExecutive case in Employee deserialization - Added constructor to TalentExecutive for FileManager integration - Renamed ID counters to m_uid for consistency - Updated salary values in ApplicationConfig </Changes> <Review> Smitha Mohan </Review>	2026-04-11 12:13:23 +05:30
joelthomastrenser	1d94f1680c	Refactored validation logic and centralized employee validators <SRS> SRS02 : Employee Management </SRS> <Changes> - Moved employee validation logic (active type check, email and phone duplication) to Validator utility - Updated service to use util::hasActiveEmployeeOfType, util::isEmailDuplicate, and util::isPhoneDuplicate - Integrated validator usage in MenuHelper for input validation - Cleaned up formatting and minor inconsistencies </Changes> <Review> Smitha Mohan </Review>	2026-04-10 20:29:55 +05:30
joelthomastrenser	c50700e70c	Added CSV header support and persistence for employees <SRS> SRS02 : Employee Management </SRS> <Changes> - Added header handling in FileManager load by skipping first line during deserialization - Added support for writing headers using T::getHeaders() in FileManager save - Implemented getHeaders() for Employee and GeneralEmployee models - Added saveEmployees functionality in EmployeeManagementService - Added persistStates method in ZenvyController - Added deserialization failure check with exception handling - Minor formatting cleanup in FileIO </Changes> <Review> Smitha Mohan </Review>	2026-04-10 19:41:08 +05:30
joelthomastrenser	eac6fa72df	Added validation checks for employee creation <SRS> SRS02 : Employee Management </SRS> <Changes> - Added helper function to check for existing active employee of a given type - Enforced business rule to allow only one active employee per non-general type - Added duplicate email validation before employee creation - Added duplicate phone number validation before employee creation </Changes> <Review> Smitha Mohan </Review>	2026-04-10 16:43:28 +05:30
joelthomastrenser	03be8f81d2	Refactored employee creation menu and centralized helper logic <SRS> SRS02 : Employee Management </SRS> <Changes> - Removed duplicate employee creation helper functions from AdminMenu and HRManagerMenu - Centralized employee creation flow into MenuHelper.cpp - Updated createEmployee to use current employee type for access control - Fixed parameter order bug in createEmployee (email, name, phone) - Improved menu titles for all roles (removed generic system header) - Added util::pressEnter() for better UX on invalid input across menus - Added newline before pause in InputHelper::pressEnter - Cleaned up minor formatting issues </Changes>	2026-04-10 13:33:41 +05:30
joelthomastrenser	451ed4fec2	Added employee persistence, serialization, and file loading support <SRS>SRS02 : Employee Management </SRS> <Changes> - Implemented serialization and deserialization for Employee and GeneralEmployee models - Added FileManager integration to load employees from CSV files - Introduced ApplicationConfig entries for employee file paths - Updated Employee ID handling (getEmployeeId → getId) across project - Modified FileIO to auto-create file if not found instead of throwing exception - Added constructors for all employee types to support deserialization - Implemented loadEmployees in service and loadStates in controller - Ensured default admin creation if none exists during load - Added StringHelper utility for extracting numeric IDs - Extended Enums with string conversion and parsing utilities - Added initial CSV files for Employee and GeneralEmployee data - Improved login error message formatting and minor cleanup - Setup gitignore to not track csv files </Changes>	2026-04-10 13:17:50 +05:30
joelthomastrenser	d29e38ef75	Added FileManager DLL and cleanup code <SRS> SRS02 : Employee Management </SRS> <Changes> - Created FileIO for reading and writing files - Created FileManager to use FileIO - Set up Trenser.FileManager as a DLL - Linked DLL with Trenser.Zenvy project - Fixed duplicate function issue by marking deactivateEmployee as inline - Cleaned up unused methods in controller and service </Changes> <Review> Smitha Mohan </Review>	2026-04-09 20:32:48 +05:30
Princy Jerin	2031f510d5	Merged PR 932: UserStory EMP002 Deactivate Employee Related work items: #946	2026-04-08 11:50:23 +05:30
joelthomastrenser	4d4974efd7	Protect Admin account from deactivation <UserStory> EMP002 : Deactivate Employee </UserStory> <Changes> - Ensure admin account cannot be deactivated </Changes> <Review> Smitha Mohan </Review>	2026-04-08 11:47:00 +05:30
joelthomastrenser	a955b64462	Ensure Role based access <UserStory> EMP002 : Deactivate Employee </UserStory> <Changes> - Ensure Role based access </Changes> <Review> Smitha Mohan </Review>	2026-04-08 11:41:31 +05:30
Princy Jerin	daf33e1aab	Implement Review Fixes <UserStory> EMP002 : Deactivate Employee </UserStory> <Changes> - Updated employee listing to display in a tabular format with headers - Renamed helper function from listActiveEmployees to listEmployees - Updated error messages - Removed blank spaces </Changes> <Review> Smitha Mohan </Review>	2026-04-08 11:41:25 +05:30
Princy Jerin	f85614ecc5	Implement Deactive Employee functionality <UserStory> EMP002 : Deactivate Employee </UserStory> <Changes> - Added deactivateEmployee logic to set employee status to INACTIVE - Enabled Deactivate Employee option in AdminMenu - Implemented listing of active employees for selection - Connected UI flow for employee deactivation - Fix minor syntax issues </Changes> <Review> Smitha Mohan </Review>	2026-04-08 11:36:50 +05:30
Tinu Johnson	e470dbc791	Updated MenuHelper.h <UserStory> EMP007 : View Employees </UserStory> <Changes> - Updated logic in viewEmployees() method. </Changes> <Review> Smitha Mohan </Review>	2026-04-08 11:04:09 +05:30
Jissin Mathew	a001b7d159	Merged PR 921: UserStory EMP008 Update Salary Details Related work items: #953	2026-04-08 10:24:42 +05:30
Jissin Sam Mathew	0290467528	Implement Review Suggestion <UserStory>EMP008: Update Salary Details</UserStory> <Changes> - Refactored salary update and employee selection: • Removed unnecessary const qualifiers from double parameters • Renamed variables • Replaced count() with find() for map lookups • Excluded ADMIN employees from salary updates and selection lists • Applied util::enforceAuthorization for access control - Improved readability and consistency: • Enhanced tabular output using setw() with left alignment Implement Update Salary </Changes> <Review> Smitha Mohan </Review>	2026-04-08 10:18:23 +05:30
Jissin Sam Mathew	63627075ef	Implement Update Salary <UserStory>EMP08: Update Salary Details</UserStory> <Changes> - Added `updateSalary` method in ZenvyController to connect payroll updates with PayslipManagementService - Implemented `PayslipManagementService::updateSalary` with employee existence and Finance-role authorization checks - Extended Payroll model with setter methods for salary components - Improved error handling with clear runtime exceptions for invalid index selection, unauthorized access, and missing employees </Changes> <Review> Smitha Mohan </Review>	2026-04-08 10:17:16 +05:30
Tinu Johnson	c27ca5240a	Added MenuHelper feature for ViewEmployee <UserStory> EMP007 : View Employees </UserStory> <Changes> - Added MenuHelper.cpp and MenuHelper.h to project configuration - Moved viewEmployees() implementation from individual menu classes into MenuHelper - Added inline viewEmployees(shared_ptr<ZenvyController>) helper with formatted output - Added enumToString() to MenuHelper for employee role display - Updated AdminMenu, EmployeeMenu, FinanceExecutiveMenu, HRManagerMenu, ITExecutiveMenu, TalentExecutiveMenu, TeamExecutiveMenu, and TeamLeadMenu to use viewEmployees(m_zenvyController) instead of per‑menu implementations - Removed old viewEmployees() method from EmployeeMenu - Updated menu options to reflect new centralized viewEmployees() function </Changes> <Review> Smitha Mohan </Review>	2026-04-07 20:32:30 +05:30
Tinu Johnson	f75bbaaae8	Merged PR 933: UserStory EMP004 Update Personal Details Related work items: #948	2026-04-07 20:31:25 +05:30
Tinu Johnson	b3b9299c70	Added Profile Update Feature for all menu <UserStory> EMP004 : Update Personal Details </UserStory> <Changes> - Added MenuHelper.cpp and MenuHelper.h and integrated them into project - Moved updateProfile() logic from individual menus into MenuHelper - Added inline updateProfile(shared_ptr<ZenvyController>) to MenuHelper - Updated AdminMenu, EmployeeMenu, HRManagerMenu, FinanceExecutiveMenu, ITExecutiveMenu, TalentExecutiveMenu, TeamExecutiveMenu, and TeamLeadMenu to use centralized updateProfile() - Added getCurrentEmployee() and updateProfile() to ZenvyController - Added corresponding implementations in EmployeeManagementService - Minor layout and option text improvements across all menus </Changes> <Review> Smitha Mohan </Review>	2026-04-07 20:25:33 +05:30
Tinu Johnson	6256b9ea82	Implement Review fixes <UserStory> EMP007 : View All Employees </UserStory> <Changes> - Added check for empty employee map - Filtered only ACTIVE employees - Added formatted table using <iomanip> in EmplopyeeMenu::viewEmployee() - Added check for empty employee list </Changes> <Review> Smitha Mohan </Review>	2026-04-07 19:19:08 +05:30
Tinu Johnson	1785660e94	Add Employee Listing Feature <UserStory> EMP007 : View All Employees </UserStory> <Changes> - Implemented getEmployees() in ZenvyController to return list of employees - Added working getEmployees() implementation in EmployeeManagementService - Fixed iterator usage to correctly extract map values into Employees vector - Added viewEmployees() UI flow in EmployeeMenu - Integrated employee listing into EmployeeMenu option flow - Added enumToString() helper for printing employee roles - Improved formatting and filtering of ACTIVE employees in employee listing - Performed minor code cleanup and consistency adjustments in controller and menu </Changes> <Review> Smitha Mohan </Review>	2026-04-07 17:38:53 +05:30
joelthomastrenser	247e5dc6f6	Merged PR 920: UserStory EMP001 Create Employee Related work items: #943	2026-04-07 17:36:30 +05:30
joelthomastrenser	ef5ac42a92	Implement employee creation <UserStory>EMP001 Create Employee</UserStory> <Changes> - Updated employee creation flow to support different employee types and designations - Set a default initial password for new employees - Added basic authorization check utility - Cleaned up employee model constructors for better consistency Minor code cleanup and refactoring </Changes> <Review> Smitha Mohan </Review>	2026-04-07 15:07:44 +05:30
joelthomastrenser	07bd979685	Set up employee management codebase <SRS>SRS02 : Employee Management </SRS> <Changes> - Renamed EmployeeManagememtService to EmployeeManagementService - Added basic employee management service structure - Connected employee management into controller and datastore - Updated project config files - Added auto ID generation across models - Added payroll-related config constants </Changes> <Review> Smitha Mohan </Review>	2026-04-07 10:51:38 +05:30