Bank System.cpp

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <iomanip>
#include <cctype>
#include <cstdlib>

using namespace std;

const string UsersFileName = "Users.txt";
const string ClientsFileName = "Clients.txt";

void Login();
void ShowMainMenue();
void ShowTransactionsMenue();
void ShowManageUsersMenue();

enum enMainMenueOptions
{
	eClientsList = 1, eAddNewClient = 2, eDeleteClient = 3, eUpdateClient = 4, eFindClient = 5, eShowTransactionsMenue = 6, eShowManageUsersMenue = 7, eLogout = 8
};

enum enTransactionsMenueOptions
{
	eDeposit = 1, eWithdraw = 2, eTotalBalance = 3, eShowMainMenue = 4
};

enum enManageUsersMenueOptions
{
	eUsersList = 1, eAddNewUser = 2, eDeleteUser = 3, eUpdateUser = 4, eFindUser = 5, eMainMenue = 6
};

enum enMainMenuePermissions
{
	pAll = -1, pListClients = 1, pAddNewClient = 2, pDeleteClient = 4, pUpdateClient = 8, pFindClient = 16, pTransactions = 32, pManageUsers = 64
};

struct stUser
{
	string UserName = "";
	string Password = "";
	short Permissions = 0;
	bool MarkForDelete = false;
};

stUser CurrentUser;

struct stClient
{
	string AccountNumber = "";
	string PinCode = "";
	string Name = "";
	string Phone = "";
	float AccountBalance = 0;
	bool MarkForDelete = false;
};

vector <string> SplitString(string S1, string Delim)
{
	vector <string> vString;

	string sWord = "";
	int pos = 0;

	while ((pos = S1.find(Delim)) != string::npos)
	{
		sWord = S1.substr(0, pos);

		if (sWord != "")
		{
			vString.push_back(sWord);
		}

		S1.erase(0, pos + Delim.length());
	}

	if (S1 != "")
	{
		vString.push_back(S1);
	}

	return vString;
}

stUser ConvertUserLineToRecord(string Line, string Separator = "#//#")
{
	stUser User;
	vector <string> vUserData;

	vUserData = SplitString(Line, Separator);

	User.UserName = vUserData[0];
	User.Password = vUserData[1];
	User.Permissions = stoi(vUserData[2]);

	return User;
}

stClient ConvertLineToRecord(string Line, string Separator = "#//#")
{
	stClient Client;
	vector <string> vClientData;

	vClientData = SplitString(Line, Separator);

	Client.AccountNumber = vClientData[0];
	Client.PinCode = vClientData[1];
	Client.Name = vClientData[2];
	Client.Phone = vClientData[3];
	Client.AccountBalance = stof(vClientData[4]);

	return Client;
}

string ConvertUserRecordToLine(stUser User, string Separator = "#//#")
{
	string stUserRecord = "";

	stUserRecord += User.UserName + Separator;
	stUserRecord += User.Password + Separator;
	stUserRecord += to_string(User.Permissions);

	return stUserRecord;
}

string ConvertRecordToLine(stClient Client, string Separator = "#//#")
{
	string stClientRecord = "";

	stClientRecord += Client.AccountNumber + Separator;
	stClientRecord += Client.PinCode + Separator;
	stClientRecord += Client.Name + Separator;
	stClientRecord += Client.Phone + Separator;
	stClientRecord += to_string(Client.AccountBalance);

	return stClientRecord;
}

vector <stUser> LoadUsersDataFromFile(string FileName)
{
	vector <stUser> vUsers;

	fstream MyFile;

	MyFile.open(FileName, ios::in);

	if (MyFile.is_open())
	{
		string Line;
		stUser User;

		while (getline(MyFile, Line))
		{
			User = ConvertUserLineToRecord(Line);

			vUsers.push_back(User);
		}

		MyFile.close();
	}

	return vUsers;
}

vector <stClient> LoadClientsDataFromFile(string FileName)
{
	vector <stClient> vClients;

	fstream MyFile;

	MyFile.open(FileName, ios::in);

	if (MyFile.is_open())
	{
		string Line;
		stClient Client;

		while (getline(MyFile, Line))
		{
			Client = ConvertLineToRecord(Line);

			vClients.push_back(Client);
		}

		MyFile.close();
	}

	return vClients;
}

