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>

.gitignore

@@ -426,3 +426,6 @@ FodyWeavers.xsd
 *.msix
 *.msm
 *.msp
+
+# CSV Files
+*.csv

Trenser.FileManager/Trenser.FileManager/FileIO.cpp

@@ -0,0 +1,28 @@
+#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';
+}

Trenser.FileManager/Trenser.FileManager/FileIO.h

@@ -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);
+};

Trenser.FileManager/Trenser.FileManager/FileManager.h

@@ -0,0 +1,41 @@
+#pragma once
+#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);
+	for (const auto& record : lines)
+	{
+		auto object = T::deserialize(record);
+		records[object->getId()] = object;
+	}
+	return records;
+}
+
+template <typename T>
+void FileManager<T>::save(const objects<T>& records)
+{
+	std::vector<std::string> lines;
+
+	for (const auto& recordPair : records)
+	{
+		lines.push_back(recordPair.second->serialize());
+	}
+	FileIO::writeAllLines(m_filePath, lines);
+}

Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj

@@ -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>

Trenser.FileManager/Trenser.FileManager/Trenser.FileManager.vcxproj.filters

@@ -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>

Trenser.FileManager/Trenser.FileManager/pch.h

@@ -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

Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.cpp

@@ -1,4 +1,5 @@
 #include "UserInterface.h"
+#include "FileManager.h"
 int main()
 {
 	UserInterface userInterFace;

Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj

@@ -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" />

Trenser.Zenvy/Trenser.Zenvy/Trenser.Zenvy.vcxproj.filters

@@ -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">

Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.cpp

@@ -1,7 +1,7 @@
 #include "ZenvyController.h"
 
 //Authentication
-AuthenticationContext ZenvyController::login(const std::string& email, const std::string& password)
+AuthenticationDTO ZenvyController::login(const std::string& email, const std::string& password)
 {
 	return m_authenticationManagementService->login(email, password);
 }
@@ -15,3 +15,39 @@ void ZenvyController::changePassword(const std::string& password)
 {
 	m_authenticationManagementService->changePassword(password);
 }
+
+//Employee Management
+void ZenvyController::createEmployee(Enums::EmployeeType employeeType, Enums::EmployeeDesignation employeeDesignation, const std::string& email,  const std::string& name, const std::string& phone)
+{
+	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();
+}

Trenser.Zenvy/Trenser.Zenvy/controllers/ZenvyController.h

@@ -4,7 +4,7 @@
 #include "AuthenticationManagementService.h"
 #include "AttendanceManagementService.h"
 #include "BookingManagementService.h"
-#include "EmployeeManagememtService.h"
+#include "EmployeeManagementService.h"
 #include "LeaveManagementService.h"
 #include "NotificationManagementService.h"
 #include "PayslipManagementService.h"
@@ -13,15 +13,13 @@
 #include "TicketManagementService.h"
 #include "Enums.h"
 
-using AuthenticationContext = std::tuple<Enums::LoginStatus, Enums::EmployeeType, Enums::EmployeeDesignation>;
-
 class ZenvyController
 {
 private:
 	std::shared_ptr<AuthenticationManagementService> m_authenticationManagementService;
 	std::shared_ptr<AttendanceManagementService> m_attendanceManagementService;
 	std::shared_ptr<BookingManagementService> m_bookingManagementService;
-	std::shared_ptr<EmployeeManagememtService> m_employeeManagememtService;
+	std::shared_ptr<EmployeeManagementService> m_employeeManagementService;
 	std::shared_ptr<LeaveManagementService> m_leaveManagementService;
 	std::shared_ptr<NotificationManagementService> m_notificationManagementService;
 	std::shared_ptr<PayslipManagementService> m_payslipManagementService;
@@ -33,7 +31,7 @@ public:
 		m_authenticationManagementService(std::make_shared<AuthenticationManagementService>()), 
 		m_attendanceManagementService(std::make_shared<AttendanceManagementService>()), 
 		m_bookingManagementService(std::make_shared<BookingManagementService>()),
-		m_employeeManagememtService(std::make_shared<EmployeeManagememtService>()),
+		m_employeeManagementService(std::make_shared<EmployeeManagementService>()),
 		m_leaveManagementService(std::make_shared<LeaveManagementService>()),
 		m_notificationManagementService(std::make_shared<NotificationManagementService>()),
 		m_payslipManagementService(std::make_shared<PayslipManagementService>()),
@@ -42,7 +40,20 @@ public:
 		m_ticketManagementService(std::make_shared<TicketManagementService>()) {};
 		
 		//Authentication
-		AuthenticationContext login(const std::string& email, const std::string& password);
+		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();
 };

Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.cpp

@@ -1,4 +1,5 @@
 #include "DataStore.h"
+#include "EmployeeManagementService.h"
 
 DataStore& DataStore::getInstance()
 {
@@ -26,8 +27,4 @@ employeeMap& DataStore::getEmployees()
 	return m_employees;
 }
 
-std::shared_ptr<Employee>& DataStore::getAuthenticatedUser()
-{
-	return m_authenticatedEmployee;
-}
 

Trenser.Zenvy/Trenser.Zenvy/datastores/DataStore.h

@@ -36,7 +36,6 @@ public:
     DataStore(DataStore&&) = delete;
     DataStore& operator=(DataStore&&) = delete;
 	employeeMap& getEmployees();
-    std::shared_ptr<Employee>& getAuthenticatedUser();
     logMap& getLogs();
     std::shared_ptr<Employee>& getAuthenticatedEmployee();
     void setAuthenticatedEmployee(std::shared_ptr < Employee>);

Trenser.Zenvy/Trenser.Zenvy/models/Admin.h

@@ -3,4 +3,30 @@
 
 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;
 };

Trenser.Zenvy/Trenser.Zenvy/models/Announcement.cpp

@@ -1,5 +1,7 @@
 #include "Announcement.h"
 
+int Announcement::m_anid = 0;
+
 const std::string& Announcement::getAnnouncementId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Announcement.h

@@ -5,14 +5,14 @@
 class Announcement
 {
 private:
+    static int m_anid;
     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_anid)), m_timestamp(), m_message("") {}
+    Announcement(const std::string& message)
+        : m_id("AN" + std::to_string(++m_anid)), m_message(message) {}
     const std::string& getAnnouncementId() const;
     const util::Timestamp& getAnnouncementTimestamp() const;
     const std::string& getAnnouncementMessage() const;

Trenser.Zenvy/Trenser.Zenvy/models/Attendance.cpp

