Курсовая

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>
#include <windows.h>

using namespace std;

const string DATA_FILE = "data.txt", ACCOUNTS_FILE = "users.txt", DEPARTMENTS_FILE = "departments.txt", POSTS_FILE = "posts.txt", TEMP_FILE = "temp.txt", NEW_USERS_FILE = "newusers.txt";

const string LINES_MAIN_MENU[] = { "\n------------Главное меню--------------\n\n","1 - Регистрация\n","2 - Войти как гость\n","3 - Войти как юзер\n","4 - Войти как администратор\n","5 - Выйти из программы\n\n" };
const int COUNTER_MAIN_MENU = 5;
const string LINES_GUEST_MENU[] = { "\n\n\n------------Гостевое меню--------------\n\n","1 - Просмотр сотрудников\n","2 - Сортировка сотрудников\n","3 - Поиск сотрудника\n","4 - Выйти из программы\n","5 - Вернуться в главное меню\n\n" };
const int COUNTER_GUEST_MENU = 5;
const string LINES_USER_MENU[] = { "\n\n\n------------Меню пользователя--------------\n\n","1 - Просмотр данных\n","2 - Сортировка данных\n","3 - Поиск по данным\n","4 - Выполнить задание\n","5 - Выйти из программы\n","6 - Вернуться в главное меню\n","7 - Сменить пароль\n\n" };
const int COUNTER_USER_MENU = 7;
const string LINES_ADMIN_MENU[] = { "\n\n\n------------Меню администратора--------------\n\n","1 - Учетные записи\n","2 - Файлы\n","3 - Данные\n","4 - Пользовательский модуль\n","5 - Выйти из программы\n","6 - Вернуться в главное меню\n", "7 - Сменить пароль\n\n" };
const int COUNTER_ADMIN_MENU = 7;
const string LINES_FILE_MENU[] = { "\n\n\n------------Диспетчер файлов--------------\n\n","1 - Создать файлы\n","2 - Удалить файлы\n","3 - Просмотреть файлы\n","4 - Вернуться в меню администратора\n\n" };
const int COUNTER_FILE_MENU = 4;
const string LINES_ACCOUNT_MENU[] = { "\n\n\n------------Диспетчер аккаунтов--------------\n\n","1 - Просмотр аккаунтов\n","2 - Добавить аккаунт\n","3 - Изменить аккаунт\n","4 - Удалить аккаунт\n","5 - Вернуться в меню администратора\n\n" };
const int COUNTER_ACCOUNT_MENU = 5;
const string LINES_DATA_MENU[] = { "\n\n\n------------Диспетчер данных--------------\n\n","1 - Просмотр данных\n","2 - Добавить данные\n","3 - Изменить данные\n","4 - Удалить данные\n","5 - Добавить отдел\n","6 - Добавить должность\n","7 - Вернуться в меню администратора\n\n" };
const int COUNTER_DATA_MENU = 7;

const string FOR_EDIT_MESSAGE = "Некоторые данные были некорректны.\nПрименено автоиcправление.\n";

const string FOR_EXIT = "\nВы уверенны, что хотите выйти?\n";

const string FOR_CHOOSE_HACKER_REGIME = "Желаете ли активировать режим \"Хакер\"?\n";
const string ABOUT_HACKER_REGIME = "Добро пожаловать в режим \"Хакер\"!\nЕдинственное отличие от режима администратора - цвет консоли.\nПомните, настоящие хакеры всегда работают в черной консоли с зеленым шрифтом!\n";

const string COLOR_HACKER = "color 02", COLOR_ADMIN = "color 1F", COLOR_USER = "color F1", COLOR_GUEST = "color F0", COLOR_MAIN = "color 0F";

const string SALT = "HrenVamANeBruteForce";