void AddDataLineToFile(string FileName, string stDataLine)
{
	fstream MyFile;

	MyFile.open(FileName, ios::out | ios::app);

	if (MyFile.is_open())
	{
		MyFile << stDataLine << endl;

		MyFile.close();
	}
}

vector <stUser> SaveUsersDataToFile(string FileName, vector <stUser> vUsers)
{
	fstream MyFile;

	MyFile.open(FileName, ios::out);

	if (MyFile.is_open())
	{
		string UserLine;

		for (stUser& U : vUsers)
		{
			if (U.MarkForDelete == false)
			{
				UserLine = ConvertUserRecordToLine(U);

				MyFile << UserLine << endl;
			}
		}

		MyFile.close();
	}

	return vUsers;
}

vector <stUser> SaveUsersDataToFile(string FileName, vector <stUser> vUsers, string Username, stUser User)
{
	fstream MyFile;

	MyFile.open(FileName, ios::out);

	if (MyFile.is_open())
	{
		string UserLine;

		for (stUser& U : vUsers)
		{
			UserLine = ConvertUserRecordToLine(U);

			MyFile << UserLine << endl;
		}

		MyFile.close();
	}

	return vUsers;
}

vector <stClient> SaveClientsDataToFile(string FileName, vector <stClient> vClients)
{
	fstream MyFile;

	MyFile.open(FileName, ios::out);

	if (MyFile.is_open())
	{
		string ClientLine;

		for (stClient& C : vClients)
		{
			if (C.MarkForDelete == false)
			{
				ClientLine = ConvertRecordToLine(C);

				MyFile << ClientLine << endl;
			}
		}

		MyFile.close();
	}

	return vClients;
}

vector <stClient> SaveClientsDataToFile(string FileName, vector <stClient> vClients, string AccountNumber, stClient Client)
{
	fstream MyFile;

	MyFile.open(FileName, ios::out);

	if (MyFile.is_open())
	{
		string ClientLine;

		for (stClient& C : vClients)
		{
			ClientLine = ConvertRecordToLine(C);

			MyFile << ClientLine << endl;
		}

		MyFile.close();
	}

	return vClients;
}

void PrintUserCard(stUser User)
{
	cout << "\nThe following are the user details:\n";
	cout << "-----------------------------------\n";
	cout << "Username    : " << User.UserName << endl;
	cout << "Password    : " << User.Password << endl;
	cout << "Permissions : " << User.Permissions << endl;
	cout << "-----------------------------------\n";
}

void PrintClientCard(stClient Client)
{
	cout << "\nThe following are the client details:\n";
	cout << "-----------------------------------\n";
	cout << "Account Number : " << Client.AccountNumber << endl;
	cout << "Pin Code       : " << Client.PinCode << endl;
	cout << "Name           : " << Client.Name << endl;
	cout << "Phone          : " << Client.Phone << endl;
	cout << "Account Balance: " << Client.AccountBalance << endl;
	cout << "-----------------------------------\n";
}

void PrintUserRecord(stUser User)
{
	cout << "| " << left << setw(15) << User.UserName;
	cout << "| " << left << setw(10) << User.Password;
	cout << "| " << left << setw(40) << User.Permissions;
}

void PrintClientRecord(stClient Client)
{
	cout << "| " << left << setw(15) << Client.AccountNumber;
	cout << "| " << left << setw(10) << Client.PinCode;
	cout << "| " << left << setw(40) << Client.Name;
	cout << "| " << left << setw(12) << Client.Phone;
	cout << "| " << left << setw(12) << Client.AccountBalance;
}

bool UserExistsByUsername(string Username, string FileName)
{
	vector <stUser> vUsers;
	fstream MyFile;

	MyFile.open(FileName, ios::in);

	if (MyFile.is_open())
	{
		string Line;
		stUser Users;

		while (getline(MyFile, Line))
		{
			Users = ConvertUserLineToRecord(Line);

			if (Users.UserName == Username)
			{
				MyFile.close();

				return true;
			}

			vUsers.push_back(Users);
		}

		MyFile.close();
	}

	return false;
}

bool ClientExistsByAccountNumber(string AccountNumber, string FileName)
{
	vector <stClient> vClients;
	fstream MyFile;

	MyFile.open(FileName, ios::in);

	if (MyFile.is_open())
	{
		string Line;
		stClient Client;

		while (getline(MyFile, Line))
		{
			Client = ConvertLineToRecord(Line);

			if (Client.AccountNumber == AccountNumber)
			{
				MyFile.close();

				return true;
			}

			vClients.push_back(Client);
		}

		MyFile.close();
	}

	return false;
}

