PasswordEntry.cpp

#include "PasswordEntry.h"
#include <algorithm>
#include <string.h>
#include <sstream>
#include <vector>
#include <iostream>

PasswordEntry::PasswordEntry() {
    name = "";
    password_text = "";
    category = "";
    login = "";
    service = "";
}

PasswordEntry::PasswordEntry(const std::string &name, const std::string &password_text,
                             const std::string &category,
                             const std::string &login, const std::string &service) :
        name(name),
        password_text(password_text),
        category(category),
        login(login),
        service(service) {};

const std::string PasswordEntry::getName() const {
    return name;
}

const std::string PasswordEntry::getPasswordText() {
    return password_text;
}

const std::string PasswordEntry::getCategory() const {
    return category;
}

const std::string PasswordEntry::getLogin() {
    return login;
}

const std::string PasswordEntry::getService() {
    return service;
}

void PasswordEntry::setName(const std::string &name) {
    PasswordEntry::name = name;
}

void PasswordEntry::setPasswordText(const std::string &password_text) {
    PasswordEntry::password_text = password_text;
}

void PasswordEntry::setCategory(const std::string &category) {
    PasswordEntry::category = category;
}

void PasswordEntry::setLogin(const std::string &login) {
    PasswordEntry::login = login;
}

void PasswordEntry::setService(const std::string &service) {
    PasswordEntry::service = service;
}

std::string PasswordEntry::toDisplayString() {
    std::string result = "Name: " + name + "\n" + "Password: " + password_text + "\n" +
                         "Category: " + category + "\n" + "Login: " + login + "\n" + "Service: " + service + "\n";
    return result;
}

std::string PasswordEntry::toStorageString() {
    std::string result = name + ";" + password_text + ";" + category + ";" + login + ";" + service + ";";
    return result;
}

void PasswordEntry::setFieldsFromStorageLine(std::string storage_line) {

    std::stringstream line_stream(storage_line);
    std::string parsed_field;
    std::vector<std::string> fields;
    while (std::getline(line_stream, parsed_field, ';')) {
        fields.push_back(parsed_field);
    }
    setName(fields.at(0));
    setPasswordText(fields.at(1));
    setCategory(fields.at(2));
    setLogin(fields.at(3));
    setService(fields.at(4));
}

void PasswordEntry::addCategory(std::vector<std::string> &categories) {
    if (!categories.empty()) {
        std::cout << "Existing categories: " << std::endl;
        for (std::string existing_category : categories) {
            std::cout << existing_category << std::endl;
        }
    }
    std::cout << "Enter the password category: " << std::endl;
    std::cin.ignore();
    std::getline(std::cin, category);
    std::vector<std::string>::iterator category_iter = std::find(categories.begin(), categories.end(), category);
    if (category_iter == categories.end()) {
        categories.push_back(category);
    }
}

bool PasswordEntry::createNewPassword(std::vector<std::string> &categories) {

    std::cout << "Please enter the password name: " << std::endl;
    std::cin.ignore();
    std::getline(std::cin, name);

    if (!generatePassword()) {
        return false;
    }

    addCategory(categories);

    std::cout << "Please enter the login: " << std::endl;
    std::getline(std::cin, login);

    std::cout << "Please enter the service: " << std::endl;
    std::getline(std::cin, service);

    if (name == "" || password_text == "" || category == "") {
        std::cout << "Invalid data: name, password, and category must be provided." << std::endl;
        std::cout << toDisplayString() << std::endl;
        return false;
    }
    return true;
}

bool PasswordEntry::generatePassword() {
    std::cout << "Choose a password generation method.\n";
    std::cout << std::endl;
    std::cout << "0. Automatic password generation.\n";
    std::cout << "1. Manual password entry.\n";
    std::string generation_choice;
    std::cin >> generation_choice;
    if (generation_choice == "0") {
        std::string length_string;
        int char_count;
        std::string include_special_chars;
        std::string include_mixed_case;
        std::cout << "How many characters should the password contain? (minimum 8)" << std::endl;
        std::cin >> char_count;
        if (char_count <= 7) {
            std::cout << "Too few characters. The password will default to 8 characters." << std::endl;
            char_count = 8;
        }
        std::cout << "Should the password include special characters? [T/N]" << std::endl;
        std::cin >> include_special_chars;
        if (include_special_chars != "T" && include_special_chars != "N") {
            std::cout << "Invalid parameter value. The password will not include special characters." << std::endl;
            include_special_chars = "N";
        }
        std::cout << "Should the password include uppercase and lowercase letters? [T/N]" << std::endl;
        std::cin >> include_mixed_case;
        if (include_mixed_case != "T" && include_mixed_case != "N") {
            std::cout << "Invalid parameter value. The password will include uppercase and lowercase letters." << std::endl;
            include_mixed_case = "T";
        }
        static const char digits_and_uppercase[] =
                "0123456789"
                "QWERTYUIOPLKJHGFDSAZXCVBNM";
        static const char lowercase[] =
                "qwertyuioplkjhgfdsazxcvbnm";
        static const char special_chars[] =
                "!@#$%*?>[:|]_+-=";
        std::string generation_pool = digits_and_uppercase;
        if (include_special_chars == "T") {
            generation_pool += special_chars;
        }
        if (include_mixed_case == "T") {
            generation_pool += lowercase;
        }

        std::string new_password;
        new_password.reserve(char_count);
        int pool_size = generation_pool.size();
        for (int i = 0; i < char_count; i++) {
            int random_index = rand() % (pool_size - 1);
            new_password += generation_pool[random_index];
        }
        std::cout << "New password: " + new_password << std::endl;
        password_text = new_password;
    } else if (generation_choice == "1") {
        std::cout << "Please enter the password: " << std::endl;
        std::cin.ignore();
        std::getline(std::cin, password_text);
    } else {
        std::cout << "Invalid generation option." << std::endl;
        return false;
    }
    return true;
}

bool PasswordEntry::compareEntries(const PasswordEntry &entryA, const PasswordEntry &entryB) {
    if (entryA.getName() < entryB.getName()) {
        return true;
    }
    if (entryA.getName() > entryB.getName()) {
        return false;
    }
    if (entryA.getCategory() > entryB.getCategory()) {
        return false;
    }
    if (entryA.getCategory() < entryB.getCategory()) {
        return true;
    }
    return false;
}

void PasswordEntry::editEntry(std::vector<std::string> &categories) {
    showEditMenu();
    std::cout << "Please enter the field number you would like to edit: " << std::endl;
    int user_choice;
    std::cin >> user_choice;
    std::string new_value;
    if (user_choice == 2) {
        generatePassword();
        new_value = password_text;
    } else if (user_choice == 3) {
        addCategory(categories);
        new_value = category;
    } else {
        std::cout << "Enter the new value:" << std::endl;
        std::cin.ignore();
        std::getline(std::cin, new_value);
    }
    if (user_choice < 4 && new_value == "") {
        std::cout << "The selected field cannot be empty." << std::endl;
    } else {
        switch (user_choice) {
            case 1:
                name = new_value;
                break;
            case 4:
                login = new_value;
                break;
            case 5:
                service = new_value;
                break;
        }
    }
    std::cout << toDisplayString() << std::endl;
}

void PasswordEntry::showEditMenu() {
    std::cout << "Menu: " << std::endl;
    std::cout << "1. Edit name." << std::endl;
    std::cout << "2. Edit password." << std::endl;
    std::cout << "3. Edit category." << std::endl;
    std::cout << "4. Edit login." << std::endl;
    std::cout << "5. Edit service." << std::endl;
}