const string INPUT_LOGIN = "\nВведите логин:\n", INPUT_PASSWORD = "\nВведите пароль:\n", CONFIRM_PASSWORD = "\nПовторите пароль:\n";
const string FOR_LOGIN = "\nЛогин должен содержать 6-10 символов.\n", FOR_PASSWORD = "\nПароль должен содержать 8-16 символов\n", HELP_LINE = "Допустимы символы A-Z, a-z, 0-9, _\n";

const string FILE_OPEN_ERROR = "Ошибка. Не удалось открыть файл. Создан новый файл.";
const string FILE_CREATE_ERROR = "Ошибка. Не удалось создать файл.";

const string SEPARATOR = "---------------------------\n";
const string LINE_UNKNOWN = "Не известно";
const string LINE_TRUE = "1 - Да\n";
const string LINE_FALSE = "2 - Нет\n\n";

//-----------------------------------
//-----------------------------------
char chooseItem(int );
//-----------------------------------
void installRusSupport();
//-----------------------------------
void activateHackerRegime();
//-----------------------------------
void showMainMenu();
void chooseMainMenu();

void showGuestMenu();
void chooseGuestMenu(bool&);

void showUserMenu();
void chooseUserMenu(bool&);

void showAdminMenu();
void chooseAdminMenu(bool&, vector<struct user>&);

void showFileMenu();
void chooseFileMenu();

void showAccountMenu();
void chooseAccountMenu(vector<struct user>&);

void showDataMenu();
void chooseDataMenu();
//-----------------------------------
void inspectFile(string);
void createFile(string);
int countLines(string);
//-----------------------------------
vector<struct worker> readDataFile();
void showDataFile(vector<struct worker>&);
void writeDataFile(vector<struct worker>&);
//-----------------------------------
vector<struct user> readAccountsFile();
void showAccountsFile(vector<struct user>&);
void writeAccountsFile(vector<struct user>&);
//-----------------------------------
void verifyData(worker&);
int verifyFullName(string&);
int verifyDay(int&, int, int);
int verifyMonth(int&);
int verifyYear(int&);
int verifyDepartment(string&);
int verifyPost(string&);
void showEditMessage();
//-----------------------------------
void verifyZero(int);
//-----------------------------------
int verifyReadInt(string);
//-----------------------------------
int learnLongestLine(vector<struct worker>&);
int learnLongestLine(string);
//-----------------------------------
string cipherUser(user);
//-----------------------------------
void registrUser(vector<struct user>&);
string registrLogin(vector<struct user>&);
string inputPassword();
bool isOriginalLogin(string, vector<struct user>&);
//-----------
void logInAccount(vector<struct user>&, bool&);
string inputLogin(vector<struct user>&);
bool isTruePassword(string, string, vector<struct user>&);
//-----------------------------------
void sortAlfabet(vector<struct worker>&);
void sortDepartment(vector<struct worker>&);
void sortPost(vector<struct worker>&);
//-----------------------------------
bool isExit();

struct worker
{
    struct tname
    {
        string name, patronum, full_name;
        string surname = name + ' ' + patronum + ' ' + full_name;
    } tname;
    struct birth
    {
        int day, month, year;
    } birth;
    struct work
    {
        struct begin
        {
            int day, month, year;
        } begin;
        string department, post;
    } work;
};

struct user
{
    string login, password;
    bool role;
};


int main()
{
    installRusSupport();
    chooseMainMenu();

    system("pause");
    return 0;
}

char chooseItem(int count_menu)
{
    cout << "Вы выбираете пункт: ";
    string choice;
    cin >> choice;
    cout << "\n";

    if (choice.length() == 1)
    {
        return choice[0];
    }
    else
    {
        return (char)(count_menu + 48);
    }

}

void installRusSupport()
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
}

void activateHackerRegime()
{
    cout << SEPARATOR << FOR_CHOOSE_HACKER_REGIME<<LINE_TRUE<<LINE_FALSE;

    if (chooseItem(2) == '1')
    {
        system(COLOR_HACKER.c_str());
        cout << ABOUT_HACKER_REGIME;
    }
    else
    {
        system(COLOR_ADMIN.c_str());
    }
}