short ReadPermissionsToSet()
{
	short Permissions = 0;
	char Answer = 'n';

	cout << "\nDo you want to give full access? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		return -1;
	}

	cout << "\nDo you want to give access to:\n";

	cout << "\nShow Client List? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		Permissions += enMainMenuePermissions::pListClients;
	}

	cout << "\nAdd New Client? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		Permissions += enMainMenuePermissions::pAddNewClient;
	}

	cout << "\nDelete Client? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		Permissions += enMainMenuePermissions::pDeleteClient;
	}

	cout << "\nUpdate Client? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		Permissions += enMainMenuePermissions::pUpdateClient;
	}

	cout << "\nFind Client? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		Permissions += enMainMenuePermissions::pFindClient;
	}

	cout << "\nTransactions? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		Permissions += enMainMenuePermissions::pTransactions;
	}

	cout << "\nManage Users? y/n? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		Permissions += enMainMenuePermissions::pManageUsers;
	}

	return Permissions;
}

stUser ReadNewUser()
{
	stUser User;

	cout << "Enter Username? ";
	getline(cin >> ws, User.UserName);

	while (UserExistsByUsername(User.UserName, UsersFileName))
	{
		cout << "\nUser with [" << User.UserName << "] already exists, Enter another Username? ";
		getline(cin >> ws, User.UserName);
	}

	cout << "Enter Password? ";
	getline(cin >> ws, User.Password);

	User.Permissions = ReadPermissionsToSet();

	return User;
}

stClient ReadNewClient()
{
	stClient Client;

	cout << "Enter Account Number? ";
	getline(cin >> ws, Client.AccountNumber);

	while (ClientExistsByAccountNumber(Client.AccountNumber, ClientsFileName))
	{
		cout << "Client with [" << Client.AccountNumber << "] already exists, Enter another Account Number? ";
		getline(cin >> ws, Client.AccountNumber);
	}

	cout << "Enter Pin Code? ";
	getline(cin, Client.PinCode);

	cout << "Enter Name? ";
	getline(cin, Client.Name);

	cout << "Enter Phone? ";
	getline(cin, Client.Phone);

	cout << "Enter Account Balance? ";
	cin >> Client.AccountBalance;

	return Client;
}

void AddNewUser()
{
	stUser User = ReadNewUser();
	AddDataLineToFile(UsersFileName, ConvertUserRecordToLine(User));
}

void AddNewClient()
{
	stClient Client = ReadNewClient();
	AddDataLineToFile(ClientsFileName, ConvertRecordToLine(Client));
}

void AddNewUsers()
{
	char AddMore = 'n';

	do
	{
		cout << "Adding New User:\n\n";
		AddNewUser();

		cout << "\nUser Added Successfully, do you want to add more Users? Y/N? ";
		cin >> AddMore;

	} while (toupper(AddMore) == 'Y');
}

void AddClients()
{
	char AddMore = 'n';

	do
	{
		cout << "\nAdding New Client:\n\n";
		AddNewClient();

		cout << "\nClient Added Successfully, do you want to add more clients? Y/N? ";
		cin >> AddMore;

	} while (toupper(AddMore) == 'Y');
}

string ReadUsername()
{
	string Username = "";

	cout << "\nPlease Enter Username? ";
	getline(cin >> ws, Username);

	return Username;
}

string ReadClientAccountNumber()
{
	string AccountNumber = "";

	cout << "\nPlease Enter Account Number? ";
	getline(cin >> ws, AccountNumber);

	return AccountNumber;
}

bool FindUserByUsername(string Username, vector <stUser> vUsers)
{
	for (stUser U : vUsers)
	{
		if (U.UserName == Username)
		{
			return true;
		}
	}

	return false;
}

bool FindUserByUsername(string Username, vector <stUser> vUsers, stUser& User)
{
	for (stUser U : vUsers)
	{
		if (U.UserName == Username)
		{
			User = U;

			return true;
		}
	}

	return false;
}

bool FindUserByUsernameAndPassword(string Username, string Password, stUser& User)
{
	vector <stUser> vUsers = LoadUsersDataFromFile(UsersFileName);

	for (stUser U : vUsers)
	{
		if (U.UserName == Username && U.Password == Password)
		{
			User = U;

			return true;
		}
	}

	return false;
}