@@ -1,5 +1,7 @@
 #include "Attendance.h"
 
+int Attendance::m_aid = 0;
+
 const std::string& Attendance::getAttendanceId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Attendance.h

@@ -5,15 +5,15 @@
 class Attendance
 {
 private:
+    static int m_aid;
     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_aid)), 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_aid)), m_loginTime(loginTime), m_logoutTime(logoutTime) {}
     const std::string& getAttendanceId() const;
     const util::Timestamp& getLoginTime() const;
     const util::Timestamp& getLogoutTime() const;

Trenser.Zenvy/Trenser.Zenvy/models/Booking.cpp

@@ -1,5 +1,7 @@
 #include "Booking.h"
 
+int Booking::m_bid = 0;
+
 const std::string& Booking::getBookingId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Booking.h

@@ -7,19 +7,19 @@
 class Booking
 {
 private:
+    static int m_bid;
     std::string m_id;
     util::Timestamp m_startTime;
     util::Timestamp m_endTime;
     std::string m_employeeId;
     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_bid)), m_startTime(), m_endTime(), m_employeeId(""), m_team(nullptr) {}
+    Booking(const util::Timestamp& startTime,
         const util::Timestamp& endTime,
         const std::string& employeeId,
         std::shared_ptr<Team> team)
-        : m_id(id), m_startTime(startTime), m_endTime(endTime), m_employeeId(employeeId), m_team(team) {}
+        : m_id("BK" + std::to_string(++m_bid)), 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;

Trenser.Zenvy/Trenser.Zenvy/models/Candidate.cpp

@@ -1,5 +1,7 @@
 #include "Candidate.h"
 
+int Candidate::m_cid = 0;
+
 const std::string& Candidate::getCandidateId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Candidate.h

@@ -5,19 +5,19 @@
 class Candidate
 {
 private:
+    static int m_cid;
     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_cid)), 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_cid)), 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;

Trenser.Zenvy/Trenser.Zenvy/models/Employee.cpp

@@ -1,6 +1,45 @@
+#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"
 
-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;
 }
@@ -128,3 +167,99 @@ 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::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;
+    }
+}

Trenser.Zenvy/Trenser.Zenvy/models/Employee.h

@@ -7,13 +7,15 @@
 #include "Leave.h"
 #include "Payroll.h"
 #include "Enums.h"
+#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;
@@ -28,17 +30,41 @@ private:
     leaveMap m_leaves;
     Enums::EmployeeType m_employeeType;
 public:
-    Employee() : m_id(""), m_password(""), m_name(""), m_phone(""), m_email(""), m_accountStatus(Enums::AccountStatus::ACTIVE), m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM), m_teamId(""), m_employeeType(Enums::EmployeeType::GENERAL) {}
-    Employee(const std::string& id,
-        const std::string& password,
-        const std::string& name,
+    Employee()
+        : m_id("EMP" + std::to_string(++m_uid)),
+        m_password(Config::Authentication::DEFAULT_PASSWORD),
+        m_name(""),
+        m_phone(""),
+        m_email(""),
+        m_accountStatus(Enums::AccountStatus::ACTIVE),
+        m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM),
+        m_teamId(""),
+        m_employeeType(Enums::EmployeeType::GENERAL) {}
+    Employee(const std::string& name,
         const std::string& phone,
         const std::string& email,
-        const std::string& teamId,
         Enums::EmployeeType employeeType,
         std::shared_ptr<Payroll> payroll)
-        : m_id(id), m_password(password), m_name(name), m_phone(phone), m_email(email), m_accountStatus(Enums::AccountStatus::ACTIVE), m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM), m_teamId(teamId), m_employeeType(employeeType), m_payroll(payroll) { }
-    const std::string& getEmployeeId() const;
+        : m_id("EMP" + std::to_string(++m_uid)),
+        m_password(Config::Authentication::DEFAULT_PASSWORD),
+        m_name(name),
+        m_phone(phone),
+        m_email(email),
+        m_accountStatus(Enums::AccountStatus::ACTIVE),
+        m_teamStatus(Enums::TeamStatus::NOT_IN_TEAM),
+        m_teamId(""),
+        m_employeeType(employeeType),
+        m_payroll(payroll) {}
+    Employee(const std::string& id,
+        const std::string& name,
+        const std::string& phone,
+        const std::string& password,
+        const std::string& email,
+        const std::string& teamId,
+        Enums::TeamStatus teamStatus,
+        Enums::EmployeeType employeeType,
+        Enums::AccountStatus accountStatus);
+    const std::string& getId() const;
     const std::string& getEmployeePassword() const;
     const std::string& getEmployeeName() const;
     const std::string& getEmployeePhone() const;
@@ -62,5 +88,7 @@ public:
     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&);
     virtual ~Employee() = default;
 };

Trenser.Zenvy/Trenser.Zenvy/models/FinanceExecutive.h

@@ -3,5 +3,31 @@
 
 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;
 };
 

Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.cpp

@@ -1,4 +1,6 @@
+#include <sstream>
 #include "GeneralEmployee.h"
+#include "Factory.h"
 
 Enums::EmployeeDesignation GeneralEmployee::getDesignation() const
 {
@@ -8,4 +10,52 @@ 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
+    );
 }

Trenser.Zenvy/Trenser.Zenvy/models/GeneralEmployee.h

@@ -7,16 +7,41 @@ class GeneralEmployee : public Employee
 private:
     Enums::EmployeeDesignation m_designation;
 public:
-    GeneralEmployee() : m_designation(Enums::EmployeeDesignation::JUNIOR) {}
-    GeneralEmployee(const std::string& id,
-        const std::string& password,
-        const std::string& name,
+    GeneralEmployee()
+        : m_designation(Enums::EmployeeDesignation::JUNIOR) {}
+    GeneralEmployee(const std::string& name,
         const std::string& phone,
         const std::string& email,
-        const std::string& teamId,
         std::shared_ptr<Payroll> payroll,
-        Enums::EmployeeDesignation designation) : Employee(id, password, name, phone, email, teamId,Enums::EmployeeType::GENERAL, payroll), m_designation(designation) {}
+        Enums::EmployeeDesignation designation)
+        : Employee(name,
+            phone,
+            email,
+            Enums::EmployeeType::GENERAL,
+            payroll),
+        m_designation(designation) {}
+    GeneralEmployee(const std::string& id,
+        const std::string& name,
+        const std::string& phone,
+        const std::string& password,
+        const std::string& email,
+        const std::string& teamId,
+        Enums::TeamStatus teamStatus,
+        Enums::EmployeeDesignation employeeDesignation,
+        Enums::AccountStatus accountStatus)
+        : Employee(id,
+            name,
+            phone,
+            password,
+            email,
+            teamId,
+            teamStatus,
+            Enums::EmployeeType::GENERAL,
+            accountStatus),
+        m_designation(employeeDesignation) {}
     Enums::EmployeeDesignation getDesignation() const;
     void setDesignation(Enums::EmployeeDesignation designation);