void showMainMenu()
{
    system(COLOR_MAIN.c_str());
    for (int i = 0; i <= COUNTER_MAIN_MENU; i++)
    {
        cout << LINES_MAIN_MENU[i];
    }
}

void showGuestMenu()
{
    system(COLOR_GUEST.c_str());
    for (int i = 0; i <= COUNTER_GUEST_MENU; i++)
    {
        cout << LINES_GUEST_MENU[i];
    }
}

void showUserMenu()
{
    system(COLOR_USER.c_str());
    for (int i = 0; i <= COUNTER_USER_MENU; i++)
    {
        cout << LINES_USER_MENU[i];
    }
}

void showAdminMenu()
{
    for (int i = 0; i <= COUNTER_ADMIN_MENU; i++)
    {
        cout << LINES_ADMIN_MENU[i];
    }
}

void showFileMenu()
{
    for (int i = 0; i <= COUNTER_FILE_MENU; i++)
    {
        cout << LINES_FILE_MENU[i];
    }
}

void showAccountMenu()
{
    for (int i = 0; i <= COUNTER_ACCOUNT_MENU; i++)
    {
        cout << LINES_ACCOUNT_MENU[i];
    }
}

void showDataMenu()
{
    for (int i = 0; i <= COUNTER_DATA_MENU; i++)
    {
        cout << LINES_DATA_MENU[i];
    }
}

void chooseMainMenu()
{
    bool main_menu_flag = true;
    vector<struct user> accounts_vector = readAccountsFile();
    while (main_menu_flag == true)
    {
        showMainMenu();
        switch (chooseItem(COUNTER_MAIN_MENU))
        {
        case '1':
        {
            registrUser(accounts_vector);
            break;
        }

        case '2':
        {
            chooseGuestMenu(main_menu_flag);
            break;
        }

        case '3':
        {
            logInAccount(accounts_vector, main_menu_flag);
            break;
        }

        case '4':
        {
            chooseAdminMenu(main_menu_flag, accounts_vector);
            break;
        }

        case '5': default:
        {
            main_menu_flag = isExit();
        }
        }
    }
}

void chooseGuestMenu(bool& main_menu_flag)
{
    bool menu_flag = true;
    vector <struct worker> workers_vector = readDataFile();
    while (menu_flag == true)
    {
        showGuestMenu();
        switch (chooseItem(COUNTER_GUEST_MENU))
        {
        case '1':
        {
            showDataFile(workers_vector);
            break;
        }

        case '2':
        {
            //sort
            break;
        }

        case '3':
        {
            //search
            break;
        }

        case '4':
        {
            main_menu_flag = menu_flag = isExit();
            break;
        }

        case '5': default:
        {
            menu_flag = isExit();
        }
        }
    }
}

void chooseUserMenu(bool& main_menu_flag)
{
    vector <struct worker> workers_vector = readDataFile();
    bool menu_flag = true;
    while (menu_flag == true)
    {
        showUserMenu();
        switch (chooseItem(COUNTER_USER_MENU))
        {
        case '1':
        {
            showDataFile(workers_vector);
            break;
        }

        case '2':
        {
            //sort
            break;
        }

        case '3':
        {
            //search
            break;
        }

        case '4':
        {
            //make task
            break;
        }

        case '5':
        {
            main_menu_flag = menu_flag = isExit();
            break;
        }

        case '7':
        {
            //сменить пароль
            break;
        }

        case '6': default:
        {
            menu_flag = isExit();
        }
        }
    }
}

