refactor almost complete, including use of new Task type in client

decision needs to be made about flat buffers and its expectation to call c_str

include/client/client.hpp

@@ -36,10 +36,22 @@ typedef std::map<int, std::string> CommandMap;
 typedef std::map<int, std::vector<std::string>> CommandArgMap;
 typedef QVector<QString> StringVec;
 
+/**
+ * @brief The KString class
+ * Temporarily used to solve the interface problem with FlatBuffers, which seems designed to work best with std::string
+ */
+
+class KString : public QString {
+ public:
+  const QChar* c_str() {
+    return this->constData();
+  }
+};
+
 struct SentFile {
     int timestamp;
     QString name;
-    FileType type;
+    Scheduler::FileType type;
 };
 
 Q_DECLARE_METATYPE(StringVec)
@@ -85,7 +97,6 @@ class Client : public QDialog {
  private:
   void sendEncoded(std::string message);
   void sendFileEncoded(QByteArray bytes);
-  void sendTaskEncoded(TaskType type, std::vector<std::string> args);
   void sendTaskEncoded(Scheduler::Task* task);
   void processFileQueue();
   void handleMessages();

include/ui/argdialog.h

@@ -18,25 +18,6 @@ using namespace Scheduler;
 
 typedef std::string Str;
 
-typedef struct IGPost {
-  std::string header = "Learn to speak like native Korean speakers 🙆‍♀️🇰🇷";
-  std::string description;
-  std::string datetime;
-  std::string promote_share = "Share the post through IG story if you enjoy the phrase 🙋‍♀️";
-  std::string link_in_bio = "Subscribe to my YouTube channel (link 🔗in bio) to learn more about Korean language and culture ❤";
-  std::vector<std::string> hashtags;
-  std::vector<std::string> requested_by;
-  const char *requested_by_phrase = "The phrase was requested by ";
-  std::string user;
-  bool is_video;
-  bool isReady() {
-    return header.size() > 0 && description.size() > 0 && datetime.size() > 0 &&
-           promote_share.size() > 0 && link_in_bio.size() > 0 &&
-           hashtags.size() > 0 && requested_by.size() > 0 && !files.empty() &&
-           files.at(0).path.size() > 0 && user.size() > 0;
-  }
-} IGPost;
-
 namespace Ui {
 class ArgDialog;
 }
@@ -46,7 +27,7 @@ class ArgDialog : public QDialog {
 
  public:
   explicit ArgDialog(QWidget *parent = nullptr);
-  virtual void keyPressEvent(QKeyEvent* e);
+  virtual void keyPressEvent(QKeyEvent* e) override;
   void setFilePath(QString path);
   virtual void accept() override;
   void setConfig(QString config_string);
@@ -70,7 +51,6 @@ class ArgDialog : public QDialog {
   void addItem(QString value, QString type);
   void addFile(QString path);
   Task *m_task;
-  IGPost m_ig_post;
   QString m_file_path;
   QString m_config_string;
 };

src/argdialog.cpp

@@ -10,7 +10,9 @@
 #include <algorithm>
 #include <vector>
 
-ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog), m_task(nullptr), m_ig_post(IGPost{}) {
+using namespace Scheduler;
+
+ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog), m_task(nullptr) {
   ui->setupUi(this);
 
   ui->argCommandButtons->button(QDialogButtonBox::Close)
@@ -31,7 +33,7 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
         QMimeDatabase db;
         auto is_video = db.mimeTypeForFile(file_path).name().contains("video");
         addItem(file_name, "file");
-        m_task->setArgument("files", Scheduler::KFileData{
+        m_task->addArgument("files", Scheduler::KFileData{
                                          .name = file_name,
                                          .type = is_video ? FileType::VIDEO : FileType::IMAGE,
                                          .path = file_path,
@@ -50,7 +52,7 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
             addFile("assets/previews/" + preview_filename);
             addItem(preview_filename, "file");
             addFile("assets/previews/" + preview_filename);
-            m_task->setArgument("files", Scheduler::KFileData{
+            m_task->addArgument("files", Scheduler::KFileData{
                                              .name = preview_filename,
                                              .type = is_video ? FileType::VIDEO : FileType::IMAGE,
                                              .path = preview_file_path,
@@ -73,8 +75,8 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
   });
 
   QObject::connect(ui->user, &QComboBox::currentTextChanged, this,
-                   [this](const QString &text) {
-                     m_ig_post.user = text.toUtf8().constData();
+                   [this](const QString &username) {
+                     m_task->setArgument("user", username);
                    });
 
   ui->argList->setHorizontalHeaderLabels(
@@ -97,13 +99,13 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
         addHashtag(text);
       } else if (type == Args::DESCRIPTION_TYPE) {
         addItem(text, type);
-        m_ig_post.description = escapeText(text).toUtf8().constData();
+        m_task->setArgument("description", escapeText(text));
       } else if (type == Args::PROMOTE_TYPE) {
         addOrReplaceInArgList(text, "promote/share");
-        m_ig_post.promote_share = text.toUtf8().constData();
+        m_task->setArgument("promote_share", text);
       } else if (type == Args::LINK_BIO_TYPE) {
         addOrReplaceInArgList(text, "link/bio");
-        m_ig_post.link_in_bio = text.toUtf8().constData();
+        m_task->setArgument("link_bio", text);
       } else if (type == Args::REQUESTED_BY_TYPE) {
         addRequestedBy(text);
       }
@@ -115,7 +117,7 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
 
   QObject::connect(ui->dateTime, &QDateTimeEdit::dateTimeChanged, this, [this]() {
     auto date_time = ui->dateTime->dateTime();
-    m_ig_post.datetime = std::string{std::to_string(date_time.toTime_t())};
+    m_task->setArgument("datetime", date_time.toString());
     qDebug() << "Time changed to" << date_time;
   });
 
@@ -139,6 +141,9 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
   });
 }
 
+/**
+ * @brief ArgDialog::setTaskArguments
+ */
 void ArgDialog::setTaskArguments() {
   QString hashtags{};
   for (const auto &tag : std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("hashtags"))) {
@@ -149,13 +154,18 @@ void ArgDialog::setTaskArguments() {
   for (const auto &name : std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("requested_by"))) {
     requested_by += "@" + name + "";
   }
-  if (m_ig_post.requested_by.size() > 1) {
+  if (requested_by.size() > 1) {
     requested_by.chop(1);
   }
   m_task->setArgument("hashtags", hashtags);
   m_task->setArgument("requested_by", requested_by);
 }
 
+/**
+ * @brief ArgDialog::addItem
+ * @param value
+ * @param type
+ */
 void ArgDialog::addItem(QString value, QString type) {
   QTableWidgetItem *item = new QTableWidgetItem(type);
   QTableWidgetItem *item2 = new QTableWidgetItem(value);
@@ -171,11 +181,14 @@ void ArgDialog::addItem(QString value, QString type) {
     if (type->text() == "file") {
       auto value = ui->argList->item(row_index, 1);
       if (!value->text().isEmpty()) {
-        auto file_it = std::find_if(m_ig_post.files.begin(), m_ig_post.files.end(),
-                                    [value](const KFile &file) { return file.name == value->text(); });
-        if (file_it != m_ig_post.files.end()) {  // If file was matched
+        // All of the following should be done by the task
+        QVector<Scheduler::KFileData> task_files = std::get<VariantIndex::FILEVEC>(m_task->getTaskArgument("files"));
+        auto file_it = std::find_if(task_files.begin(), task_files.end(),
+                                    [value](const Scheduler::KFileData &file) { return file.name == value->text(); });
+        if (file_it != task_files.end()) {  // If file was matched
           qDebug() << "Removing file from task arguments";
-          m_ig_post.files.erase(file_it);
+          task_files.erase(file_it);
+          m_task->setArgument("files", task_files); // Probably not necessary. Try without doing this
         }
       }
     }
@@ -186,6 +199,10 @@ void ArgDialog::addItem(QString value, QString type) {
   ui->argList->setCellWidget(row, 3, q_pb);
 }
 
+/**
+ * @brief ArgDialog::addFile
+ * @param path
+ */
 void ArgDialog::addFile(QString path) {
   auto row_count = ui->argList->rowCount();
 
@@ -198,6 +215,9 @@ void ArgDialog::addFile(QString path) {
   ui->argList->setItem(row_count - 1, 2, file_item);
 }
 
+/**
+ * @brief ArgDialog::clearPost
+ */
 void ArgDialog::clearPost() {
   QDateTime date_time = QDateTime::currentDateTime();
   ui->dateTime->setDateTime(date_time);
@@ -209,13 +229,21 @@ void ArgDialog::clearPost() {
   ui->argList->setRowCount(0);
 }
 
+/**
+ * @brief ArgDialog::clearTask
+ */
 void ArgDialog::clearTask() { m_task->clear(); }
 
+/**
+ * @brief ArgDialog::addRequestedBy
+ * @param value
+ */
 void ArgDialog::addRequestedBy(QString value) {
   QStringList names = value.split(" ");
+  QVector<QString> requested_by_names = std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("requested_by"));
   for (const auto &name : names) {
-    if (std::find(m_ig_post.requested_by.begin(), m_ig_post.requested_by.end(), value.toUtf8().constData()) == m_ig_post.requested_by.end()) {
-      m_ig_post.requested_by.push_back(name.toUtf8().constData());
+    if (std::find(requested_by_names.begin(), requested_by_names.end(), value.toUtf8().constData()) == requested_by_names.end()) {
+      m_task->addArgument("requested_by", name);
       addToArgList(name, "requested_by");
     } else {
         const char* message = "You have already inputed this name under \"requested_by\"";
@@ -229,6 +257,11 @@ void ArgDialog::addRequestedBy(QString value) {
   }
 }
 
+/**
+ * @brief ArgDialog::addToArgList
+ * @param value
+ * @param type
+ */
 void ArgDialog::addToArgList(QString value, QString type) {
   for (int i = 0; i < ui->argList->rowCount(); i++) {
     auto item = ui->argList->item(i, 0);
@@ -245,6 +278,11 @@ void ArgDialog::addToArgList(QString value, QString type) {
     addItem(value, type);
 }
 
+/**
+ * @brief ArgDialog::addOrReplaceInArgList
+ * @param value
+ * @param type
+ */
 void ArgDialog::addOrReplaceInArgList(QString value, QString type) {
     for (int i = 0; i < ui->argList->rowCount(); i++) {
         auto item = ui->argList->item(i, 1);
@@ -258,24 +296,33 @@ void ArgDialog::addOrReplaceInArgList(QString value, QString type) {
     addItem(value, type);
 }
 
+/**
+ * @brief ArgDialog::addHashtag
+ * @param tag
+ */
 void ArgDialog::addHashtag(QString tag) {
     QStringList tags = tag.split(" ");
     for (const auto& tag : tags) {
-        if (std::find(m_ig_post.hashtags.begin(), m_ig_post.hashtags.end(), tag.toUtf8().constData()) == m_ig_post.hashtags.end()) {
-            m_ig_post.hashtags.push_back(tag.toUtf8().constData());
-            addToArgList(tag, "hashtag");
+      QVector<QString> hashtags = std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("hashtags"));
+        if (std::find(hashtags.begin(), hashtags.end(), tag.toUtf8().constData()) == hashtags.end()) {
+          m_task->addArgument("hashtags", tag);
+          addToArgList(tag, "hashtag");
         } else {
-            const char* message = "Can't add the same hashtag twice";
-            qDebug() << message;
-            QMessageBox::warning(
-                this,
-                tr("Hashtags"),
-                tr(message)
-                );
+          const char* message = "Can't add the same hashtag twice";
+          qDebug() << message;
+          QMessageBox::warning(
+              this,
+              tr("Hashtags"),
+              tr(message)
+              );
         }
     }
 }
 
+/**
+ * @brief ArgDialog::keyPressEvent
+ * @param e
+ */
 void ArgDialog::keyPressEvent(QKeyEvent *e) {
     if (Qt::ControlModifier) {
         if(e->key()==Qt::Key_Return || e->key()==Qt::Key_Enter) {
@@ -288,13 +335,21 @@ void ArgDialog::keyPressEvent(QKeyEvent *e) {
     }
 }
 
+/**
+ * @brief ArgDialog::setFilePath
+ * @param path
+ */
 void ArgDialog::setFilePath(QString path) { m_file_path = path; }
 
+/**
+ * @brief ArgDialog::setConfig
+ * @param config_string
+ */
 void ArgDialog::setConfig(QString config_string) {
   m_config_string = config_string;
   ui->user->addItems(getValueArgs(m_config_string.toUtf8(), "users"));
   if (ui->user->count() > 0) {
-    m_ig_post.user = ui->user->itemText(0).toUtf8().constData();
+    m_task->setArgument("user", ui->user->itemText(0));
   }
 }
 

src/client.cpp

@@ -41,7 +41,7 @@ Client::MessageHandler Client::createMessageHandler(std::function<void()> cb) {
  * @param [in] {int} count
  * @param [in] {char**} arguments
  */
-Client::Client(QWidget *parent, int count, char** arguments) : QDialog(parent), argc(count), argv(arguments), m_client_socket_fd(-1), m_commands({}), executing(false) {
+Client::Client(QWidget *parent, int count, char** arguments) : QDialog(parent), argc(count), argv(arguments), m_client_socket_fd(-1), executing(false), m_commands({}) {
     qRegisterMetaType<QVector<QString>>("QVector<QString>");
 }
 
@@ -88,15 +88,15 @@ void Client::handleMessages() {
             if (isUploadCompleteEvent(event.toUtf8().constData())) { // Upload complete
               if (!args.isEmpty()) {
                 sent_files.at(sent_files.size() - 1).timestamp =
-                    std::stoi(args.at(0).toUtf8().constData());
-                if (outgoing_files.isEmpty()) {
-                  sendTaskEncoded(TaskType::INSTAGRAM, m_task);
+                    std::stoi(args.at(0).toUtf8().constData()); // mark file with server-generated timestamp
+                if (outgoing_files.isEmpty()) { // Task files are all sent
+                  sendTaskEncoded(m_outbound_task); // Send remaining task data to complete scheduling
                   file_was_sent = false;
-                } else {
+                } else { // Begin file upload operation. Task will be sent after all outgoing files are sent.
                   sendEncoded(
                       createOperation("FileUpload", {"Subsequent file"}));
                 }
-                }
+              }
             }
         }
         std::string formatted_json = getJsonString(data_string);
@@ -104,14 +104,20 @@ void Client::handleMessages() {
     }
     memset(receive_buffer, 0, 2048);
     ::close(m_client_socket_fd);
-//    ::shutdown(m_client_socket_fd, SHUT_RDWR);
 }
 
+/**
+ * @brief Client::processFileQueue
+ */
 void Client::processFileQueue() {
   Scheduler::KFileData outgoing_file = outgoing_files.dequeue();
   sendFileEncoded(outgoing_file.bytes);
-  sent_files.push_back(SentFile{.name = outgoing_file.name, .type = outgoing_file.type});
+  sent_files.push_back(SentFile{
+      .name = outgoing_file.name,
+      .type = outgoing_file.type
+  });
 }
+
 /**
  * @brief Client::start
  */
@@ -207,6 +213,7 @@ void Client::sendEncoded(std::string message) {
     ::send(m_client_socket_fd, send_buffer, size + 5, 0);
     builder.Clear();
 }
+
 /**
  * @brief getTaskFileInfo
  * @param [in] {std::vector<SentFile>} files The files to produce an information string from
@@ -219,7 +226,7 @@ std::string getTaskFileInfo(std::vector<SentFile> files) {
         info += std::to_string(f.timestamp);
         info += f.name.toUtf8().constData();
         info += "|";
-        if (f.type == FileType::VIDEO) {
+        if (f.type == Scheduler::FileType::VIDEO) {
             info += "video";
         } else {
             info += "image";
@@ -236,31 +243,31 @@ std::string getTaskFileInfo(std::vector<SentFile> files) {
  */
 void Client::sendTaskEncoded(Scheduler::Task* task) {
   if (task->getType() == Scheduler::TaskType::INSTAGRAM) {
+    auto datetime = std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("datetime")).toUtf8().constData()};
     flatbuffers::Offset<IGTask> ig_task =
         CreateIGTask(
             builder,
             96,
             builder.CreateString(getTaskFileInfo(sent_files)),
+            builder.CreateString(datetime),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("datetime")).constData()),
-            builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("description")).constData()),
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("description"))}),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("hashtags")).constData()),
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("hashtags"))}),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_phrase")).constData()),
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_phrase"))}),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_phrase")).constData()),
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_phrase"))}),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("promote_share")).constData()),
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("promote_share"))}),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("link_in_bio")).constData()),
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("link_in_bio"))}),
             std::get<Scheduler::VariantIndex::BOOLEAN>(task->getTaskArgument("is_video")),
             std::get<Scheduler::VariantIndex::INTEGER>(task->getTaskArgument("mask")),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("header")).constData()),
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("header"))}),
             builder.CreateString(
-                std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("user")).constData()));
+                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("user"))}));
     builder.Finish(ig_task);
 
     uint8_t* encoded_message_buffer = builder.GetBufferPointer();
