ActiveCommand.cpp

@@ -14,15 +14,15 @@ namespace commands
 
     void ActiveCommand::run(stringstream& args)
     {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
         int user_id;
         args >> user_id;
         if (!user_id)
             throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
-        const User* u = mgr->get_user(user_id);
+        const User* u = mgr.get_user(user_id);
         if (!u)
             throw Error(401, "Eine solche BenutzerIn existiert nicht.");
-        for (const Assignment* a : mgr->get_assignments_for_user(user_id))
+        for (const Assignment* a : mgr.get_assignments_for_user(user_id))
             cout << a->get_task_id() << "\n";
     }
 } // commands

AddCommand.cpp

@@ -17,21 +17,21 @@ namespace commands
     void AddCommand::run(stringstream& args)
     {
         const string data_type = Util::read_string(args);
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
         if (data_type == "user")
         {
             AddUser u;
             args >> u;
-            mgr->add_user(new User(u));
+            mgr.add_user(new User(u));
         }
         else if (data_type == "task")
         {
             AddTask t;
             args >> t;
-            mgr->add_task(new Task(t));
+            mgr.add_task(new Task(t));
         }
         else
             throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden.");
-        mgr->save();
+        mgr.save();
     }
 } // commands

AssignCommand.cpp

@@ -14,21 +14,21 @@ namespace commands
 
     void AssignCommand::run(stringstream& args)
     {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
         int user_id, task_id;
         args >> user_id >> task_id;
         if (!args)
             throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
-        const User* u = mgr->get_user(user_id);
+        const User* u = mgr.get_user(user_id);
         if (!u)
             throw Error(401, "Eine solche BenutzerIn existiert nicht.");
-        const Task* t = mgr->get_task(task_id);
+        const Task* t = mgr.get_task(task_id);
         if (!t)
             throw Error(402, "Eine solche Aufgabe existiert nicht.");
-        if (mgr->assignment_exists(user_id, task_id))
+        if (mgr.assignment_exists(user_id, task_id))
             throw Error(302, "Eine solche Zuordnung existiert bereits.");
         Assignment* a = new Assignment(user_id, task_id);
-        mgr->add_assignment(a);
+        mgr.add_assignment(a);
-        mgr->save();
+        mgr.save();
     }
 } // commands

Assignment.cpp