void chooseAdminMenu(bool& main_menu_flag, vector<struct user>& accounts_vector)
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        activateHackerRegime();
        showAdminMenu();
        switch (chooseItem(COUNTER_ADMIN_MENU))
        {
        case '1':
        {
            chooseFileMenu();
            break;
        }

        case '2':
        {
            chooseAccountMenu(accounts_vector);
            break;
        }

        case '3':
        {
            chooseDataMenu();
            break;
        }

        case '4':
        {
            chooseUserMenu(main_menu_flag);
            break;
        }

        case '5':
        {
            main_menu_flag = menu_flag = isExit();
            break;
        }

        case '7':
        {
            //сменить пароль
            break;
        }

        case '6': default:
        {
            menu_flag = isExit();
        }
        }
    }
}

void chooseFileMenu()
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        showFileMenu();
        switch (chooseItem(COUNTER_FILE_MENU))
        {
        case '1':
        {
            //create
            break;
        }

        case '2':
        {
            //delete
            break;
        }

        case '3':
        {
            //show+
            break;
        }

        case '4': default:
        {
            menu_flag = isExit();
        }
        }
    }
}

void chooseAccountMenu(vector<struct user>& accounts_vector)
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        showAccountMenu();
        switch (chooseItem(COUNTER_ACCOUNT_MENU))
        {
        case '1':
        {
            showAccountsFile(accounts_vector);
            break;
        }

        case '2':
        {
            //add
            break;
        }

        case '3':
        {
            //edit
            break;
        }

        case '4':
        {
            //delete
            break;
        }

        case '5': default:
        {
            menu_flag = isExit();//exit
        }
        }
        writeAccountsFile(accounts_vector);
    }
}

void chooseDataMenu()
{
    bool menu_flag = true;
    vector <struct worker> workers_vector = readDataFile();
    while (menu_flag == true)
    {
        showDataMenu();
        switch (chooseItem(COUNTER_DATA_MENU))
        {
        case '1':
        {
            showDataFile(workers_vector);
            break;
        }

        case '2':
        {
            //добавить
            break;
        }

        case '3':
        {
            //edit
            break;
        }

        case '4':
        {
            //delete
            break;
        }

        case '5':
        {
            //добавить отдел
            break;
        }

        case '6':
        {
            //добавить должность
            break;
        }

        case '7': default:
        {
            menu_flag = isExit();
        }
        }
    }
    writeDataFile(workers_vector);
}


void inspectFile(string file_name)
{
    ofstream out(file_name, ios::out);

    if (!out.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(file_name);
    }

    out.close();
}

void createFile(string file_name)
{
    ofstream out(file_name, ios::out);

    if (!out.is_open())
    {
        cout << FILE_CREATE_ERROR;
    }

    cout << "\nНет данных!\n";
    out.close();
}

int countLines(string file_name)
{
    ifstream in(file_name, ios::in);

    if (!in.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(file_name);
    }

    int counter = 0;
    string temp_line;
    while (!in.eof())
    {
        getline(in, temp_line);
        if (temp_line.length() != 0)
        {
            counter++;
        }
    }

    in.close();
    return counter;
}

vector<struct worker> readDataFile()
{
    ifstream in(DATA_FILE, ios::in);

    if (!in.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(DATA_FILE);
    }

    vector<struct worker> work_vector;
    struct worker temp_vector;
    while (!in.eof())
    {
        getline(in, temp_vector.tname.surname, '.');
        getline(in, temp_vector.tname.name, '.');
        getline(in, temp_vector.tname.patronum, '.');


        string temp;
        getline(in, temp, '.');
        temp_vector.birth.day = verifyReadInt(temp);

        getline(in, temp, '.');
        temp_vector.birth.month = verifyReadInt(temp);

        getline(in, temp, '.');
        temp_vector.birth.year = verifyReadInt(temp);

        getline(in, temp, '.');
        temp_vector.work.begin.day = verifyReadInt(temp);

        getline(in, temp, '.');
        temp_vector.work.begin.month = verifyReadInt(temp);

        getline(in, temp, '.');
        temp_vector.work.begin.year = verifyReadInt(temp);



        getline(in, temp_vector.work.department, '.');
        getline(in, temp_vector.work.post, '.');

        work_vector.push_back(temp_vector);
    }

    in.close();
    return work_vector;
}

