WorkCode

#include <iostream>
#include <string>

std::string ReadLine() {
    std::string s;
    std::getline(std::cin, s);
    return s;
}

int ReadLineWithNumber() {
    int result;
    std::cin >> result;
    ReadLine();
    return result;
}

class Job {
public:
    Job(int number_order, std::string code, std::string unit, double norm_of_time, double price, int number_accepted_units) {
        number_order_ = number_order;
        code_ = code;
        unit_ = unit;
        norm_of_time_ = norm_of_time;
        price_ = price;
        number_accepted_units_ = number_accepted_units;
        cost_ = number_accepted_units_ * price_;
    }

    int GetNumbreOrder() const {
        return number_order_;
    }

    const std::string& GetCode() const {
        return code_;
    }

    const std::string& GetUnit() const {
        return unit_;
    }

    double GetNormOfTime() const {
        return norm_of_time_;
    }

    double GetPrice() const {
        return price_;
    }

    int GetNumberAcceptedUnits() const {
        return number_accepted_units_;
    }

    double GetCost() const {
        return cost_;
    }

private:
    int number_order_; // Номер
    std::string code_; // Код
    std::string unit_; // Единица измерения
    double norm_of_time_; // Норма времени
    double price_; // Расценка
    int number_accepted_units_; // Количество принятых единиц измерения
    double cost_; // стоимость работы
};

class Worker {
public:
    Worker(int personnel_number) {
        personnel_number_ = personnel_number;
        jobs_ = new Job * [10];
        count_job_ = 0;
    }

    void AddJob(const Job& job) {
        jobs_[count_job_] = new Job(job);
        ++count_job_;
    }

    Job** GetJobs() const {
        return jobs_;
    }

    int GetCountJob() const {
        return count_job_;
    }

    ~Worker() {
        for (int i = 0; i < count_job_; ++i) {
            delete jobs_[i];
        }
        delete[] jobs_;
    }

    int GetPersonnelNumber() const {
        return personnel_number_;
    }

private:
    int personnel_number_; // Табельный номер рабочего
    int count_job_; // Количество работ
    Job** jobs_; // Работы
};

class DatabaseWorkers {
public:
    DatabaseWorkers() {
        workers_ = new Worker * [20];
        count_worker_ = 0;
    }

    void AddWorker(const Worker& worker) {
        workers_[count_worker_] = new Worker(worker);
        ++count_worker_;
    }

    bool CountWorker(int personnel_number) const {
        for (int i = 0; i < count_worker_; ++i) {
            if (workers_[i]->GetPersonnelNumber() == personnel_number) {
                return true;
            }
        }
        return false;
    }

    Worker* GetWorker(int personnel_number) const {
        return FindWorker(personnel_number);
    }

    ~DatabaseWorkers() {
        for (int i = 0; i < count_worker_; ++i) {
            delete workers_[i];
        }
        delete[] workers_;
    }

private:
    int count_worker_; // Количество рабочих
    Worker** workers_; // Рабочие

private:
    Worker* FindWorker(int personnel_number) const {
        int number = 0;
        for (int i = 0; i < count_worker_; ++i) {
            if (workers_[i]->GetPersonnelNumber() == personnel_number) {
                number = i;
                break;
            }
        }
        return workers_[number];
    }
};

std::ostream& operator<<(std::ostream& os, const Job& job) {
    os << "Номер наряда - " << job.GetNumbreOrder() << '\n';
    os << "Код работы - " << job.GetCode() << '\n';
    os << "Единица измерения - " << job.GetUnit() << '\n';
    os << "Норма времени - " << job.GetNormOfTime() << '\n';
    os << "Расценка - " << job.GetPrice() << '\n';
    os << "Количество принятых единиц измерения - " << job.GetNumberAcceptedUnits() << '\n';
    os << "Стоимость работы - " << job.GetCost();
    return os;
}

std::ostream& operator<<(std::ostream& os, const Worker& worker) {
    os << "Табелный номер - " << worker.GetPersonnelNumber() << '\n';
    int sum_cost = 0;
    Job** jobs = worker.GetJobs();
    for (int i = 0; i < worker.GetCountJob(); ++i) {
        sum_cost += jobs[i]->GetCost();
        os << "Работа №" << i + 1 << '\n';
        os << *(jobs[i]) << "\n\n";
    }
    os << "Итого - " << sum_cost;
    return os;
}

std::string* ParseString(const std::string str) {
    std::string* parse_str = new std::string[6];
    std::string tmp;
    int count_part = 0;
    for (int i = 0; i < str.size(); ++i) {
        if (str[i] != ' ') {
            tmp += str[i];
        }
        else {
            parse_str[count_part] = tmp;
            ++count_part;
            tmp.clear();
        }
    }
    parse_str[count_part] = tmp;

    return parse_str;
}

Job WriteInfromationAboutJob() {
    std::cout << "Введите информацию о работе\n";
    std::cout << "Номер наряда код работы единица измерения норма времени расценка количество принятых единиц измерения\n";
    std::string str = ReadLine();
    std::string* parse_str = ParseString(str);
    int number_order = std::stoi(parse_str[0]);
    std::string code = parse_str[1];
    std::string unit = parse_str[2];
    double norm_of_time = std::stod(parse_str[3]);
    double price = std::stod(parse_str[4]);
    int number_accepted_units = std::stoi(parse_str[5]);
    delete[] parse_str;
    return { number_order, code, unit, norm_of_time, price, number_accepted_units };
}

void WriteDataToDatabase(DatabaseWorkers& database) {
    std::cout << "Введите информацию о рабочих\n";
    int count_workers = 4;
    for (int i = 0; i < count_workers; ++i) {
        std::cout << "Введите табельный номер рабочего\n";
        int personnel_number = ReadLineWithNumber();
        Worker* worker;
        if (database.CountWorker(personnel_number)) {
            worker = database.GetWorker(personnel_number);
        }
        else {
            worker = new Worker(personnel_number);
        }
        worker->AddJob(WriteInfromationAboutJob());
        database.AddWorker(*worker);
    }
}

void PrintInformationWoker(const DatabaseWorkers& database) {
    while (true) {
        std::cout << "Введите табельный номер рабочего\n";
        int personnel_number;
        std::cin >> personnel_number;
        if (database.CountWorker(personnel_number)) {
            std::cout << *database.GetWorker(personnel_number) << std::endl;
        }
        else {
            std::cout << "Работника с таким табильным номером нет!\n";
        }
        std::cout << "Введите 0, чтобы завершить вывод информации: ";
        bool repeat;
        std::cin >> repeat;
        if (!repeat) {
            break;
        }
    }
}

//1 AAA kilog 12.5 10 100
//2 AAA kilog 5 20 50
//1 BBB milli 1 100 2
//3 ABC mickr 100 1 100


int main() {
    setlocale(LC_ALL, "ru");
    DatabaseWorkers database;
    WriteDataToDatabase(database);
    //    PrintInformationWoker(database);
    return 0;
}