@@ -5,7 +5,11 @@
 using err::Error;
 using util::Manager;
 namespace models {
-    Assignment::Assignment(const int& user_id, const int& task_id) : user_id(user_id), task_id(task_id) {}
+    Assignment::Assignment(const int& user_id, const int& task_id) : user_id(user_id), task_id(task_id) {
+        //validate user exist
+        //Manager& mgr = Manager::get_instance();
+
+    }
     Assignment::Assignment(): user_id(0), task_id(0) {}
 
     ostream& Assignment::write(ostream& stream) const
@@ -22,12 +26,12 @@ namespace models {
         return this->user_id;
     }
 
-    ostream& operator<<(ostream& os, const Assignment& assignment) {
+    ostream& operator<<(ostream& os, const Assignment& t) {
-        os << assignment.get_user_id() << " " << assignment.get_task_id() << "\n";
+        os << t.get_user_id() << " " << t.get_task_id() << "\n";
         return os;
     }
 
-    istream& operator>>(istream& is, Assignment& assignment) {
+    istream& operator>>(istream& is, Assignment& t) {
         int user_id;
         is >> user_id;
         if (!is)
@@ -36,7 +40,7 @@ namespace models {
         is >> task_id;
         if (!is)
             throw Error(602, "Datei hat ein unbekanntes Format.");
-       assignment= {user_id, task_id};
+        t = {user_id, task_id};
         return is;
     }
 } // models

DelCommand.cpp

@@ -14,19 +14,18 @@ namespace commands
 
     void DelCommand::run(stringstream& args)
     {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
         const string data_type = Util::read_string(args);
         int id;
         args >> id;
         if (!args)
             throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
         if (data_type == "user")
-            mgr->del_user(id);
+            mgr.del_user(id);
         else if (data_type == "task")
-            // Validate if we can Delete This Task.
+            mgr.del_task(id);
-            mgr->del_task(id);
         else
             throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
-        mgr->save();
+        mgr.save();
     }
 } // commands

ListCommand.cpp

@@ -17,16 +17,16 @@ namespace commands
 
     void ListCommand::run(stringstream& args)
     {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
         const string data_type = Util::read_string(args);
         if (data_type == "users")
-            for (const User* u : mgr->get_users())
+            for (const User* u : mgr.get_users())
                 cout << *u;
         else if (data_type == "tasks")
-            for (const Task* t : mgr->get_tasks())
+            for (const Task* t : mgr.get_tasks())
                 cout << *t;
         else if (data_type == "assignments")
-            for (const Assignment* a : mgr->get_assignments())
+            for (const Assignment* a : mgr.get_assignments())
                 cout << *a;
         else
             throw Error(101, "Befehl ist unbekannt.");

Manager.cpp

@@ -103,7 +103,7 @@ namespace util
     void Manager::update_task_id_index()
     {
         int i = 0;
-        for (const auto& task_pair : this->tasks)
+        for (const auto& task_pair : this->users)
             if (task_pair.second && task_pair.second->get_id() >= i)
                 i = task_pair.second->get_id() + 1;
         this->task_id_index = i;
@@ -129,13 +129,13 @@ namespace util
         return value;
     }
 
-    Manager* Manager::INSTANCE = nullptr;
+    Manager* Manager::INSTANCE;
 
-    Manager* Manager::get_instance()
+    Manager& Manager::get_instance()
     {
-        if (INSTANCE == nullptr)
+        if (!INSTANCE)
             INSTANCE = new Manager();
-        return INSTANCE;
+        return *INSTANCE;
     }
 
     vector<User*> Manager::get_users() const
@@ -161,7 +161,7 @@ namespace util
         return this->assignments;
     }
 
-    User* Manager::get_user(const int id)
+    User* Manager::get_user(const int& id)
     {
         if (this->users.count(id) == 0)
             return nullptr;
@@ -169,36 +169,26 @@ namespace util
     }
 
 
-    Task* Manager::get_task(const int id)
+    Task* Manager::get_task(const int& id)
     {
         if (this->tasks.count(id) == 0)
             return nullptr;
         return this->tasks[id];
     }
 
-    Vector<Assignment*> Manager::get_assignments_for_user(const int user_id)
+    Vector<Assignment*> Manager::get_assignments_for_user(const int& id)
     {
         Vector<Assignment*> user_assignments;
-        if (this->get_user(user_id) == nullptr)
+        if (this->get_user(id) == nullptr)
             throw Error(401, "Eine solche BenutzerIn existiert nicht.");
         for (Assignment* as : this->assignments)
-            if (as->get_user_id() == user_id)
+            if (as->get_user_id() == id)
                 user_assignments.push_back(as);
         return user_assignments;
     }
-    Vector<Assignment*> Manager::get_assignments_for_task(const int task_id)
+
+    bool Manager::assignment_exists(const int& user_id, const int& task_id)
     {
-        Vector<Assignment*> task_assignments;
-        if (this->get_task(task_id) == nullptr)
-            throw Error(401, "Eine solche BenutzerIn existiert nicht.");
-        for (Assignment* as : this->assignments)
-            if (as->get_task_id() == task_id)
-                task_assignments.push_back(as);
-        return task_assignments;
-    }
-
-    bool Manager::assignment_exists(int user_id, int task_id) {
-
         for ( Assignment* as : this->assignments)
             if (as->get_user_id() == user_id && as->get_task_id() == task_id)
                 return true;
@@ -231,24 +221,19 @@ namespace util
         this->assignments.push_back(as);
     }
 
-    void Manager::del_user(const int id)
+    void Manager::del_user(const int& id)
     {
         if (this->users.count(id) == 0)
             throw Error(401, "Eine solche BenutzerIn existiert nicht.");
-        //Assigment
+
-        if (!this->get_assignments_for_user(id).empty()) {
-            throw Error(201, "Benutzer kann nicht gelöscht werden.");
-        }
         this->users.erase(id);
     }
 
-    void Manager::del_task(const int id)
+    void Manager::del_task(const int& id)
     {
         if (this->tasks.count(id) == 0)
             throw Error(402, "Eine solche Aufgabe existiert nicht.");
-        if (!this->get_assignments_for_task(id).empty()) {
+
-            throw Error(201, "Aufgabe kann nicht gelöscht werden.");
-        }
         this->tasks.erase(id);
     }
 

Manager.h

@@ -30,9 +30,7 @@ namespace util
         void update_task_id_index();
 
     public:
-        Manager(const Manager&) = delete;
+        static Manager& get_instance();
-        Manager& operator=(const Manager&) = delete;
-        static Manager* get_instance();
 
         void save();
         void update_indexes();
@@ -43,18 +41,17 @@ namespace util
         vector<Task*> get_tasks() const;
         vector<Assignment*> get_assignments();
 
-        User* get_user(int id);
+        User* get_user(const int& id);
-        Task* get_task(int id);
+        Task* get_task(const int& id);
-        vector<Assignment *> get_assignments_for_user(int user_id);
+        vector<Assignment*> get_assignments_for_user(const int& id);
-        vector<Assignment *> get_assignments_for_task(int task_id);
+        bool assignment_exists(const int& user_id, const int& task_id);
-        bool assignment_exists(int user_id, int task_id);
 
         void add_user(User* user);
         void add_task(Task* task);
         void add_assignment(Assignment* as);
 
-        void del_user(int id);
+        void del_user(const int& id);
-        void del_task(int id);
+        void del_task(const int& id);
         void del_assignment(Assignment& as);
     };
 } // util