+    std::string serialize() const override;
+    static std::shared_ptr<GeneralEmployee> deserialize(const std::string&);
     ~GeneralEmployee() = default;
 };

Trenser.Zenvy/Trenser.Zenvy/models/HRManager.h

@@ -3,5 +3,31 @@
 
 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;
 };
 

Trenser.Zenvy/Trenser.Zenvy/models/ITExecutive.h

@@ -3,5 +3,31 @@
 
 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;
 };
 

Trenser.Zenvy/Trenser.Zenvy/models/JobListing.cpp

@@ -1,5 +1,7 @@
 #include "JobListing.h"
 
+int JobListing::m_jid = 0;
+
 const std::string& JobListing::getJobId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/JobListing.h

@@ -9,6 +9,7 @@ using candidateMap = std::map<std::string, std::shared_ptr<Candidate>>;
 class JobListing
 {
 private:
+    static int m_jid;
     std::string m_id;
     std::string m_name;
     std::string m_description;
@@ -16,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_jid)), 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_jid)), 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;

Trenser.Zenvy/Trenser.Zenvy/models/Leave.cpp

@@ -1,5 +1,7 @@
 #include "Leave.h"
 
+int Leave::m_lid = 0;
+
 const std::string& Leave::getLeaveId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Leave.h

@@ -6,6 +6,7 @@
 class Leave
 {
 private:
+    static int m_lid;
     std::string m_id;
     std::string m_employeeId;
     util::Timestamp m_timestamp;
@@ -15,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_lid)), 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_lid)), 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;

Trenser.Zenvy/Trenser.Zenvy/models/Notification.cpp

@@ -1,5 +1,7 @@
 #include "Notification.h"
 
+int Notification::m_nid = 0;
+
 const std::string& Notification::getNotificationId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Notification.h

@@ -6,18 +6,18 @@
 class Notification
 {
 private:
+    static int m_nid;
     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_nid)), 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_nid)), m_employeeId(employeeId), m_message(message), m_notificationStatus(notificationStatus) {}
     const std::string& getNotificationId() const;
     const std::string& getEmployeeId() const;
     const std::string& getNotificationMessage() const;

Trenser.Zenvy/Trenser.Zenvy/models/Payroll.cpp

@@ -1,5 +1,7 @@
 #include "Payroll.h"
 
+int Payroll::m_prid = 0;
+
 const std::string& Payroll::getPayrollId() const
 {
     return m_id;
@@ -30,9 +32,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)

Trenser.Zenvy/Trenser.Zenvy/models/Payroll.h

@@ -4,6 +4,7 @@
 class Payroll
 {
 private:
+    static int m_prid;
     std::string m_id;
     double m_basicSalary;
     double m_houseRentAllowance;
@@ -11,23 +12,22 @@ private:
     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_prid)), 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) {}
+        : m_id("PR" + std::to_string(++m_prid)), m_basicSalary(basicSalary), m_houseRentAllowance(houseRentAllowance), m_foodAllowance(foodAllowance), m_employeePFContribution(employeePFContribution), m_employerPFContribution(employerPFContribution) {}
     const std::string& getPayrollId() const;
     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);
 };

Trenser.Zenvy/Trenser.Zenvy/models/Payslip.cpp

@@ -1,5 +1,7 @@
 #include "Payslip.h"
 
+int Payslip::m_pid = 0;
+
 const std::string& Payslip::getPayslipId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Payslip.h

@@ -4,11 +4,12 @@
 class Payslip
 {
 private:
+    static int m_pid;
     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_pid)), m_salary(0.0) {}
+    Payslip(const double salary) : m_id("PS" + std::to_string(++m_pid)), m_salary(salary) {}
     const std::string& getPayslipId() const;
     double getSalary() const;
     void setPayslipId(const std::string& id);

Trenser.Zenvy/Trenser.Zenvy/models/Room.cpp

@@ -1,5 +1,7 @@
 #include "Room.h"
 
+int Room::m_rid = 0;
+
 const std::string& Room::getRoomId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Room.h

@@ -8,12 +8,13 @@ using bookingMap = std::map<std::string, std::shared_ptr<Booking>>;
 class Room
 {
 private:
+    static int m_rid;
     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_rid)), m_name("") {}
+    Room(const std::string& name) : m_id("RM" + std::to_string(++m_rid)), m_name(name) {}
     const std::string& getRoomId() const;
     const std::string& getRoomName() const;
     const bookingMap& getBookings() const;

Trenser.Zenvy/Trenser.Zenvy/models/TalentExecutive.h

@@ -3,5 +3,14 @@
 
 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::TAG, payroll) {};
+    ~TalentExecutive() = default;
 };
 

Trenser.Zenvy/Trenser.Zenvy/models/Team.cpp

@@ -1,5 +1,7 @@
 #include "Team.h"
 
+int Team::m_tmid = 0;
+
 const std::string& Team::getTeamId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Team.h

@@ -8,18 +8,19 @@ using employeeMap = std::map<std::string, std::shared_ptr<Employee>>;
 class Team
 {
 private:
+    static int m_tmid;
     std::string m_id;
     std::string m_name;
     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_tmid)), m_name(""), m_lead(nullptr), m_maximumNumberOfEmployees(0) {}
+    Team(
         const std::string& name,
         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_tmid)), m_name(name), m_lead(lead), m_maximumNumberOfEmployees(maximumNumberOfEmployees) {
     }
     const std::string& getTeamId() const;
     const std::string& getTeamName() const;

Trenser.Zenvy/Trenser.Zenvy/models/TeamExecutive.h

@@ -3,5 +3,31 @@
 
 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;
 };
 

Trenser.Zenvy/Trenser.Zenvy/models/Ticket.cpp

@@ -1,5 +1,7 @@
 #include "Ticket.h"
 
+int Ticket::m_tid = 0;
+
 const std::string& Ticket::getTicketId() const
 {
     return m_id;

Trenser.Zenvy/Trenser.Zenvy/models/Ticket.h

@@ -5,19 +5,20 @@
 class Ticket
 {
 private:
+    static int m_tid;
     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_tid)), 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_tid)), 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;