void showDataFile(vector<struct worker>& work_vector)
{
    cout << SEPARATOR;
    if (work_vector.size() == 0)
    {
        cout << "Нет данных!\n\n";
    }
    else
    {
        int full_name_size, department_size, post_size;
        full_name_size = learnLongestLine(work_vector);
        department_size = learnLongestLine(DEPARTMENTS_FILE);
        post_size = learnLongestLine(POSTS_FILE);

        cout << setw(4) << left << "№" << ' | ' << setw(full_name_size) << left << "ФИО" << ' | ' << setw(10) << left << "Дата рожд." << ' | ' << setw(10) << left << "Начал р-ть" << ' | ' << setw(department_size) << left << "Отдел" << ' | ' << setw(post_size) << left << "Должность" << endl << endl;

        for (int i = 0; i < work_vector.size(); i++)
        {
            work_vector[i].tname.full_name = work_vector[i].tname.surname + ' ' + work_vector[i].tname.name + ' ' + work_vector[i].tname.patronum;
            verifyData(work_vector[i]);

            cout << setw(4) << left << i + 1  << ' | ' << setw(full_name_size) << left << work_vector[i].tname.full_name << ' | ';

            verifyZero(work_vector[i].birth.day);
            cout << work_vector[i].birth.day << '.';

            verifyZero(work_vector[i].birth.month);
            cout << work_vector[i].birth.month << '.' << work_vector[i].birth.year << ' | ';

            verifyZero(work_vector[i].work.begin.day);
            cout << work_vector[i].work.begin.day << '.';

            verifyZero(work_vector[i].work.begin.month);
            cout << work_vector[i].work.begin.month << '.' << work_vector[i].work.begin.year << ' | ';

            cout << setw(department_size) << left << work_vector[i].work.department << ' | ';
            cout << setw(post_size) << left << work_vector[i].work.post << endl;
        }
        cout << endl;
    }
}
//разбить на функции, ввести константы
void writeDataFile(vector<struct worker>& work_vector)
{
    ofstream out(DATA_FILE, ios::out);

    if (!out.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(DATA_FILE);
    }

    for (int i = 0; i < work_vector.size(); i++)
    {
        out << work_vector[i].tname.surname <<'.'<< work_vector[i].tname.name <<'.'<< work_vector[i].tname.patronum<<'.';
        out << work_vector[i].birth.day << '.' << work_vector[i].birth.month << '.' << work_vector[i].birth.year << '.';
        out << work_vector[i].work.begin.day << '.' << work_vector[i].work.begin.month << '.' << work_vector[i].work.begin.year << '.';
        out << work_vector[i].work.department << '.' << work_vector[i].work.post << '.' << endl;
    }

    out.close();
}

vector<struct user> readAccountsFile()
{
    ifstream in(ACCOUNTS_FILE, ios::in);
    vector <struct user> users;
    if (!in.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(ACCOUNTS_FILE);
    }
    else
    {
        user temp_user;
        while (!in.eof())
        {
            in >> temp_user.login >> temp_user.password;

            string temp_role;
            in >> temp_role;
            temp_user.role=verifyReadInt(temp_role);

            users.push_back(temp_user);
        }
    }
    in.close();
    return users;
}

void showAccountsFile(vector<struct user>& users)
{
    cout << SEPARATOR;
    if (users.size() == 0)
    {
        cout << "Файл пуст!\n\n";
    }
    else
    {
        cout << setw(10) << left << "Логин" << ' ' << setw(32) << left << "Пароль" << ' ' << "Роль";

        for (int i = 0; i < users.size(); i++)
        {
            cout << endl << setw(10) << left << users[i].login << ' ' << setw(32) << left << users[i].password << ' ' << users[i].role;
        }
    }
}
//разбить на функции, ввести константы
void writeAccountsFile(vector<struct user>& users)
{
    ofstream out(ACCOUNTS_FILE, ios::out);

    if (!out.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(ACCOUNTS_FILE);
    }
    else
    {
        for (int i = 0; i < users.size(); i++)
        {
            out << endl << users[i].login << ' ' << users[i].login << ' ' << users[i].role;
        }
    }
    out.close();
}