bool FindClientByAccountNumber(string AccountNumber, vector <stClient> vClients, stClient& Client)
{
	for (stClient C : vClients)
	{
		if (C.AccountNumber == AccountNumber)
		{
			Client = C;

			return true;
		}
	}

	return false;
}

bool MarkUserForDeleteByUsername(string Username, vector <stUser>& vUsers)
{
	for (stUser& U : vUsers)
	{
		if (U.UserName == Username)
		{
			U.MarkForDelete = true;

			return true;
		}
	}

	return false;
}

bool MarkClientForDeleteByAccountNumber(string AccountNumber, vector <stClient>& vClients)
{
	for (stClient& C : vClients)
	{
		if (C.AccountNumber == AccountNumber)
		{
			C.MarkForDelete = true;

			return true;
		}
	}

	return false;
}

bool DeleteUserByUsername(string Username, vector <stUser>& vUsers)
{
	stUser User;
	char Answer = 'n';

	if (Username == "Admin")
	{
		cout << "\n\nYou cannot Delete This User.";

		return false;
	}

	if (FindUserByUsername(Username, vUsers))
	{
		MarkUserForDeleteByUsername(Username, vUsers);
		SaveUsersDataToFile(UsersFileName, vUsers);

		vUsers = LoadUsersDataFromFile(UsersFileName);

		cout << "\n\nUser Deleted Successfully.";

		return true;
	}
	else
	{
		cout << "\nUser with Username (" << Username << ") is Not Found!";

		return false;
	}
}

bool DeleteClientByAccountNumber(string AccountNumber, vector <stClient>& vClients)
{
	stClient Client;
	char Answer = 'n';

	if (FindClientByAccountNumber(AccountNumber, vClients, Client))
	{
		PrintClientCard(Client);

		cout << "\n\nAre you sure you want delete this client? Y/N ? ";
		cin >> Answer;

		if (toupper(Answer) == 'Y')
		{
			MarkClientForDeleteByAccountNumber(AccountNumber, vClients);
			SaveClientsDataToFile(ClientsFileName, vClients);

			vClients = LoadClientsDataFromFile(ClientsFileName);

			cout << "\n\nClient Deleted Successfully.\n";
		}

		return true;
	}
	else
	{
		cout << "\nClient with Account Number (" << AccountNumber << ") Not Found!\n";

		return false;
	}
}

stUser ChangeUserRecord(string Username)
{
	stUser User;

	User.UserName = Username;

	cout << "\n\nEnter Password? ";
	getline(cin >> ws, User.Password);

	User.Permissions = ReadPermissionsToSet();

	return User;
}

stClient ChangeClientRecord(string AccountNumber)
{
	stClient Client;

	Client.AccountNumber = AccountNumber;

	cout << "\n\nEnter Pin Code? ";
	getline(cin >> ws, Client.PinCode);

	cout << "Enter Name? ";
	getline(cin, Client.Name);

	cout << "Enter Phone? ";
	getline(cin, Client.Phone);

	cout << "Enter Account Balance? ";
	cin >> Client.AccountBalance;

	return Client;
}

bool UpdateUserByUsername(string Username, vector <stUser>& vUsers)
{
	stUser User;
	char Answer = 'n';

	if (FindUserByUsername(Username, vUsers, User))
	{
		PrintUserCard(User);

		cout << "\n\nAre you sure you want update this user? y/n ? ";
		cin >> Answer;

		if (toupper(Answer) == 'Y')
		{
			for (stUser& U : vUsers)
			{
				if (U.UserName == Username)
				{
					U = ChangeUserRecord(Username);
					break;
				}
			}

			SaveUsersDataToFile(UsersFileName, vUsers, Username, User);

			cout << "\n\nUser Updated Successfully.";
		}

		return true;
	}
	else
	{
		cout << "\nUser with Username (" << Username << ") Not Found!\n";

		return false;
	}
}