Trenser.Zenvy/Trenser.Zenvy/services/ApplicationConfig.h

@@ -2,5 +2,38 @@
 
 namespace Config
 {
-	constexpr const char* DEFAULT_PASSWORD = "password";
+	namespace Authentication
+	{
+		constexpr const char* DEFAULT_PASSWORD = "password";
+	}
+
+	namespace Payroll
+	{
+		constexpr double SENIOR_BASIC_SALARY = 0.0;
+		constexpr double SENIOR_HOUSE_RENT_ALLOWANCE = 0.0;
+		constexpr double SENIOR_FOOD_ALLOWANCE = 0.0;
+		constexpr double SENIOR_EMPLOYEE_PF_CONTRIBUTION = 0.0;
+		constexpr double SENIOR_EMPLOYER_PF_CONTRIBUTION = 0.0;
+		constexpr double JUNIOR_BASIC_SALARY = 0.0;
+		constexpr double JUNIOR_HOUSE_RENT_ALLOWANCE = 0.0;
+		constexpr double JUNIOR_FOOD_ALLOWANCE = 0.0;
+		constexpr double JUNIOR_EMPLOYEE_PF_CONTRIBUTION = 0.0;
+		constexpr double JUNIOR_EMPLOYER_PF_CONTRIBUTION = 0.0;
+		constexpr double HR_MANAGER_BASIC_SALARY = 0.0;
+		constexpr double HR_MANAGER_HOUSE_RENT_ALLOWANCE = 0.0;
+		constexpr double HR_MANAGER_FOOD_ALLOWANCE = 0.0;
+		constexpr double HR_MANAGER_EMPLOYEE_PF_CONTRIBUTION = 0.0;
+		constexpr double HR_MANAGER_EMPLOYER_PF_CONTRIBUTION = 0.0;
+		constexpr double EXECUTIVE_BASIC_SALARY = 0.0;
+		constexpr double EXECUTIVE_HOUSE_RENT_ALLOWANCE = 0.0;
+		constexpr double EXECUTIVE_FOOD_ALLOWANCE = 0.0;
+		constexpr double EXECUTIVE_EMPLOYEE_PF_CONTRIBUTION = 0.0;
+		constexpr double EXECUTIVE_EMPLOYER_PF_CONTRIBUTION = 0.0;
+	}
+
+	namespace File
+	{
+		constexpr const char* EMPLOYEES_FILE = "files/Employee.csv";
+		constexpr const char* GENERAL_EMPLOYEES_FILE = "files/GeneralEmployee.csv";
+	}
 }

Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.cpp

@@ -2,7 +2,7 @@
 #include "AuthenticationManagementService.h"
 #include "ApplicationConfig.h"
 
-std::tuple<Enums::LoginStatus, Enums::EmployeeType, Enums::EmployeeDesignation> AuthenticationManagementService::login(const std::string& email, const std::string& password)
+AuthenticationDTO AuthenticationManagementService::login(const std::string& email, const std::string& password)
 {
 	employeeMap& employees = m_dataStore.getEmployees();
 	Enums::LoginStatus loginStatus = Enums::LoginStatus::USER_NOT_FOUND;
@@ -14,7 +14,7 @@ std::tuple<Enums::LoginStatus, Enums::EmployeeType, Enums::EmployeeDesignation>
 		{
 			if (employee.second->getEmployeePassword() == password)
 			{
-				if (password == Config::DEFAULT_PASSWORD)
+				if (password == Config::Authentication::DEFAULT_PASSWORD)
 				{
 					loginStatus = Enums::LoginStatus::FIRST_LOGIN;
 				}
@@ -49,7 +49,7 @@ std::tuple<Enums::LoginStatus, Enums::EmployeeType, Enums::EmployeeDesignation>
 
 void AuthenticationManagementService::changePassword(const std::string& password)
 {
-	std::shared_ptr<Employee> authenticatedUser = m_dataStore.getAuthenticatedUser();
+	std::shared_ptr<Employee> authenticatedUser = m_dataStore.getAuthenticatedEmployee();
 	if (authenticatedUser)
 	{
 		authenticatedUser->setEmployeePassword(password);
@@ -61,8 +61,8 @@ void AuthenticationManagementService::changePassword(const std::string& password
 }
 
 void AuthenticationManagementService::logout() {
-	if (m_dataStore.getAuthenticatedUser()) {
-		m_dataStore.getAuthenticatedUser() = nullptr;
+	if (m_dataStore.getAuthenticatedEmployee()) {
+		m_dataStore.getAuthenticatedEmployee() = nullptr;
 	}
 	else {
 		throw std::runtime_error("No user currently logged In...");

Trenser.Zenvy/Trenser.Zenvy/services/AuthenticationManagementService.h

@@ -1,18 +1,21 @@
 #pragma once
 #include <string>
 #include <map>
+#include <tuple>
 #include <utility>
 #include <stdexcept>
 #include "DataStore.h"
 #include "Enums.h"
 
+using AuthenticationDTO = std::tuple<Enums::LoginStatus, Enums::EmployeeType, Enums::EmployeeDesignation>;
+
 class AuthenticationManagementService
 {
 private:
 	DataStore& m_dataStore;
 public:
 	AuthenticationManagementService() : m_dataStore(DataStore::getInstance()) {};
-	std::tuple<Enums::LoginStatus, Enums::EmployeeType, Enums::EmployeeDesignation> login(const std::string& username, const std::string& password);
+	AuthenticationDTO login(const std::string& username, const std::string& password);
 	void logout();
 	void changePassword(const std::string&);
 };

Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.cpp

@@ -1 +0,0 @@
-#include "EmployeeManagememtService.h"

Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagememtService.h

@@ -1,5 +0,0 @@
-#pragma once
-class EmployeeManagememtService
-{
-};
-

Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.cpp

@@ -0,0 +1,223 @@
+#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"
+
+static bool hasActiveEmployeeOfType(Enums::EmployeeType employeeType, const employeeMap& employees)
+{
+	for (const auto& employeePair : employees)
+	{
+		const auto& employee = employeePair.second;
+		if (employee->getEmployeeType() == employeeType && employee->getEmployeeAccountStatus() == Enums::AccountStatus::ACTIVE)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+static bool isEmailDuplicate(const std::string& email, const employeeMap& employees)
+{
+	for (const auto& employeePair : employees)
+	{
+		const auto& employee = employeePair.second;
+		if (employee->getEmployeeEmail() == email)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+static bool isPhoneDuplicate(const std::string& phone, const employeeMap& employees)
+{
+	for (const auto& employeePair : employees)
+	{
+		const auto& employee = employeePair.second;
+		if (employee->getEmployeePhone() == phone)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+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 && 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 (isEmailDuplicate(email, employees))
+	{
+		throw std::runtime_error("Duplicate Email");
+	}
+	if (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::TAG:
+		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::TAG:
+			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");
+	}
+	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));
+	}
+}

Trenser.Zenvy/Trenser.Zenvy/services/EmployeeManagementService.h

@@ -0,0 +1,21 @@
+#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();
+};

Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.cpp

@@ -1 +1,21 @@
 #include "PayslipManagementService.h"
+#include "AuthorizationHelper.h"
+#include "Enums.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)
+	{
+		(employee->second)->getPayroll()->setBasicSalary(basicSalary);
+		(employee->second)->getPayroll()->setHouseRentAllowance(houseRentAllowance);
+		(employee->second)->getPayroll()->setFoodAllowance(foodAllowance);
+		(employee->second)->getPayroll()->setEmployeePFContribution(employeePFContribution);
+		(employee->second)->getPayroll()->setEmployerPFContribution(employerPFContribution);
+	}
+	else
+	{
+		throw std::runtime_error("Employee not found, unable to update the salary");
+	}
+}

Trenser.Zenvy/Trenser.Zenvy/services/PayslipManagementService.h

@@ -1,5 +1,13 @@
 #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);
 };
-

Trenser.Zenvy/Trenser.Zenvy/utilities/AuthorizationHelper.cpp

@@ -0,0 +1 @@
+#include "AuthorizationHelper.h"

Trenser.Zenvy/Trenser.Zenvy/utilities/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!");
+        }
+    }
+}

Trenser.Zenvy/Trenser.Zenvy/utilities/Enums.h

@@ -1,4 +1,5 @@
 #pragma once
+#include <string>
 
 namespace Enums {
 
@@ -89,4 +90,120 @@ 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::TAG:
+            return "TAG";
+        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 == "TAG")
+            return EmployeeType::TAG;
+        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;
+    }
 }

Trenser.Zenvy/Trenser.Zenvy/utilities/InputHelper.h

@@ -25,6 +25,7 @@ namespace util
 
     inline void pressEnter()
     {
+        std::cout << std::endl;
 	    system("pause");
     }
 }

Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.cpp

@@ -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;
+}