void verifyData(worker& temp_worker)
{
    string& full_name = temp_worker.tname.full_name;
    int& birth_day = temp_worker.birth.day, &birth_month = temp_worker.birth.month, &birth_year = temp_worker.birth.year;
    int& work_day = temp_worker.work.begin.day, &work_month= temp_worker.work.begin.month, &work_year = temp_worker.work.begin.year;
    string& department = temp_worker.work.department;
    string& post = temp_worker.work.post;

    if (verifyFullName(full_name) + verifyDay(birth_day, birth_month, birth_year) + verifyMonth(birth_month) + verifyYear(birth_year) + verifyDepartment(department) + verifyPost(post) + verifyDay(work_day, work_month, work_year) + verifyMonth(work_month) + verifyYear(work_year) != 0)
    {
        showEditMessage();
    }
}

int verifyFullName(string& full_name)
{
    bool flag = true;
    for (int i = 0; i < full_name.length(); i++)
    {
        if (((full_name[i]>127) && (full_name[i]<127)) || ((full_name[i]>223) && (full_name[i]<242)) || (full_name[i] == 32) || (full_name[i] == 45))
        {
            continue;
        }
        full_name.erase(i, 1);
        flag = false;
    }
    if (flag)
        return 0;
    else
        return 1;
}

int verifyDay(int& day, int month, int year)
{
    if (day > 0)
    {
        if ((month != 2) && (day < 31))
            return 0;
        else if (((month == 1) || (month == 3) || (month == 5) || (month == 7) || (month == 8) || (month == 10) || (month == 12)) && (day < 32))
            return 0;
        else if ((month == 2) && (day < 29))
            return 0;
        else if ((month == 2) && (day < 29) && (((year % 100 != 0) && (year % 4 == 0))) || ((year % 100 == 0) && (year % 400 == 0)))
            return 0;
        else
        {
            day = 1;
            return 1;
        }
    }
    else
    {
        day = 1;
        return 1;
    }
}

int verifyMonth(int& month)
{
    if ((month < 1) || (month > 12))
    {
        month = 1;
        return 1;
    }
    else
        return 0;
}

int verifyYear(int& year)
{
    if ((year < 1900) || (year > 2000))
    {
        year = 1900;
        return 1;
    }
    else
        return 0;
}

int verifyDepartment(string& department)
{
    ifstream in(DEPARTMENTS_FILE, ios::in);
    if (!in.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(DEPARTMENTS_FILE);
    }
    else
    {
        string temp_line;
            while (!in.eof())
            {
                getline(in, temp_line);
                if (department == temp_line)
                {
                    in.close();
                    return 0;
                }
            }
    }
    department = LINE_UNKNOWN;
    in.close();
    return 1;
}

int verifyPost(string& post)
{
    ifstream in(POSTS_FILE, ios::in);
    if (!in.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(POSTS_FILE);
    }
    else
    {
        string temp_line;
        while (!in.eof())
        {
            getline(in, temp_line);
            if (post == temp_line)
            {
                in.close();
                return 0;
            }
        }
    }
    post = LINE_UNKNOWN;
    in.close();
    return 1;
}

void showEditMessage()
{
    cout << SEPARATOR << FOR_EDIT_MESSAGE;
}

void verifyZero(int number)
{
    if (number < 10)
    {
        cout << "0";
    }
}

int verifyReadInt(string temp)
{
    for (int i = 0; i < temp.length(); i++)
    {
        if ((temp[i] < 48) || (temp[i]>57))
        {
            temp.erase(i, 1);
        }
    }
    if (temp.length() == 0)
    {
        temp = "1";
    }
    return stoi(temp);
}