bool UpdateClientByAccountNumber(string AccountNumber, vector <stClient>& vClients)
{
	stClient Client;
	char Answer = 'n';

	if (FindClientByAccountNumber(AccountNumber, vClients, Client))
	{
		PrintClientCard(Client);

		cout << "\n\nAre you sure you want update this client? Y/N ? ";
		cin >> Answer;

		if (toupper(Answer) == 'Y')
		{
			for (stClient& C : vClients)
			{
				if (C.AccountNumber == AccountNumber)
				{
					C = ChangeClientRecord(AccountNumber);
					break;
				}
			}

			SaveClientsDataToFile(ClientsFileName, vClients, AccountNumber, Client);

			cout << "\n\nClient Updated Successfully.\n";
		}

		return true;
	}
	else
	{
		cout << "\nClient with Account Number (" << AccountNumber << ") Not Found!\n";

		return false;
	}
}

bool DepositBalanceToClientByAccountNumber(string AccountNumber, double Amount, vector <stClient>& vClients)
{
	char Answer = 'n';

	cout << "\n\nAre you sure you want perfrom this transaction? Y/N ? ";
	cin >> Answer;

	if (toupper(Answer) == 'Y')
	{
		for (stClient& C : vClients)
		{
			if (C.AccountNumber == AccountNumber)
			{
				C.AccountBalance += Amount;

				SaveClientsDataToFile(ClientsFileName, vClients);

				cout << "\n\nDone Successfully. New balance is: " << C.AccountBalance;

				return true;
			}
		}
	}

	return false;

}

void PrintClientRecordBalanceLine(stClient Client)
{
	cout << "| " << left << setw(15) << Client.AccountNumber;
	cout << "| " << left << setw(40) << Client.Name;
	cout << "| " << left << setw(12) << Client.AccountBalance;
}

bool CheckAccessPermissions(enMainMenuePermissions Permissions)
{
	if (CurrentUser.Permissions == enMainMenuePermissions::pAll)
		return true;

	if ((CurrentUser.Permissions & Permissions) == Permissions)
		return true;
	else
		return false;
}

void ShowAccessDeniedMessage()
{
	cout << "\n-----------------------------------\n";
	cout << "Access Denied,\nYou dont Have Permission To Do this,\nPlease Contact Your Admin.\n";
	cout << "-----------------------------------\n";
}

void ShowAllUsersScreen()
{
	vector <stUser> vUsers = LoadUsersDataFromFile(UsersFileName);

	cout << "\n\t\t\t\t\Users List (" << vUsers.size() << ") User(s).";
	cout << "\n________________________________________________________________________________________________\n" << endl;
	cout << "| " << left << setw(15) << "User Name";
	cout << "| " << left << setw(10) << "Password";
	cout << "| " << left << setw(40) << "Permissions";
	cout << "\n________________________________________________________________________________________________\n" << endl;

	if (vUsers.size() == 0)
		cout << "\t\t\t\tNo Users Available In The System!";
	else
		for (stUser& User : vUsers)
		{
			PrintUserRecord(User);

			cout << endl;
		}

	cout << "________________________________________________________________________________________________\n" << endl;
}

void ShowAllClientsScreen()
{
	if (!CheckAccessPermissions(enMainMenuePermissions::pListClients))
	{
		ShowAccessDeniedMessage();
		return;
	}

	vector <stClient> vClients = LoadClientsDataFromFile(ClientsFileName);

	cout << "\n\t\t\t\t\tClient List (" << vClients.size() << ") Client (s).";
	cout << "\n________________________________________________________________________________________________\n" << endl;
	cout << "| " << left << setw(15) << "Account Number";
	cout << "| " << left << setw(10) << "Pin Code";
	cout << "| " << left << setw(40) << "Client Name";
	cout << "| " << left << setw(12) << "Phone";
	cout << "| " << left << setw(12) << "Balance";
	cout << "\n________________________________________________________________________________________________\n" << endl;

	for (stClient& Client : vClients)
	{
		PrintClientRecord(Client);

		cout << endl;
	}

	cout << "________________________________________________________________________________________________\n" << endl;
}

void ShowAddNewClientScreen()
{
	if (!CheckAccessPermissions(enMainMenuePermissions::pAddNewClient))
	{
		ShowAccessDeniedMessage();
		return;
	}

	cout << "\n-----------------------------------\n";
	cout << "\tAdd New Clients Screen\n";
	cout << "-----------------------------------\n";

	AddClients();
}

void ShowDeleteClientScreen()
{
	if (!CheckAccessPermissions(enMainMenuePermissions::pDeleteClient))
	{
		ShowAccessDeniedMessage();
		return;
	}

	cout << "\n-----------------------------------\n";
	cout << "\tDelete Client Screen\n";
	cout << "-----------------------------------\n";

	vector <stClient> vClients = LoadClientsDataFromFile(ClientsFileName);
	string AccountNumber = ReadClientAccountNumber();

	DeleteClientByAccountNumber(AccountNumber, vClients);
}