Trenser.Zenvy/Trenser.Zenvy/utilities/StringHelper.h

@@ -0,0 +1,7 @@
+#pragma once
+#include <string>
+
+namespace util
+{
+    int extractNumber(const std::string&);
+}

Trenser.Zenvy/Trenser.Zenvy/utilities/Validator.cpp

@@ -33,7 +33,7 @@ bool util::isEmailValid(const std::string& email) {
 
 bool util::isPasswordValid(const std::string& password)
 {
-	if (password == Config::DEFAULT_PASSWORD)
+	if (password == Config::Authentication::DEFAULT_PASSWORD)
 	{
 		return false;
 	}

Trenser.Zenvy/Trenser.Zenvy/views/AdminMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "AdminMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void AdminMenu::run()
 {
@@ -12,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 Employee\n3. Deactivate Employee\n4. Search Employee\n5. Update Profile\n6. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -31,22 +32,23 @@ bool AdminMenu::handleOperation(int choice)
 {
 	switch (choice)
 	{
-	/*case 1:
-		m_zenvyController.createHRManager();
+	case 1:
+		createEmployee(m_zenvyController);
 		break;
-	case 2:
-		m_zenvyController.createEmployee();
-		break;
-	case 3:
+	/*case 2:
 		m_zenvyController.viewEmployee();
-		break;
-	case 4:
-		m_zenvyController.deactivateEmployee();
 		break;*/
+	case 3:
+		deactivateEmployee(m_zenvyController);
+		break;
 	case 5:
+		updateProfile(m_zenvyController);
+		break;
+	case 6:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
-}
+}

Trenser.Zenvy/Trenser.Zenvy/views/EmployeeMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "EmployeeMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void EmployeeMenu::run()
 {
@@ -12,7 +13,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 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. Update Profile\n15. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -31,7 +32,8 @@ bool EmployeeMenu::handleOperation(int choice)
 {
 	switch (choice)
 	{
-	/*case 1:
+	/*
+	case 1:
 		m_zenvyController.applyLeave();
 		break;
 	case 2:
@@ -50,7 +52,7 @@ bool EmployeeMenu::handleOperation(int choice)
 		m_zenvyController.viewTicketHistory();
 		break;
 	case 7:
-		m_zenvyController.viewEmployees();
+		viewEmployees();
 		break;
 	case 8:
 		m_zenvyController.searchEmployee();
@@ -71,9 +73,16 @@ 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;
-}
+}
+
+
+

Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "FinanceExecutiveMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void FinanceExecutiveMenu::run()
 {
@@ -12,7 +13,7 @@ void FinanceExecutiveMenu::run()
 		{
 			int choice;
 			util::clear();
-			std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Resolve Ticket\n9. Generate Payslip\n10. Update Payroll\n11. Logout\nEnter your Choice: ";
+			std::cout << "Finance Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Resolve Ticket\n9. Generate Payslip\n10. Update Payroll\n11. Update Profile\n12. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -27,44 +28,111 @@ void FinanceExecutiveMenu::run()
 	}
 }
 
+std::string FinanceExecutiveMenu::getSelectedUserId()
+{
+	int choice;
+	std::map<int, std::shared_ptr<const Employee>> employeeList;
+	int index = 0;
+	auto allEmployees = m_zenvyController->getEmployees();
+	for (auto& currentEmployee : allEmployees)
+	{
+		if (currentEmployee->getEmployeeType() == Enums::EmployeeType::ADMIN)
+		{
+			continue;
+		}
+		employeeList[++index] = currentEmployee;
+	}
+	std::cout << std::left
+		<< std::setw(6) << "Index"
+		<< std::setw(15) << "Employee Id"
+		<< std::setw(25) << "Name" << std::endl;
+	for (const auto& employee : employeeList) 
+	{
+		std::cout << std::left << std::setw(6) << employee.first
+			<< std::setw(15) << employee.second->getId()
+			<< std::setw(25) << employee.second->getEmployeeName()
+			<< std::endl;
+	}
+	std::cout << "Enter the Index: ";
+	util::read(choice);
+	auto employeeIterator = employeeList.find(choice);
+	if (employeeIterator != employeeList.end())
+	{
+		return (employeeIterator->second->getId());
+	}
+	else
+	{
+		throw std::runtime_error("Invalid Index");
+	}
+}
+
+void FinanceExecutiveMenu::updatePayroll()
+{
+	std::string employeeId;
+	double basicSalary, houseRentAllowance, foodAllowance, employeePFContribution, employerPFContribution;
+	employeeId = getSelectedUserId();
+	if (employeeId != "") {
+		std::cout << "Enter the New Basic Salary: ";
+		util::read(basicSalary);
+		std::cout << "Enter the New House Rent Allowance: ";
+		util::read(houseRentAllowance);
+		std::cout << "Enter the New Food Allowance: ";
+		util::read(foodAllowance);
+		std::cout << "Enter the New EmployeePFContribution: ";
+		util::read(employeePFContribution);
+		std::cout << "Enter the New EmplyerPFContribution: ";
+		util::read(employerPFContribution);
+		m_zenvyController->updateSalary(employeeId, basicSalary, houseRentAllowance, foodAllowance, employeePFContribution, employerPFContribution);
+	}
+	else {
+		throw std::runtime_error("Unexpected error occured");
+	}
+}
+
 bool FinanceExecutiveMenu::handleOperation(int choice)
 {
 	switch (choice)
 	{
-	/*case 1:
-		m_zenvyController.applyLeave();
-		break;
-	case 2:
-		m_zenvyController.viewPayslip();
-		break;
-	case 3:
-		m_zenvyController.viewPayslipHistory();
-		break;
-	case 4:
-		m_zenvyController.viewEmployees();
-		break;
-	case 5:
-		m_zenvyController.searchEmployee();
-		break;
-	case 6:
-		m_zenvyController.viewNotifications();
-		break;
-	case 7:
-		m_zenvyController.viewAnnouncements();
-		break;
-	case 8:
-		m_zenvyController.resolveTicket();
-		break;
-	case 9:
-		m_zenvyController.generatePayslip();
-		break;
+	//case 1:
+	//	m_zenvyController.applyLeave();
+	//	break;
+	//case 2:
+	//	m_zenvyController.viewPayslip();
+	//	break;
+	//case 3:
+	//	m_zenvyController.viewPayslipHistory();
+	//	break;
+	//case 4:
+	//	m_zenvyController.viewEmployees();
+	//	break;
+	//case 5:
+	//	m_zenvyController.searchEmployee();
+	//	break;
+	//case 6:
+	//	m_zenvyController.viewNotifications();
+	//	break;
+	//case 7:
+	//	m_zenvyController.viewAnnouncements();
+	//	break;
+	//case 8:
+	//	m_zenvyController.resolveTicket();
+	//	break;
+	//case 9:
+	//	m_zenvyController.generatePayslip();
+	//	break;
 	case 10:
-		m_zenvyController.updatePayroll();
-		break;*/
+		updatePayroll();
+		break;
 	case 11:
+		updateProfile(m_zenvyController);
+		break;
+	case 12:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
 }
+
+

Trenser.Zenvy/Trenser.Zenvy/views/FinanceExecutiveMenu.h

@@ -1,5 +1,8 @@
 #pragma once
 #include<memory>
+#include<iostream>
+#include<stdexcept>
+#include <iomanip>
 #include"ZenvyController.h"
 
 class FinanceExecutiveMenu
@@ -10,5 +13,7 @@ public:
 	FinanceExecutiveMenu() : m_zenvyController(std::make_shared<ZenvyController>()) {};
 	void run();
 	bool handleOperation(int);
+	std::string getSelectedUserId();
+	void updatePayroll();
 };
 

Trenser.Zenvy/Trenser.Zenvy/views/HRManagerMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "HRManagerMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void HRManagerMenu::run()
 {
@@ -12,7 +13,7 @@ void HRManagerMenu::run()
 		{
 			int choice;
 			util::clear();
-			std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create Employee\n9. Regularize Attendance\n10. Update Leave Request\n11. Register CandidateAsEmployee\n12. Logout\nEnter your Choice: ";
+			std::cout << "HR Manager Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create Employee\n9. Regularize Attendance\n10. Update Leave Request\n11. Register CandidateAsEmployee\n12. Update Profile\n13. Deactivate Employee\n14. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -31,43 +32,49 @@ bool HRManagerMenu::handleOperation(int choice)
 {
 	switch (choice)
 	{
-	//case 1:
-	//	m_zenvyController.applyLeave();
-	//	break;
-	//case 2:
-	//	m_zenvyController.viewPayslip();
-	//	break;
-	//case 3:
-	//	m_zenvyController.viewPayslipHistory();
-	//	break;
-	//case 4:
-	//	m_zenvyController.viewEmployees();
-	//	break;
-	//case 5:
-	//	m_zenvyController.searchEmployee();
-	//	break;
-	//case 6:
-	//	m_zenvyController.viewNotifications();
-	//	break;
-	//case 7:
-	//	m_zenvyController.viewAnnouncements();
-	//	break;
-	//case 8:
-	//	m_zenvyController.createEmployee();
-	//	break;
-	//case 9:
-	//	m_zenvyController.regularizeAttenance();
-	//	break;
-	//case 10:
-	//	m_zenvyController.updateLeaveRequest();
-	//	break;
-	//case 11:
-	//	m_zenvyController.registercandidateAsEmployee();
-	//	break;
+	/*case 1:
+		m_zenvyController.applyLeave();
+		break;
+	case 2:
+		m_zenvyController.viewPayslip();
+		break;
+	case 3:
+		m_zenvyController.viewPayslipHistory();
+		break;
+	case 4:
+		m_zenvyController.viewEmployees();
+		break;
+	case 5:
+		m_zenvyController.searchEmployee();
+		break;
+	case 6:
+		m_zenvyController.viewNotifications();
+		break;
+	case 7:
+		m_zenvyController.viewAnnouncements();
+		break;*/
+	case 8:
+		createEmployee(m_zenvyController);
+		break;
+	/*case 9:
+		m_zenvyController.regularizeAttenance();
+		break;
+	case 10:
+		m_zenvyController.updateLeaveRequest();
+		break;
+	case 11:
+		m_zenvyController.registercandidateAsEmployee();
+		break;*/
 	case 12:
+		updateProfile(m_zenvyController);
+		break;
+	case 13:
+		deactivateEmployee(m_zenvyController);
+	case 14:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
 }

Trenser.Zenvy/Trenser.Zenvy/views/ITExecutiveMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "ITExecutiveMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void ITExecutiveMenu::run()
 {
@@ -12,7 +13,7 @@ void ITExecutiveMenu::run()
 		{
 			int choice;
 			util::clear();
-			std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Resolve Ticket\n9. Logout\nEnter your Choice: ";
+			std::cout << "IT Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Resolve Ticket\n9. Update Profile\n10. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -56,9 +57,13 @@ bool ITExecutiveMenu::handleOperation(int choice)
 		m_zenvyController.resolveTicket();
 		break;*/
 	case 9:
+		updateProfile(m_zenvyController);
+		break;
+	case 10:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
 }

Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.cpp

@@ -0,0 +1,103 @@
+#include <stdexcept>
+#include "MenuHelper.h"
+
+static Enums::EmployeeType getEmployeeType(Enums::EmployeeType employeeType)
+{
+    int choice;
+    util::clear();
+    static const std::map<Enums::EmployeeType, std::vector<Enums::EmployeeType>> employeeTypeOptions = {
+        { Enums::EmployeeType::ADMIN, {
+            Enums::EmployeeType::HR,
+            Enums::EmployeeType::IT,
+            Enums::EmployeeType::TEAM,
+            Enums::EmployeeType::FINANCE,
+            Enums::EmployeeType::TAG,
+            Enums::EmployeeType::GENERAL
+        }},
+        { Enums::EmployeeType::HR, {
+            Enums::EmployeeType::IT,
+            Enums::EmployeeType::TEAM,
+            Enums::EmployeeType::FINANCE,
+            Enums::EmployeeType::TAG,
+            Enums::EmployeeType::GENERAL
+        }}
+    };
+    static const std::map<Enums::EmployeeType, std::string> labels = {
+        { Enums::EmployeeType::HR, "HR Employee" },
+        { Enums::EmployeeType::IT, "IT Executive" },
+        { Enums::EmployeeType::TEAM, "Team Executive" },
+        { Enums::EmployeeType::FINANCE, "Finance Executive" },
+        { Enums::EmployeeType::TAG, "Talent Executive" },
+        { Enums::EmployeeType::GENERAL, "General Employee" }
+    };
+    auto it = employeeTypeOptions.find(employeeType);
+    if (it == employeeTypeOptions.end())
+    {
+        throw std::runtime_error("You do not have the authority to create a new Employee!");
+    }
+    const auto& options = it->second;
+    std::cout << "Select Employee Type\n";
+    for (int index = 0; index < options.size(); ++index)
+    {
+        std::cout << index + 1 << ". " << labels.at(options[index]) << "\n";
+    }
+    std::cout << "Enter Choice: ";
+    util::read(choice);
+    if (choice >= 1 && choice <= options.size())
+    {
+        return options[choice - 1];
+    }
+    return Enums::EmployeeType::INVALID;
+}
+
+static Enums::EmployeeDesignation getEmployeeDesignation()
+{
+    int choice;
+    util::clear();
+    std::cout << "Select Employee Designation"
+        "\n1. SENIOR"
+        "\n2. JUNIOR"
+        "\nEnter Choice: ";
+    util::read(choice);
+    switch (choice)
+    {
+    case 1:
+        return Enums::EmployeeDesignation::SENIOR;
+    case 2:
+        return Enums::EmployeeDesignation::JUNIOR;
+    default:
+        return Enums::EmployeeDesignation::INVALID;
+    }
+}
+
+void createEmployee(std::shared_ptr<ZenvyController> controller)
+{
+    auto currentEmployee = controller->getCurrentEmployee();
+    Enums::EmployeeType employeeType = getEmployeeType(currentEmployee->getEmployeeType());
+    Enums::EmployeeDesignation employeeDesignation = Enums::EmployeeDesignation::INVALID;
+    std::string name, email, phone;
+    switch (employeeType)
+    {
+    case Enums::EmployeeType::INVALID:
+        std::cout << "Invalid Choice";
+        util::pressEnter();
+        return;
+    case Enums::EmployeeType::GENERAL:
+        employeeDesignation = getEmployeeDesignation();
+        if (employeeDesignation == Enums::EmployeeDesignation::INVALID)
+        {
+            std::cout << "Invalid Choice";
+            util::pressEnter();
+            return;
+        }
+        break;
+    }
+    std::cout << "Enter Name: ";
+    util::read(name);
+    std::cout << "Enter Email: ";
+    util::read(email);
+    std::cout << "Enter Phone: ";
+    util::read(phone);
+    controller->createEmployee(employeeType, employeeDesignation, email, name, phone);
+    std::cout << "\nCreated Employee Successfully.";
+}

Trenser.Zenvy/Trenser.Zenvy/views/MenuHelper.h

@@ -0,0 +1,110 @@
+#pragma once
+#include <map>
+#include <memory>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include "Employee.h"
+#include "ZenvyController.h"
+#include "MenuHelper.h" 
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "Enums.h"
+
+void createEmployee(std::shared_ptr<ZenvyController> controller);
+
+inline void updateProfile(std::shared_ptr<ZenvyController> m_zenvyController)
+{
+	int choice;
+	std::string name, phone;
+	name = m_zenvyController->getCurrentEmployee()->getEmployeeName();
+	phone = m_zenvyController->getCurrentEmployee()->getEmployeePhone();
+	while (true)
+    {
+		util::clear();
+		std::cout << "Please choose the information you want to update:\n"
+			"1. Name\n"
+			"2. Phone Number\n"
+			"3. Exit\n"
+			"Enter your choice: ";
+		util::read(choice);
+		switch (choice)
+    {
+		case 1:
+			std::cout << "Enter your updated Name :";
+			util::read(name);
+			m_zenvyController->updateProfile(name, phone);
+			std::cout << "Profile Updated Successfully\n";
+			break;
+		case 2:
+			std::cout << "Enter your updated phone Number :";
+			util::read(phone);
+			m_zenvyController->updateProfile(name, phone);
+			std::cout << "Profile Updated Successfully\n";
+			break;
+		case 3:
+        return;
+		default:
+			std::cout << "Enter a valid choice!" << std::endl;
+			break;
+    }
+    }
+}
+
+inline std::map<int, std::shared_ptr<const Employee>> listEmployees(const std::shared_ptr<ZenvyController>& controller)
+{
+    auto employees = controller->getEmployees();
+    std::map<int, std::shared_ptr<const Employee>> employeeList;
+    std::cout << std::left
+        << std::setw(5) << "Index"
+        << std::setw(15) << "ID"
+        << std::setw(25) << "Name"
+        << "\n";
+    int index = 1;
+    for (auto& activeEmployees : employees)
+    {
+        std::cout << std::left
+            << std::setw(5) << index
+            << std::setw(15) << activeEmployees->getId()
+            << std::setw(25) << activeEmployees->getEmployeeName()
+            << "\n";
+        employeeList[index] = activeEmployees;
+        ++index;
+    }
+    if (employeeList.empty())
+    {
+        std::cout << "No active employees available.\n";
+    }
+    return employeeList;
+}
+
+inline void deactivateEmployee(const std::shared_ptr<ZenvyController>& controller)
+{
+    auto employeeList = listEmployees(controller);
+    if (employeeList.empty())
+    {
+        return;
+    }
+    int choice;
+    util::clear();
+    std::cout << "\nEnter the index of the employee to deactivate: ";
+    util::read(choice);
+    auto iterator = employeeList.find(choice);
+    if (iterator != employeeList.end())
+    {
+        std::string id = iterator->second->getId();
+        bool success = controller->deactivateEmployee(id);
+        if (success)
+        {
+            std::cout << "Employee deactivated successfully\n";
+        }
+        else
+        {
+            std::cout << "Employee not found\n";
+        }
+    }
+    else
+    {
+        std::cout << "Invalid index.\n";
+    }
+}

Trenser.Zenvy/Trenser.Zenvy/views/TalentExecutiveMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "TalentExecutiveMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void TalentExecutiveMenu::run()
 {
@@ -12,7 +13,7 @@ void TalentExecutiveMenu::run()
 		{
 			int choice;
 			util::clear();
-			std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create New Job\n9. View Job Opening\n10. Add Candidate\n11. UpdateCandidate Status\n12. View Shortlisted Candidate\n13. Logout\nEnter your Choice: ";
+			std::cout << "Talent Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create New Job\n9. View Job Opening\n10. Add Candidate\n11. UpdateCandidate Status\n12. View Shortlisted Candidate\n13. Update Profile\n14. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -68,9 +69,13 @@ bool TalentExecutiveMenu::handleOperation(int choice)
 	//	m_zenvyController.viewShortlistedCandidates();
 	//	break;
 	case 13:
+		updateProfile(m_zenvyController);
+		break;
+	case 14:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
 }

Trenser.Zenvy/Trenser.Zenvy/views/TeamExecutiveMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "TeamExecutiveMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void TeamExecutiveMenu::run()
 {
@@ -12,7 +13,7 @@ void TeamExecutiveMenu::run()
 		{
 			int choice;
 			util::clear();
-			std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create Team\n9. Update Team\n10. Remove Team\n11. Assign Employee\n12. Unassign Employee\n13. View Teams\n14. Logout\nEnter your Choice: ";
+			std::cout << "Team Executive Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. View Employees\n5. Search Employee\n6. View Notification\n7. View Announcements\n8. Create Team\n9. Update Team\n10. Remove Team\n11. Assign Employee\n12. Unassign Employee\n13. View Teams\n14. Update Profile\n15. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -71,9 +72,13 @@ bool TeamExecutiveMenu::handleOperation(int choice)
 	//	m_zenvyController.viewTeams();
 	//	break;
 	case 14:
+		updateProfile(m_zenvyController);
+	    break;
+	case 15:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
 }

Trenser.Zenvy/Trenser.Zenvy/views/TeamLeadMenu.cpp

@@ -1,7 +1,8 @@
 #include <iostream>
 #include "TeamLeadMenu.h"
-#include"InputHelper.h"
-#include"OutputHelper.h"
+#include "InputHelper.h"
+#include "OutputHelper.h"
+#include "MenuHelper.h"
 
 void TeamLeadMenu::run()
 {
@@ -12,7 +13,7 @@ void TeamLeadMenu::run()
 		{
 			int choice;
 			util::clear();
-			std::cout << "Zenvy - The HR Management System\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. Raise Ticke\n5. View Ticket\n6. View Ticket History\n7. View Employees\n8. Search Employee\n9. View Team Members\n10. Book Meeting Room\n11. View Booking History\n12. View Notification\n13. View Announcements\n4. Regularize Attendance\n15. Update Leave Request\n16. Logout\nEnter your Choice: ";
+			std::cout << "Team Lead Menu\n1. Apply Leave\n2. View Payslip\n3. View Payslip History\n4. Raise Ticke\n5. View Ticket\n6. View Ticket History\n7. View Employees\n8. Search Employee\n9. View Team Members\n10. Book Meeting Room\n11. View Booking History\n12. View Notification\n13. View Announcements\n4. Regularize Attendance\n15. Update Leave Request\n16. Update Profile\n17. Logout\nEnter your Choice: ";
 			util::read(choice);
 			if (!handleOperation(choice))
 			{
@@ -77,9 +78,13 @@ bool TeamLeadMenu::handleOperation(int choice)
 		m_zenvyController.updateLeaveRequest();
 		break;*/
 	case 16:
+		updateProfile(m_zenvyController);
+		break;
+	case 17:
 		return false;
 	default:
 		std::cout << "Enter a valid choice!" << std::endl;
+		util::pressEnter();
 	}
 	return true;
 }

Trenser.Zenvy/Trenser.Zenvy/views/UserInterface.cpp

@@ -19,6 +19,15 @@
 void UserInterface::run()
 {
 	bool isMenuActive = true;
+    try
+    {
+        m_controller->loadStates();
+    }
+    catch (const std::exception& e)
+	{
+	    std::cout << "Exception: " << e.what() << std::endl;
+        return;
+    }
 	while (isMenuActive)
 	{
 		try
@@ -65,7 +74,7 @@ void UserInterface::login()
     util::read(email);
     std::cout << "Enter password: ";
     util::read(password);
-    AuthenticationContext authenticationContext = m_controller->login(email, password);
+    AuthenticationDTO authenticationContext = m_controller->login(email, password);
     Enums::LoginStatus loginStatus = std::get<0>(authenticationContext);
     Enums::EmployeeType employeeType = std::get<1>(authenticationContext);
     Enums::EmployeeDesignation employeeDesignation = std::get<2>(authenticationContext);
@@ -94,7 +103,7 @@ void UserInterface::login()
         }
         else
         {
-            std::cout << "\nInvalid Password";
+            std::cout << "Error: Invalid Password\n";
             util::pressEnter();
             return;
         }