@@ -357,9 +364,9 @@ void Client::sendPackets(uint8_t* data, int size) {
 void Client::ping() {
   if (m_client_socket_fd != -1) {  // if we have active connection
     if (outgoing_files.size() == 0 || file_was_sent) {
-      // 1st condition: we aren't sending file packets
-      // 2nd condition: we're sending packets, but one file has sent and we want
-      // to ping in case the server is unresponsive
+      /* 1st condition: we aren't sending file packets
+         2nd condition: we were sending packets, but the file is complete and we want
+         to ping in case the server is unresponsive */
       uint8_t send_buffer[5];
       memset(send_buffer, 0, 5);
       send_buffer[4] = (TaskCode::PINGBYTE & 0xFF);
@@ -456,7 +463,8 @@ void Client::execute() {
 /**
  * @brief Client::scheduleTask
  * @param [in] {std::vector<std::string>} task_args The task arguments
- * @param [in] {bool}                     file_pending A boolean indicating whether there are files being sent for this task
+ * @param [in] {bool}                     file_pending A boolean indicating whether there are
+ *                                        files being sent for this task
  */
 void Client::scheduleTask(Scheduler::Task* task) {
   if (m_outbound_task == nullptr) {
@@ -485,8 +493,6 @@ void Client::sendFiles(Scheduler::Task* task) {
     std::string send_file_operation = createOperation("FileUpload", {});
     sendEncoded(send_file_operation);
   } else {
-    // TODO: place in queue and check queue after we finish scheduling the
-    // task associated with the outgoing files
     m_task_queue.enqueue(task);
     qDebug() << "Still attempting to send a different file";
   }

src/instagram_task.cpp

@@ -32,32 +32,18 @@ InstagramTask::InstagramTask(QVector<KFileData> k_files) : files(k_files) {}
  * @brief InstagramTask::defineTaskArguments
  */
 void InstagramTask::defineTaskArguments() {
-  std::vector<std::unique_ptr<TaskArgumentBase>> args{};
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("header", Type::TEXT, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("description", Type::TEXT, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("datetime", Type::DATETIME, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("promote_share", Type::TEXT, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("link_in_bio", Type::TEXT, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("hashtags", Type::TEXT, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<
-                        std::vector<QString>>>("requested_by", Type::STRINGVECTOR, std::vector<QString>{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("requested_by_phrase", Type::TEXT, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<
-                        std::vector<KFileData>>>("files", Type::FILEVECTOR, std::vector<KFileData>{})),
-  args.emplace_back(std::make_unique<
-                    TaskArgument<QString>>("user", Type::TEXT, QString{}));
-  args.emplace_back(std::make_unique<
-                    TaskArgument<bool>>("is_video", Type::BOOLEAN, bool{}));
-  m_arguments = args;
+  m_arguments.clear();
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("header", Type::TEXT, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("description", Type::TEXT, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("datetime", Type::DATETIME, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("promote_share", Type::TEXT, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("link_in_bio", Type::TEXT, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("hashtags", Type::TEXT, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("requested_by", Type::STRINGVECTOR, QVector<QString>{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("requested_by_phrase", Type::TEXT, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("files", Type::FILEVECTOR, QVector<KFileData>{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("user", Type::TEXT, QString{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("is_video", Type::BOOLEAN, bool{}));
 }
 
 /**
@@ -66,34 +52,62 @@ void InstagramTask::defineTaskArguments() {
  * @param value
  */
 void InstagramTask::setArgument(QString name, TypeVariant value) {
-  TaskIterator it =
-      std::find_if(m_arguments.begin(), m_arguments.end(), [name](auto argument) { return argument.text() == name; });
-  if (it != m_arguments.end()) {
+//  TaskIterator it =
+//      std::find_if(m_arguments.begin(), m_arguments.end(), [name](auto argument) { return argument.text() == name; });
+for (const auto& argument : m_arguments) {
+  if (argument.get()->text() == name) {
     if (isIndex(value.index(), VariantIndex::QSTRING)) {
-      it->get()->setValue(value);
+      argument.get()->setValue(value);
     } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
-      it->get()->setValue(QString::number(std::get<VariantIndex::BOOLEAN>(value)));
+      argument.get()->setValue(QString::number(std::get<VariantIndex::BOOLEAN>(value)));
     } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
-      it->get()->setValue(QString::number(std::get<VariantIndex::INTEGER>(value)));
+      argument.get()->setValue(QString::number(std::get<VariantIndex::INTEGER>(value)));
     } else {
       // Could not set argument value
       // TODO: Log here
     }
   }
+  return;
+}
+//  if (it != m_arguments.end()) {
+//    if (isIndex(value.index(), VariantIndex::QSTRING)) {
+//      it->get()->setValue(value);
+//    } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
+//      it->get()->setValue(QString::number(std::get<VariantIndex::BOOLEAN>(value)));
+//    } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
+//      it->get()->setValue(QString::number(std::get<VariantIndex::INTEGER>(value)));
+//    } else {
+//      // Could not set argument value
+//      // TODO: Log here
+//    }
+//  }
 }
 
 /**
- * @brief InstagramTask::setArgument
+ * @brief InstagramTask::addArgument
  * @param name
  * @param file
  */
-void InstagramTask::setArgument(QString name, Scheduler::KFileData file) {
-  TaskIterator it =
-      std::find_if(m_arguments.begin(), m_arguments.end(), [name](auto argument) { return argument.text() == name; });
-  if (it != m_arguments.end() && it->get()->getTypeIndex() == Scheduler::VariantIndex::FILEVEC) {
-    it->get()->insert(file);
-  } else {
-    // Could not add file to container
+void InstagramTask::addArgument(QString name, Scheduler::KFileData file) {
+  for (const auto& argument : m_arguments) {
+    if (argument.get()->text() == name) {
+      argument.get()->insert(file);
+      return;
+    }
+  }
+}
+
+/**
+ * @brief InstagramTask::addArgument
+ * @param name
+ * @param string
+ */
+void InstagramTask::addArgument(QString name, QString string) {
+  for (const auto& argument : m_arguments) {
+    if (argument.get()->text() == name) {
+      argument.get()->insert(string);
+      return;
+    }
   }
 }
 
@@ -102,11 +116,11 @@ void InstagramTask::setArgument(QString name, Scheduler::KFileData file) {
  * @param name
  * @return
  */
-TypeVariant InstagramTask::getTaskArgument(QString name) {
-  TaskIterator it =
-      std::find_if(m_arguments.begin(), m_arguments.end(), [name](auto argument) { return argument.text() == name; });
-  if (it != m_arguments.end()) {
-    return it->get()->getValue();
+const TypeVariant InstagramTask::getTaskArgument(QString name) {
+  for (const auto& argument : m_arguments) {
+    if (argument.get()->text() == name) {
+      return argument.get()->getValue();
+    }
   }
   return "";  // Perhaps we should throw
 }
@@ -117,7 +131,7 @@ TypeVariant InstagramTask::getTaskArgument(QString name) {
  */
 ArgumentValues InstagramTask::getArgumentValues() {
   ArgumentValues values{static_cast<int>(m_arguments.size())};
-  for (const auto& argument : m_arguments) {
+  for (auto& argument : m_arguments) {
     if (!argument->isContainer()) {
       values.push_back(argument->getStringValue());
     }
@@ -129,7 +143,7 @@ ArgumentValues InstagramTask::getArgumentValues() {
  * @brief InstagramTask::getTaskArguments
  * @return
  */
-const TaskArguments InstagramTask::getTaskArguments() { return m_arguments; }
+const TaskArguments InstagramTask::getTaskArguments() { return std::move(m_arguments); }
 
 
 /**