void ShowUpdateClientInfoScreen()
{
	if (!CheckAccessPermissions(enMainMenuePermissions::pUpdateClient))
	{
		ShowAccessDeniedMessage();
		return;
	}

	cout << "\n-----------------------------------\n";
	cout << "     Update Client Info Screen\n";
	cout << "-----------------------------------\n";

	vector <stClient> vClients = LoadClientsDataFromFile(ClientsFileName);
	string AccountNumber = ReadClientAccountNumber();

	UpdateClientByAccountNumber(AccountNumber, vClients);
}

void ShowFindClientScreen()
{
	if (!CheckAccessPermissions(enMainMenuePermissions::pFindClient))
	{
		ShowAccessDeniedMessage();
		return;
	}

	cout << "\n-----------------------------------\n";
	cout << "\tFind Client Screen\n";
	cout << "-----------------------------------\n";

	vector <stClient> vClients = LoadClientsDataFromFile(ClientsFileName);
	stClient Client;
	string AccountNumber = ReadClientAccountNumber();

	if (FindClientByAccountNumber(AccountNumber, vClients, Client))
	{
		PrintClientCard(Client);
	}
	else
	{
		cout << "\nClient with Account Number[" << AccountNumber << "] is not found!\n";
	}
}

void ShowDepositScreen()
{
	cout << "\n-----------------------------------\n";
	cout << "\tDeposit Screen\n";
	cout << "-----------------------------------\n";

	stClient Client;

	vector <stClient> vClients = LoadClientsDataFromFile(ClientsFileName);
	string AccountNumber = ReadClientAccountNumber();

	while (!FindClientByAccountNumber(AccountNumber, vClients, Client))
	{
		cout << "\nClient with [" << AccountNumber << "] does not exist.\n";

		AccountNumber = ReadClientAccountNumber();
	}

	PrintClientCard(Client);

	double Amount = 0;

	cout << "\nPlease enter deposit amount? ";
	cin >> Amount;

	DepositBalanceToClientByAccountNumber(AccountNumber, Amount, vClients);
}

void ShowWithDrawScreen()
{
	cout << "\n-----------------------------------\n";
	cout << "\tWithdraw Screen\n";
	cout << "-----------------------------------\n";

	stClient Client;

	vector <stClient> vClients = LoadClientsDataFromFile(ClientsFileName);
	string AccountNumber = ReadClientAccountNumber();

	while (!FindClientByAccountNumber(AccountNumber, vClients, Client))
	{
		cout << "\nClient with [" << AccountNumber << "] does not exist.\n";

		AccountNumber = ReadClientAccountNumber();
	}

	PrintClientCard(Client);

	double Amount = 0;

	cout << "\nPlease enter whitdraw amount? ";
	cin >> Amount;

	while (Amount > Client.AccountBalance)
	{
		cout << "\nAmount Exceeds the balance, you can  withdraw up to : " << Client.AccountBalance << endl;

		cout << "Please enter another amount? ";
		cin >> Amount;
	}

	DepositBalanceToClientByAccountNumber(AccountNumber, Amount * -1, vClients);
}

void ShowTotalBalances()
{
	vector <stClient> vClients = LoadClientsDataFromFile(ClientsFileName);

	cout << "\n\t\t\t\t\tBalance List (" << vClients.size() << ") Client(s).";
	cout << "\n________________________________________________________________________________________________\n" << endl;
	cout << "| " << left << setw(15) << "Account Number";
	cout << "| " << left << setw(40) << "Client Name";
	cout << "| " << left << setw(12) << "Balance";
	cout << "\n________________________________________________________________________________________________\n" << endl;

	double TotalBalance = 0;

	if (vClients.size() == 0)
	{
		cout << "\t\t\t\tNo Clients Available In the System!\n" << endl;
	}
	else
	{
		for (stClient& Client : vClients)
		{
			PrintClientRecordBalanceLine(Client);
			TotalBalance += Client.AccountBalance;

			cout << endl;
		}
	}

	cout << "________________________________________________________________________________________________\n" << endl;

	cout << "\t\t\t\t\t   Total Balance = " << TotalBalance;
}

