breaking changes

new design proposed

headers/util.hpp

@@ -38,11 +38,11 @@ struct KFileData {
     QByteArray bytes;
 };
 
-struct Task {
-  QVector<KFileData> files;
-  std::vector<std::string> args;
-  int mask;
-};
+// struct Task {
+//  QVector<KFileData> files;
+//  std::vector<std::string> args;
+//  int mask;
+//};
 
 typedef QQueue<Task> TaskQueue;
 

include/task/instagram_task.hpp

@@ -2,15 +2,20 @@
 #define __INSTAGRAM_TASK_HPP__
 
 #include <include/task/task.hpp>
+#include <type_traits>
 
-namespace Task {
-
-class InstagramTask : public Task {
+class InstagramTask : public Scheduler::Task {
  public:
-  bool isReady() override { return false; }
-  virtual const TaskArguments getTaskArguments() override;
+  virtual bool isReady() override;
+  virtual void clear() override;
+  virtual const Scheduler::TaskArguments getTaskArguments() override;
+  virtual void defineTaskArguments() override;
   virtual ~InstagramTask() override;
+  template <typename T>
+  void setArgument(QString name, T arg);
+
+ private:
+  Scheduler::TaskArguments m_arguments;
 };
-}  // namespace Task
 
 #endif  // __INSTAGRAM_TASK_HPP

include/task/task.hpp

@@ -2,9 +2,19 @@
 #define __TASK_HPP__
 
 #include <QString>
-#include <QVector>
+#include <memory>
+#include <vector>
 
-namespace Task {
+enum FileType { VIDEO = 1, IMAGE = 2 };
+
+struct KFileData {
+  QString name;
+  FileType type;
+  QString path;
+  QByteArray bytes;
+};
+
+namespace Scheduler {
 
 namespace Type {
 static constexpr const char* TEXT = "Text";
@@ -17,22 +27,38 @@ static constexpr const char* BOOLEAN = "Boolean";
 
 using ArgumentType = const char*;
 
-class TaskArgument {
-  QString name;
-  ArgumentType type;
+class TaskArgumentBase {
+ public:
+  virtual QString text() const = 0;
+};
 
+template <typename T>
+class TaskArgument : TaskArgumentBase {
  public:
-  TaskArgument(QString n, QString t) : name(n), type(t) {}
+  TaskArgument(QString n, ArgumentType t, T _value) {
+    name = n;
+    type = t;
+    value = _value;
+  }
+  TaskArgument(TaskArgument&& a) : name(std::move(a.name)), type(std::move(a.type)), value(std::move(a.value)) {}
+  virtual QString text() const { return name; }
+  QString name;
+  ArgumentType type;
+  T value;
 };
 
-using TaskArguments = QVector<TaskArgument>;
+using TaskArguments = std::vector<std::unique_ptr<TaskArgumentBase>>;
 
 class Task {
  public:
+  virtual void defineTaskArguments() = 0;
   virtual bool isReady() = 0;
   virtual const TaskArguments getTaskArguments() = 0;
+  template <typename T>
+  void setArgument(QString name, T new_value){};
+  virtual void clear() = 0;
   virtual ~Task(){};
 };
-}  // namespace Task
+}  // namespace Scheduler
 
 #endif  // __TASK_HPP__

include/ui/argdialog.h

@@ -9,9 +9,12 @@
 #include <QMessageBox>
 #include <QPushButton>
 #include <headers/util.hpp>
+#include <include/task/task.hpp>
 #include <string_view>
 #include <unordered_map>
 
+using namespace Scheduler;
+
 namespace Args {
 const QString HEADER_TYPE = "header";
 const QString DESCRIPTION_TYPE = "description";
@@ -78,10 +81,11 @@ class ArgDialog : public QDialog {
   void addHashtag(QString tag);
   void addRequestedBy(QString value);
   void setTaskArguments();
+  void setArgTypes();
   Ui::ArgDialog *ui;
   void addItem(QString value, QString type);
   void addFile(QString path);
-  Task m_task;
+  Task *m_task;
   IGPost m_ig_post;
   QString m_file_path;
   QString m_config_string;

src/argdialog.cpp

@@ -10,7 +10,7 @@
 #include <algorithm>
 #include <vector>
 
-ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog), m_task(Task{}), m_ig_post(IGPost{}) {
+ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog), m_task(nullptr), m_ig_post(IGPost{}) {
   ui->setupUi(this);
 
   ui->argCommandButtons->button(QDialogButtonBox::Close)
@@ -148,16 +148,16 @@ void ArgDialog::setTaskArguments() {
         requested_by.pop_back();
     }
 
-    m_task.args.push_back(m_ig_post.datetime);
-    m_task.args.push_back(m_ig_post.description);
-    m_task.args.push_back(hashtags);
-    m_task.args.push_back(requested_by);
-    m_task.args.push_back(m_ig_post.requested_by_phrase);
-    m_task.args.push_back(m_ig_post.promote_share);
-    m_task.args.push_back(m_ig_post.link_in_bio);
-    m_task.args.push_back(std::to_string(m_ig_post.is_video));
-    m_task.args.push_back(m_ig_post.header);
-    m_task.args.push_back(m_ig_post.user);
+    m_task->setArgument<std::string>("datetime", m_ig_post.datetime);
+    m_task->setArgument<std::string>("description", m_ig_post.description);
+    m_task->setArgument<std::string>("hashtags", hashtags);
+    m_task->setArgument<std::string>("requested_by", requested_by);
+    m_task->setArgument<std::string>("requested_by_phrase", m_ig_post.requested_by_phrase);
+    m_task->setArgument<std::string>("promote_share", m_ig_post.promote_share);
+    m_task->setArgument<std::string>("link_in_bio", m_ig_post.link_in_bio);
+    m_task->setArgument<std::string>("is_video", std::to_string(m_ig_post.is_video));
+    m_task->setArgument<std::string>("header", m_ig_post.header);
+    m_task->setArgument<std::string>("user", m_ig_post.user);
 }
 
 void ArgDialog::addItem(QString value, QString type) {
@@ -220,10 +220,7 @@ void ArgDialog::clearPost() {
   ui->argList->setRowCount(0);
 }
 
-void ArgDialog::clearTask() {
-  m_task.args.clear();
-  m_task.mask = -1;
-}
+void ArgDialog::clearTask() { m_task->clear(); }
 
 void ArgDialog::addRequestedBy(QString value) {
   QStringList names = value.split(" ");
@@ -318,3 +315,10 @@ ArgDialog::~ArgDialog()
 }
 
 void ArgDialog::accept() { qDebug() << "Sending request to schedule a task.."; }
+
+void ArgDialog::setArgTypes() {
+  ui->argType->clear();
+  for (const auto &arg : m_task->getTaskArguments()) {
+    ui->argType->addItem(arg->text());
+  }
+}

src/instagram_task.cpp

@@ -1,19 +1,41 @@
 #include <include/task/instagram_task.hpp>
 
-using namespace Task;
+using namespace Scheduler;
 
-const TaskArguments InstagramTask::getTaskArguments() {
-  return QVector<TaskArgument>{TaskArgument{"header", Type::TEXT},
-                               TaskArgument{"description", Type::TEXT},
-                               TaskArgument{"datetime", Type::DATETIME},
-                               TaskArgument{"promote_share", Type::TEXT},
-                               TaskArgument{"link_in_bio", Type::TEXT},
-                               TaskArgument{"hashtags", Type::STRINGVECTOR},
-                               TaskArgument{"requested_by", Type::STRINGVECTOR},
-                               TaskArgument{"requested_by_phrase", Type::TEXT},
-                               TaskArgument{"files", Type::FILEVECTOR},
-                               TaskArgument{"user", Type::TEXT},
-                               TaskArgument{"is_video", Type::BOOLEAN}};
+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<std::vector<QString>>>("hashtags", Type::STRINGVECTOR, std::vector<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;
+}
+
+const TaskArguments InstagramTask::getTaskArguments() { return m_arguments; }
+
+template <typename T>
+void InstagramTask::setArgument(QString name, T value) {
+  if constexpr (std::is_same_v<T, QString>) {
+    auto it = std::find_if(m_arguments.begin(), m_arguments.end(),
+                           [name, value](auto argument) { return argument.text() == name; });
+    if (it != m_arguments.end()) {
+      it->value = value;
+    }
+  }
+}
+
+void InstagramTask::clear() {
+  // remove all arg values
 }
 
 InstagramTask::~InstagramTask() {}