int learnLongestLine(vector<struct worker>& work_vector)
{
    int max_line_size = LINE_UNKNOWN.length();
    for (int i = 0; i < work_vector.size(); i++)
    {
        if (max_line_size < work_vector[i].tname.full_name.length())
        {
            max_line_size = work_vector[i].tname.full_name.length();
        }
    }
    return max_line_size;
}

int learnLongestLine(string file_name)
{
    ifstream in(file_name, ios::in);
    if (!in.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(file_name);
    }
    else
    {
        int max_line_size = LINE_UNKNOWN.length();
        string temp_line;
        while (!in.eof())
        {
            getline(in, temp_line);
            if (max_line_size < temp_line.length())
            {
                max_line_size = temp_line.length();
            }
        }

        in.close();
        return max_line_size;
    }
}


string cipherUser(user temp_user)
{
    if (temp_user.login.length() < 10)
    {
        while (temp_user.login.length() < 10)
            temp_user.login += ',';
    }
    if (temp_user.password.length() < 16)
    {
        while (temp_user.login.length() < 16)
            temp_user.login += '\'';
    }

    string cipher_string;
    cipher_string = temp_user.login + "..." + temp_user.password + SALT + (char)(temp_user.role + temp_user.login[1]);

    for (int i = 0; i < cipher_string.length(); i++)
    {
        switch (cipher_string[i] % 5)
        {
            case 0:
            {
                cipher_string[i] += 3;
                break;
            }
            case 1:
            {
                cipher_string[i] += 5;
                break;
            }
            case 2:
            {
                cipher_string[i] += 2;
                break;
            }
            case 3:
            {
                cipher_string[i] += 1;
                break;
            }
            case 4:
            {
                cipher_string[i] += 4;
                break;
            }
        }
        cipher_string[i] -= 1;
    }
    return cipher_string;
}



void registrUser(vector<struct user>& work_vector)
{
    ofstream out(NEW_USERS_FILE, ios::app);
    if (!out.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(NEW_USERS_FILE);
    }
    else
    {
        out << registrLogin(work_vector) << ' ' << inputPassword() << endl;
    }

    out.close();
}
//прописать возврат в главное меню
string registrLogin(vector<struct user>& work_vector)
{
    bool flag = false;
    while (!flag)
    {
        cout << "\nДля выхода в главное меню нажмите \"0\": \n Для продолжения - любую другую клавишу: \n";
        int check_out;
        cin >> check_out;
        cout << endl;
        if (!check_out)
        {
            return 0;
        }
        else
        {
            flag = true;

            cout << INPUT_LOGIN;
            string login;
            cin >> login;

            if ((login.length() >= 6) || (login.length() <= 10))
            {
                bool symbols_flag = true;
                int i = 0;
                while ((flag) && (i < login.length()))
                {
                    if ((login[i] == 95) || ((login[i]>47) && (login[i] < 58)) || ((login[i]>64) && (login[i] < 91)) || ((login[i]>96) && (login[i] < 123)))
                    {
                        i++;
                        continue;
                    }
                    symbols_flag = false;
                }
            }
            if (isOriginalLogin(login, work_vector))
            {
                return login;
            }
        }
    }
}
//разбить на функции
string inputPassword()
{
    cout << INPUT_PASSWORD;
    string pass;
    cin >> pass;

    if ((pass.length() >= 8) || (pass.length() <= 16))
    {
        bool flag = true;
        int i = 0;
        while ((flag) && (i < pass.length()))
        {
            if ((pass[i] == 95) || ((pass[i]>47) && (pass[i] < 58)) || ((pass[i]>64) && (pass[i] < 91)) || ((pass[i]>96) && (pass[i] < 123)))
            {
                i++;
                continue;
            }
            flag = false;
        }
        if (flag)
        {
            return pass;
        }
    }
    cout << FOR_PASSWORD << HELP_LINE;
    inputPassword();
}
//разбить на функции
bool isOriginalLogin(string login, vector<struct user>& work_vector)
{
    for (int i = 0; i < work_vector.size(); i++)
    {
        if (login == work_vector[i].login)
        {
            return false;
        }
    }
    return true;
}