void ShowTotalBalancesScreen()
{
	ShowTotalBalances();
}

void GoBackToManageUsersMeune()
{
	cout << "\n\nPress any key to go back to Manage Users Menue...";

	system("pause>0");

	ShowManageUsersMenue();
}

void ShowAllListUsersScreen()
{
	ShowAllUsersScreen();
}

void ShowAddNewUserScreen()
{
	cout << "\n-----------------------------------\n";
	cout << "\tAdd New User Screen\n";
	cout << "-----------------------------------\n";

	AddNewUsers();
}

void ShowDeleteUserScreen()
{
	cout << "\n-----------------------------------\n";
	cout << "\tDelete Users Screen\n";
	cout << "-----------------------------------\n";

	vector <stUser> vUsers = LoadUsersDataFromFile(UsersFileName);
	string Username = ReadUsername();

	DeleteUserByUsername(Username, vUsers);
}

void ShowUpdateUserScreen()
{
	cout << "\n-----------------------------------\n";
	cout << "\tUpdate Users Screen\n";
	cout << "-----------------------------------\n";

	vector <stUser> vUsers = LoadUsersDataFromFile(UsersFileName);
	string Username = ReadUsername();

	UpdateUserByUsername(Username, vUsers);
}

void ShowFindUserScreen()
{
	cout << "\n-----------------------------------\n";
	cout << "\tFind User Screen\n";
	cout << "-----------------------------------\n";

	vector <stUser> vUsers = LoadUsersDataFromFile(UsersFileName);
	stUser User;
	string Username = ReadUsername();

	if (FindUserByUsername(Username, vUsers, User))
	{
		PrintUserCard(User);
	}
	else
	{
		cout << "\nUser with Username [" << Username << "] is not found!\n";
	}
}

void GoBackToMainMenue()
{
	cout << "\n\nPress any key to go back to Main Menue...";

	system("pause>0");

	ShowMainMenue();
}

void PerfromManageUsersMenueOptions(enManageUsersMenueOptions ManageUsersMenueOptions)
{
	switch (ManageUsersMenueOptions)
	{
	case enManageUsersMenueOptions::eUsersList:
		system("cls");
		ShowAllListUsersScreen();
		GoBackToManageUsersMeune();
		break;

	case enManageUsersMenueOptions::eAddNewUser:
		system("cls");
		ShowAddNewUserScreen();
		GoBackToManageUsersMeune();
		break;

	case enManageUsersMenueOptions::eDeleteUser:
		system("cls");
		ShowDeleteUserScreen();
		GoBackToManageUsersMeune();
		break;

	case enManageUsersMenueOptions::eUpdateUser:
		system("cls");
		ShowUpdateUserScreen();
		GoBackToManageUsersMeune();
		break;

	case enManageUsersMenueOptions::eFindUser:
		system("cls");
		ShowFindUserScreen();
		GoBackToManageUsersMeune();
		break;

	case enManageUsersMenueOptions::eMainMenue:
		ShowMainMenue();
		break;
	}
}

short ReadManageUsersMenueOption()
{
	short Choice = 0;

	cout << "Choose what do you want to do? [1 to 6]? ";
	cin >> Choice;

	return Choice;
}

void ShowManageUsersMenue()
{
	if (!CheckAccessPermissions(enMainMenuePermissions::pManageUsers))
	{
		ShowAccessDeniedMessage();
		GoBackToMainMenue();
		return;
	}

	system("cls");

	cout << "===========================================\n";
	cout << "\tManage Users Meune Screen\n";
	cout << "===========================================\n";
	cout << "\t[1] List Users.\n";
	cout << "\t[2] Add New User.\n";
	cout << "\t[3] Delete User.\n";
	cout << "\t[4] Update User.\n";
	cout << "\t[5] Find User.\n";
	cout << "\t[6] Main Menue.\n";
	cout << "===========================================\n";

	PerfromManageUsersMenueOptions(enManageUsersMenueOptions(ReadManageUsersMenueOption()));
}

void GoBackToTransactionsMenue()
{
	cout << "\n\nPress any key to go back to Transactions Menue...";

	system("pause>0");

	ShowTransactionsMenue();
}