ShowCommand.cpp

@@ -18,15 +18,15 @@ namespace commands
 
     void ShowCommand::run(stringstream& args)
     {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
         const string data_type = Util::read_string(args);
         if (data_type == "user")
-            for (User* u : mgr->get_users()) {
+            for (User* u : mgr.get_users()) {
                 AddUser au = {*u};
                 cout << au;
             }
         else if (data_type == "task")
-            for (Task* t : mgr->get_tasks()) {
+            for (Task* t : mgr.get_tasks()) {
                 AddTask at = {*t};
                 cout << at;
             }

Task.cpp

@@ -20,8 +20,8 @@ namespace models
 
     Task::Task(const AddTask& t): id(0), name(t.get_name()), description(t.get_description()), children(t.get_children())
     {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
-        this->id = mgr->get_task_id();
+        this->id = mgr.get_task_id();
     }
 
 
@@ -46,8 +46,10 @@ namespace models
         return this->description;
     }
 
-    vector<int> Task::get_children() const { return this->children; }
+    vector<int> Task::get_children() const
-
+    {
+        return this->children;
+    }
 
     AddTask::AddTask(): Task() {}
 
@@ -87,7 +89,7 @@ namespace models
             if (name.empty())
                 throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
             string description = Util::read_string_between_percent(is);
-            vector<int> children = Task::read_children(is);
+            vector<int> children = Util::read_numbers(is);
             t = {id, name, description, children};
             return is;
         }
@@ -113,7 +115,7 @@ namespace models
             if (name.empty())
                 throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
             const string description = Util::read_string_between_percent(is);
-            const vector<int> children = Task::read_children(is);
+            const vector<int> children = Util::read_numbers(is);
             Task at = {0, name, description, children};
             t = at;
             return is;
@@ -125,21 +127,4 @@ namespace models
             throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
         }
     }
-
-    vector<int> Task::read_children(istream &is) {
-        vector<int> nums;
-        int num;
-
-        // Read integers directly from the stream until we hit an error (non-integer or EOF)
-        while (is >> num) {
-            nums.push_back(num);
-        }
-        // Stream wurde bad durch was anderes als EOF?
-        if (!is.eof()) {
-            is.clear();
-            throw Error(703, "Could not convert input to integer.");
-        }
-
-        return nums;
-    }
 } // models

Task.h

@@ -31,7 +31,6 @@ namespace models
         string get_name() const;
         string get_description() const;
         vector<int> get_children() const;
-        static Vector<int> read_children(istream &is);
 
 
         friend ostream& operator<<(ostream& os, const Task& t);

UnassignCommand.cpp

@@ -13,21 +13,21 @@ namespace commands
 
     void UnassignCommand::run(stringstream& args)
     {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
         int user_id, task_id;
         args >> user_id >> task_id;
         if (!args)
             throw Error(102, "Ein Parameter eines Befehls konnte nicht gelesen werden");
-        const User* u = mgr->get_user(user_id);
+        const User* u = mgr.get_user(user_id);
         if (!u)
             throw Error(401, "Eine solche BenutzerIn existiert nicht.");
-        const Task* t = mgr->get_task(task_id);
+        const Task* t = mgr.get_task(task_id);
         if (!t)
             throw Error(401, "Eine solche Zuordnung existiert nicht.");
-        if (!mgr->assignment_exists(user_id, task_id))
+        if (!mgr.assignment_exists(user_id, task_id))
             throw Error(302, "Eine solche Zuordnung existiert bereits.");
         Assignment as = {user_id, task_id};
-        mgr->del_assignment(as);
+        mgr.del_assignment(as);
-        mgr->save();
+        mgr.save();
     }
 } // commands

User.cpp

@@ -62,8 +62,8 @@ namespace models {
 
 
     istream& operator>>(istream& is, AddUser& u) {
-        Manager* mgr = Manager::get_instance();
+        Manager& mgr = Manager::get_instance();
-        int id = mgr->get_user_id();
+        int id = mgr.get_user_id();
 
         string name, surname;
         is >> name >> surname;

tasks

@@ -0,0 +1,13 @@
+[tasks]
+0 %Eine Aufgabe% %Mit einer längeren Beschreibung%
+1 %Noch eine Aufgabe% %Kurze Beschreibung% 0
+
+[users]
+0 Fleissiger Mitarbeiter
+1 NochEin Mitarbeiter
+
+[assignments]
+0 0
+0 1
+1 1
+