Курсач

#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\n" };
const int COUNTER_USER_MENU = 6;
const string LINES_ADMIN_MENU[] = { "\n\n\n------------Меню администратора--------------\n\n","1 - Учетные записи\n","2 - Файлы\n","3 - Данные\n","4 - Пользовательский модуль\n","5 - Выйти из программы\n","6 - Вернуться в главное меню\n\n" };
const int COUNTER_ADMIN_MENU = 6;
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\n" };
const int COUNTER_DATA_MENU = 5;

const string FOR_EDIT_MESSAGE = "Некоторые данные были некорректнs.\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___________________________________\n\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&);

void showFileMenu();
void chooseFileMenu();

void showAccountMenu();
void chooseAccountMenu();

void showDataMenu();
void chooseDataMenu();
//-----------------------------------
void inspectFile(string);
void createFile(string);
int countLines(string);
//-----------------------------------
void readFile(vector<struct worker>&);
void showFile(vector<struct worker>&);
void writeFile(vector<struct worker>&);
//-----------------------------------
void readFile(vector<struct user>&);
void showFile(vector<struct user>&);
void writeFile(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);
struct user unscrambleUser(string);
//-----------------------------------
void registrUser();
string inputLogin();
string inputPassword();
//-----------------------------------
bool isExit();

struct worker
{
    struct tname
    {
        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 <= 5; i++)
    {
        cout << LINES_MAIN_MENU[i];
    }
}

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

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

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

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

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

void showDataMenu()
{
    for (int i = 0; i <= 5; i++)
    {
        cout << LINES_DATA_MENU[i];
    }
}
//функции "добавить отдел" и "добавить должность"
void chooseMainMenu()
{
    bool main_menu_flag0 = true;
    bool& main_menu_flag = main_menu_flag0;
    while (main_menu_flag == true)
    {
        showMainMenu();
        switch (chooseItem(COUNTER_MAIN_MENU))
        {
        case '1':
        {
            //sign up
            break;
        }

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

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

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

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

void chooseGuestMenu(bool& main_menu_flag)
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        vector <struct workers> workers_data();

        showGuestMenu();
        switch (chooseItem(COUNTER_GUEST_MENU))
        {
        case '1':
        {
            //show
            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)
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        showUserMenu();
        switch (chooseItem(COUNTER_USER_MENU))
        {
        case '1':
        {
            //show
            break;
        }

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

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

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

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

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

void chooseAdminMenu(bool& main_menu_flag)
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        activateHackerRegime();
        showAdminMenu();
        switch (chooseItem(COUNTER_ADMIN_MENU))
        {
        case '1':
        {
            chooseFileMenu();
            break;
        }

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

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

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

        case '5':
        {
            main_menu_flag = menu_flag = isExit();
            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()
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        showAccountMenu();
        switch (chooseItem(COUNTER_ACCOUNT_MENU))
        {
        case '1':
        {
            //show
            break;
        }

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

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

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

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

void chooseDataMenu()
{
    bool menu_flag = true;
    while (menu_flag == true)
    {
        showDataMenu();
        switch (chooseItem(COUNTER_DATA_MENU))
        {
        case '1':
        {
            //delete
            break;
        }

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

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

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

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



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

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

void readFile(vector<struct worker>& work_vector)
{
    ifstream in(DATA_FILE, ios::in);

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

    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();
}

void showFile(vector<struct worker>& work_vector)

{
    cout << SEPARATOR;
    int full_name_size, department_size, post_size;
    full_name_size = learnLongestLine(work_vector);
    department_size = learnLongestLine(DEPARTMENTS_FILE);
    post_size = learnLongestLine(POSTS_FILE);

    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 << 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 writeFile(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();
}

void readFile(vector<struct user>&)
{

}
//-
void showFile(vector<struct user>&)
{

}
//-
void writeFile(vector<struct user>&)
{
    ofstream out(ACCOUNTS_FILE, ios::out);

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

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

struct user unscrambleUser(string temp_line)
{

}
//-

void registrUser()
{
    ofstream out(NEW_USERS_FILE, ios::app);
    if (!out.is_open())
    {
        cout << FILE_OPEN_ERROR;
        createFile(NEW_USERS_FILE);
    }
    else
    {
        out << inputLogin() << ' ' << inputPassword() << endl;
    }

    out.close();
}

string inputLogin()
{
    cout << INPUT_LOGIN;
    string login;
    cin >> login;

    if ((login.length() >= 6) || (login.length() <= 10))
    {
        bool 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;
            }
            flag = false;
        }
        if (flag)
        {
            return login;
        }
    }
        cout << FOR_LOGIN << HELP_LINE;
        inputLogin();
}
//разбить на функции
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 isExit()
{
    cout << SEPARATOR << FOR_EXIT << LINE_TRUE << LINE_FALSE;

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

    return flag;
}