void PerfromTransactionsMenueOptions(enTransactionsMenueOptions TransactionsMenueOptions)
{
	switch (TransactionsMenueOptions)
	{
	case enTransactionsMenueOptions::eDeposit:
		system("cls");
		ShowDepositScreen();
		GoBackToTransactionsMenue();
		break;

	case enTransactionsMenueOptions::eWithdraw:
		system("cls");
		ShowWithDrawScreen();
		GoBackToTransactionsMenue();
		break;

	case enTransactionsMenueOptions::eTotalBalance:
		system("cls");
		ShowTotalBalancesScreen();
		GoBackToTransactionsMenue();
		break;

	case enTransactionsMenueOptions::eShowMainMenue:
		ShowMainMenue();
		break;
	}
}

short ReadTransactionsMenueOption()
{
	short Choice = 0;

	cout << "Choose what do you want to do? [1 to 4]? ";
	cin >> Choice;

	return Choice;
}

void ShowTransactionsMenue()
{
	if (!CheckAccessPermissions(enMainMenuePermissions::pTransactions))
	{
		ShowAccessDeniedMessage();
		GoBackToMainMenue();
		return;
	}

	system("cls");

	cout << "===========================================\n";
	cout << "\tTransactions Menue Screen\n";
	cout << "===========================================\n";
	cout << "\t[1] Deposit.\n";
	cout << "\t[2] Withdraw.\n";
	cout << "\t[3] Total Balance.\n";
	cout << "\t[4] Main Menue.\n";
	cout << "===========================================\n";

	PerfromTransactionsMenueOptions(enTransactionsMenueOptions(ReadTransactionsMenueOption()));
}

void PerfromMainMenueOptions(enMainMenueOptions MainMenueOptions)
{
	switch (MainMenueOptions)
	{
	case enMainMenueOptions::eClientsList:
		system("cls");
		ShowAllClientsScreen();
		GoBackToMainMenue();
		break;

	case enMainMenueOptions::eAddNewClient:
		system("cls");
		ShowAddNewClientScreen();
		GoBackToMainMenue();
		break;

	case enMainMenueOptions::eDeleteClient:
		system("cls");
		ShowDeleteClientScreen();
		GoBackToMainMenue();
		break;

	case enMainMenueOptions::eUpdateClient:
		system("cls");
		ShowUpdateClientInfoScreen();
		GoBackToMainMenue();
		break;

	case enMainMenueOptions::eFindClient:
		system("cls");
		ShowFindClientScreen();
		GoBackToMainMenue();
		break;

	case enMainMenueOptions::eShowTransactionsMenue:
		system("cls");
		ShowTransactionsMenue();
		break;

	case enMainMenueOptions::eShowManageUsersMenue:
		system("cls");
		ShowManageUsersMenue();
		break;

	case enMainMenueOptions::eLogout:
		system("cls");
		Login();
		break;
	}
}

short ReadMainMenueOption()
{
	short Choice = 0;

	cout << "Choose what do you want to do? [1 to 8]? ";
	cin >> Choice;

	return Choice;
}

void ShowMainMenue()
{
	system("cls");

	cout << "===========================================\n";
	cout << "\t\tMain Menue Screen\n";
	cout << "===========================================\n";
	cout << "\t[1] Show Client List.\n";
	cout << "\t[2] Add New Client.\n";
	cout << "\t[3] Delete Client.\n";
	cout << "\t[4] Update Client Info.\n";
	cout << "\t[5] Find Client.\n";
	cout << "\t[6] Transactions.\n";
	cout << "\t[7] Manage Users.\n";
	cout << "\t[8] Logout.\n";
	cout << "===========================================\n";

	PerfromMainMenueOptions(enMainMenueOptions(ReadMainMenueOption()));
}

bool LoadUserInfo(string Username, string Password)
{
	if (FindUserByUsernameAndPassword(Username, Password, CurrentUser))
		return true;
	else
		return false;
}

void Login()
{
	bool LoginFailed = false;
	string Username = "", Password = "";

	do
	{
		system("cls");

		cout << "\n-----------------------------------\n";
		cout << "\tLogin Screen\n";
		cout << "-----------------------------------\n";

		if (LoginFailed)
		{
			cout << "Invalid Username/Password!\n";
		}

		cout << "Enter Username? ";
		cin >> Username;

		cout << "Enter Password? ";
		cin >> Password;

		LoginFailed = !LoadUserInfo(Username, Password);

	} while (LoginFailed);

	ShowMainMenue();
}

int main()
{
	Login();

	system("pause>0");

	return 0;
}