void logInAccount(vector<struct user>& work_vector, bool& main_menu_flag)
{
    bool flag = false;
    while (!flag)
    {
        string login = inputLogin(work_vector);
        string password = inputPassword();
        if (login == "0")
        {
            return;
        }
        else if (!isTruePassword(login, password, work_vector))
        {
            cout << SEPARATOR << "\nЗдравствуйте, " << login << "!\n\n";
            chooseUserMenu(main_menu_flag);
            flag = true;
        }
        else
        {
            cout << "\n\nНеверный логин или пароль. Попробуйте еще раз.\n\n";
        }
    }
}

string inputLogin(vector<struct user>& work_vector)
{
    bool flag = false;
    while (!flag)
    {
        cout << "\nДля выхода в главное меню нажмите \"0\": \nДля продолжения - любую другую клавишу: \n";
        char check_out;
        cin >> check_out;
        cout << endl;
        if (check_out =='0')
        {
            return "0";
        }
        else
        {
            flag = true;

            cout << INPUT_LOGIN;
            string login;
            cin >> login;

            if ((login.length() >= 6) || (login.length() <= 10))
            {
                bool symbols_flag = true;
                int i = 0;
                while ((flag) && (i < login.length()))
                {
                    if ((login[i] == 95) || ((login[i]>47) && (login[i] < 58)) || ((login[i]>64) && (login[i] < 91)) || ((login[i]>96) && (login[i] < 123)))
                    {
                        i++;
                        continue;
                    }
                    symbols_flag = false;
                }

                if (!isOriginalLogin(login, work_vector))
                {
                    return login;
                }
            }
        }
    }
}

bool isTruePassword(string login, string password, vector<struct user>& work_vector)
{
    for (int i = 0; i < work_vector.size(); i++)
    {
        if ((password == work_vector[i].password) && (login == work_vector[i].login))
        {
            return false;
        }
    }
    return true;
}


void sortAlfabet(vector<struct worker>& work_vector)
{
    cout << "\nВведите искомое сочетание букв: \n";
    string temp_search;
    getline(cin, temp_search);

    vector<struct worker> sort_vector;
    for (int i = 0; i < work_vector.size(); i++)
    {
        if (work_vector[i].tname.full_name.find(temp_search) != string::npos)
        {
            sort_vector.push_back(work_vector[i]);
        }
    }

    showDataFile(sort_vector);
}

void sortDepartment(vector<struct worker>& work_vector)
{
    cout << "\nВведите искомое сочетание букв: \n";
    string temp_search;
    getline(cin, temp_search);

    vector<struct worker> sort_vector;
    for (int i = 0; i < work_vector.size(); i++)
    {
        if (work_vector[i].work.department.find(temp_search) != string::npos)
        {
            sort_vector.push_back(work_vector[i]);
        }
    }

    showDataFile(sort_vector);
}

void sortPost(vector<struct worker>& work_vector)
{
    cout << "\nВведите искомое сочетание букв: \n";
    string temp_search;
    getline(cin, temp_search);

    vector<struct worker> sort_vector;
    for (int i = 0; i < work_vector.size(); i++)
    {
        if (work_vector[i].work.post.find(temp_search) != string::npos)
        {
            sort_vector.push_back(work_vector[i]);
        }
    }

    showDataFile(sort_vector);
}


bool isExit()
{
    cout << SEPARATOR << FOR_EXIT << LINE_TRUE << LINE_FALSE;

    bool flag = true;
    if (chooseItem(2) == '1')
    {
        flag = false;
    }

    return flag;
}