Merge branch 'genericTask' into simplifyUi

headers/generictask.fbs

@@ -0,0 +1,14 @@
+namespace GenericData;
+
+table GenericTask {
+  id: int;
+  file_info: string;
+  time: string;
+  description: string;
+  is_video: bool;
+  mask: int;
+  header: string;
+  user: string;
+}
+
+root_type GenericTask;

headers/generictask_generated.h

@@ -0,0 +1,190 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_GENERICTASK_GENERICDATA_H_
+#define FLATBUFFERS_GENERATED_GENERICTASK_GENERICDATA_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace GenericData {
+
+struct GenericTask;
+struct GenericTaskBuilder;
+
+struct GenericTask FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef GenericTaskBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ID = 4,
+    VT_FILE_INFO = 6,
+    VT_TIME = 8,
+    VT_DESCRIPTION = 10,
+    VT_IS_VIDEO = 12,
+    VT_MASK = 14,
+    VT_HEADER = 16,
+    VT_USER = 18
+  };
+  int32_t id() const {
+    return GetField<int32_t>(VT_ID, 0);
+  }
+  const flatbuffers::String *file_info() const {
+    return GetPointer<const flatbuffers::String *>(VT_FILE_INFO);
+  }
+  const flatbuffers::String *time() const {
+    return GetPointer<const flatbuffers::String *>(VT_TIME);
+  }
+  const flatbuffers::String *description() const {
+    return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
+  }
+  bool is_video() const {
+    return GetField<uint8_t>(VT_IS_VIDEO, 0) != 0;
+  }
+  int32_t mask() const {
+    return GetField<int32_t>(VT_MASK, 0);
+  }
+  const flatbuffers::String *header() const {
+    return GetPointer<const flatbuffers::String *>(VT_HEADER);
+  }
+  const flatbuffers::String *user() const {
+    return GetPointer<const flatbuffers::String *>(VT_USER);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_ID) &&
+           VerifyOffset(verifier, VT_FILE_INFO) &&
+           verifier.VerifyString(file_info()) &&
+           VerifyOffset(verifier, VT_TIME) &&
+           verifier.VerifyString(time()) &&
+           VerifyOffset(verifier, VT_DESCRIPTION) &&
+           verifier.VerifyString(description()) &&
+           VerifyField<uint8_t>(verifier, VT_IS_VIDEO) &&
+           VerifyField<int32_t>(verifier, VT_MASK) &&
+           VerifyOffset(verifier, VT_HEADER) &&
+           verifier.VerifyString(header()) &&
+           VerifyOffset(verifier, VT_USER) &&
+           verifier.VerifyString(user()) &&
+           verifier.EndTable();
+  }
+};
+
+struct GenericTaskBuilder {
+  typedef GenericTask Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(int32_t id) {
+    fbb_.AddElement<int32_t>(GenericTask::VT_ID, id, 0);
+  }
+  void add_file_info(flatbuffers::Offset<flatbuffers::String> file_info) {
+    fbb_.AddOffset(GenericTask::VT_FILE_INFO, file_info);
+  }
+  void add_time(flatbuffers::Offset<flatbuffers::String> time) {
+    fbb_.AddOffset(GenericTask::VT_TIME, time);
+  }
+  void add_description(flatbuffers::Offset<flatbuffers::String> description) {
+    fbb_.AddOffset(GenericTask::VT_DESCRIPTION, description);
+  }
+  void add_is_video(bool is_video) {
+    fbb_.AddElement<uint8_t>(GenericTask::VT_IS_VIDEO, static_cast<uint8_t>(is_video), 0);
+  }
+  void add_mask(int32_t mask) {
+    fbb_.AddElement<int32_t>(GenericTask::VT_MASK, mask, 0);
+  }
+  void add_header(flatbuffers::Offset<flatbuffers::String> header) {
+    fbb_.AddOffset(GenericTask::VT_HEADER, header);
+  }
+  void add_user(flatbuffers::Offset<flatbuffers::String> user) {
+    fbb_.AddOffset(GenericTask::VT_USER, user);
+  }
+  explicit GenericTaskBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  GenericTaskBuilder &operator=(const GenericTaskBuilder &);
+  flatbuffers::Offset<GenericTask> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<GenericTask>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<GenericTask> CreateGenericTask(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t id = 0,
+    flatbuffers::Offset<flatbuffers::String> file_info = 0,
+    flatbuffers::Offset<flatbuffers::String> time = 0,
+    flatbuffers::Offset<flatbuffers::String> description = 0,
+    bool is_video = false,
+    int32_t mask = 0,
+    flatbuffers::Offset<flatbuffers::String> header = 0,
+    flatbuffers::Offset<flatbuffers::String> user = 0) {
+  GenericTaskBuilder builder_(_fbb);
+  builder_.add_user(user);
+  builder_.add_header(header);
+  builder_.add_mask(mask);
+  builder_.add_description(description);
+  builder_.add_time(time);
+  builder_.add_file_info(file_info);
+  builder_.add_id(id);
+  builder_.add_is_video(is_video);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<GenericTask> CreateGenericTaskDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t id = 0,
+    const char *file_info = nullptr,
+    const char *time = nullptr,
+    const char *description = nullptr,
+    bool is_video = false,
+    int32_t mask = 0,
+    const char *header = nullptr,
+    const char *user = nullptr) {
+  auto file_info__ = file_info ? _fbb.CreateString(file_info) : 0;
+  auto time__ = time ? _fbb.CreateString(time) : 0;
+  auto description__ = description ? _fbb.CreateString(description) : 0;
+  auto header__ = header ? _fbb.CreateString(header) : 0;
+  auto user__ = user ? _fbb.CreateString(user) : 0;
+  return GenericData::CreateGenericTask(
+      _fbb,
+      id,
+      file_info__,
+      time__,
+      description__,
+      is_video,
+      mask,
+      header__,
+      user__);
+}
+
+inline const GenericData::GenericTask *GetGenericTask(const void *buf) {
+  return flatbuffers::GetRoot<GenericData::GenericTask>(buf);
+}
+
+inline const GenericData::GenericTask *GetSizePrefixedGenericTask(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<GenericData::GenericTask>(buf);
+}
+
+inline bool VerifyGenericTaskBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<GenericData::GenericTask>(nullptr);
+}
+
+inline bool VerifySizePrefixedGenericTaskBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<GenericData::GenericTask>(nullptr);
+}
+
+inline void FinishGenericTaskBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<GenericData::GenericTask> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedGenericTaskBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<GenericData::GenericTask> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace GenericData
+
+#endif  // FLATBUFFERS_GENERATED_GENERICTASK_GENERICDATA_H_

headers/util.hpp

@@ -66,19 +66,27 @@ static QString escapeTextToRaw(QString s) {
 
 /**
  * @brief configValue
- * @param key [in] {QString} The key whose corresponding value is to be sought
+ * @param [in] {QString}    key          The key whose corresponding value is to be sought from the
- * from the ConfigJson param
+ *                                       ConfigJson param
- * @param [in] {ConfigJson} A Key-Value JSON Config object
+ * @param [in] {ConfigJson} config       JSON Config object
+ * @param [in] {bool}       use_default  Indicates that the default key will be sought if no value
+ *                                       matching the key parameter is found
  * @return {QString} The value which corresonds to the key, or an empty string
  *
  * TODO: ConfigJson should probably be called something else, like
  * ConfigJsonObject
  */
-QString configValue(QString key, ConfigJson config) {
+QString configValue(QString key, ConfigJson config, bool use_default = false) {
-  ConfigJson::iterator it{config.find(key)};  // Find iterator to element matching key
+  ConfigJson::iterator it{config.find(key.toLower())};  // Find iterator to element matching key
   if (it != std::end(config)) {               // If element was found
     return it->second;                        // Return the value of the Key-Pair element
   }
+  if (use_default) {
+    it = config.find("default");
+    if (it != std::end(config)) {               // If element was found
+      return it->second;                        // Return the value of the Key-Pair element
+    }
+  }
   return "";
 }
 
@@ -243,12 +251,14 @@ QList<QString> getValueArgs(const char* data, QString key) {
   Document d;
   d.Parse(data);
   QList<QString> args{};
-  for (const auto& m : d.GetObject()) {
+  if (d.IsObject()) {
-    auto name = m.name.GetString();
+    for (const auto& m : d.GetObject()) {
-    if (name == key.toUtf8()) {
+      auto name = m.name.GetString();
-      if (m.value.IsArray()) {
+      if (name == key.toUtf8()) {
-        for (const auto& a : m.value.GetArray()) {
+        if (m.value.IsArray()) {
-          args.push_back(a.GetString());
+          for (const auto& a : m.value.GetArray()) {
+            args.push_back(a.GetString());
+          }
         }
       }
     }
@@ -284,6 +294,7 @@ ConfigJson getConfigObject(QString json_string) {
             m.value.Accept(writer);
             QString config_value{buffer.GetString()};
             config_map.emplace(m.name.GetString(), config_value);
+            writer.Reset(buffer);
           }
         }
     }

include/client/client.hpp

@@ -29,6 +29,7 @@ using namespace Scheduler;
 namespace TaskCode {
 static constexpr int IGTASKBYTE = 0xFF;
 static constexpr int GENMSGBYTE = 0xFE;
+static constexpr int GENTASKBYTE = 0xFC;
 static constexpr int PINGBYTE = 0xFD;
 }  // namespace TaskCode
 

include/task/generic_task.hpp

@@ -0,0 +1,164 @@
+#ifndef __GENERIC_TASK_HPP__
+#define __GENERIC_TASK_HPP__
+
+#include <include/task/task.hpp>
+#include <type_traits>
+
+namespace Scheduler {
+namespace GenericArgs {
+const QString HEADER_TYPE = "header";
+const QString FILE_TYPE = "files";
+const QString DESCRIPTION_TYPE = "description";
+}  // namespace Args
+namespace TaskCode {
+static constexpr int GENTASKBYTE = 0xFC;
+}
+}  // namespace Scheduler
+
+/**
+ * @brief The GenericTask class
+ *
+ * Class to organize and transport data necessary to perform generic tasks.
+ */
+class GenericTask : public Scheduler::Task {
+ public:
+  /**
+   * @constructor
+   */
+  GenericTask();
+
+  /**
+   * Overrides @abstract Task::defineTaskArguments
+   *
+   * Useful for avoiding repetitive input of data.
+   */
+  virtual void defineTaskArguments() override;
+
+  /**
+   * Overrides @abstract Task::getTaskArguments
+   *
+   * Use this method to take over ownership of the task's arguments.
+   */
+  virtual const Scheduler::TaskArguments&& getTaskArguments() override;
+
+  /**
+   * Overrides @abstract Task::getTaskArgument
+   *
+   * Easy access to an argument.
+   */
+  virtual Scheduler::TaskArgument&& getTaskArgument(QString name) override;
+
+  /**
+   * Overrides @abstract Task::getTaskArgumentValue
+   *
+   * Easy access to an argument's value.
+   */
+  virtual const Scheduler::TypeVariant getTaskArgumentValue(QString name) override;
+
+  /**
+   * Overrides @abstract Task::getArgumentValues
+   *
+   * Easy access to all of the arguments that can be represented as a string.
+   */
+  virtual Scheduler::ArgumentValues getArgumentValues() override;
+
+  /**
+   * Overrides @abstract Task::getArgumentNames
+   *
+   * Provides the names of the arguments.
+   */
+  virtual QVector<QString> getArgumentNames() override;
+
+  /**
+   * Overrides @abstract Task::getFiles
+   *
+   * Easy access to the task's files.
+   */
+  virtual const QVector<Scheduler::KFileData> getFiles() override;
+
+  /**
+   * Overrides @abstract Task::getType
+   *
+   * Informs the caller of the task's type.
+   */
+  virtual Scheduler::TaskType getType() override;
+
+  /**
+   * Overrides @abstract Task::getTaskCode
+   *
+   * Returns the task's byte code.
+   */
+  virtual int getTaskCode() override;
+
+  /**
+   * Overrides @abstract Task::setArgument
+   *
+   * Set the value of an existing argument.
+   */
+  virtual void setArgument(QString name, Scheduler::TypeVariant arg) override;
+
+  /**
+   * Overrides @abstract Task::addArgument
+   *
+   * Add an additional value to a file container argument.
+   */
+  virtual void addArgument(QString name, Scheduler::KFileData file) override;
+
+  /**
+   * Overrides @abstract Task::addArgument
+   *
+   * Add an additional value to a string container argument.
+   */
+  virtual void addArgument(QString name, QString string) override;
+
+  /**
+   * Overrides @abstract Task::removeArgument
+   *
+   * Remove a value from a container argument.
+   */
+  virtual void removeArgument(QString name, Scheduler::TypeVariant arg) override;
+
+  /**
+   * Overrides @abstract Task::hasFiles
+   *
+   * Tells the caller if the task has files.
+   */
+  virtual bool hasFiles() override;
+
+  /**
+   * Overrides @abstract Task::isReady
+   *
+   * Informs the caller if the prerequisite arguments have values.
+   */
+  virtual bool isReady() override;
+
+  /**
+   * Overrides @abstract Task::clear
+   *
+   * Clears the values of all arguments, without removing the arguments.
+   */
+  virtual void clear() override;
+
+  /**
+   * Overrides @abstract Task::setDefaultValues
+   *
+   * Set default values for the arguments.
+   */
+  virtual void setDefaultValues() override;
+
+  /**
+   * Overrides @abstract Task::~Task
+   * @destructor
+   */
+  virtual ~GenericTask() override;
+
+ private:
+  /**
+   * @brief m_arguments
+   *
+   * A container storing the task's arguments
+   */
+  Scheduler::TaskArguments m_arguments;
+};
+
+#endif  // __GENERIC_TASK_HPP

include/task/instagram_task.hpp

@@ -15,6 +15,10 @@ const QString LINK_BIO_TYPE = "link_in_bio";
 const QString REQUESTED_BY_TYPE = "requested_by";
 const QString REQUESTED_BY_PHRASE = "requested_by_phrase";
 }  // namespace Args
+
+namespace TaskCode {
+  static constexpr int IGTASKBYTE = 0xFF;
+}
 }  // namespace Scheduler
 
 /**
@@ -85,6 +89,13 @@ class InstagramTask : public Scheduler::Task {
    */
   virtual Scheduler::TaskType getType() override;
 
+  /**
+   * Overrides @abstract Task::getTaskCode
+   *
+   * Returns the task's byte code.
+   */
+  virtual int getTaskCode() override;
+
   /**
    * Overrides @abstract Task::setArgument
    *

include/task/task.hpp

@@ -10,7 +10,9 @@
 
 namespace Scheduler {
 
-enum TaskType { INSTAGRAM = 1, OTHER = 2 };
+enum TaskType { INSTAGRAM = 1, GENERIC = 2, OTHER = 3 };
+
+static constexpr const char* INSTAGRAM_NAME = "Instagram";
 
 /**
  * Files
@@ -281,6 +283,7 @@ class Task {
   virtual ArgumentValues getArgumentValues() = 0;
   virtual QVector<QString> getArgumentNames() = 0;
   virtual TaskType getType() = 0;
+  virtual int getTaskCode() = 0;
   virtual void defineTaskArguments() = 0;
   virtual void setDefaultValues() = 0;
   virtual const QVector<KFileData> getFiles() = 0;

include/ui/argdialog.h

@@ -10,6 +10,7 @@
 #include <QPushButton>
 #include <headers/util.hpp>
 #include <include/task/instagram_task.hpp>
+#include <include/task/generic_task.hpp>
 #include <include/task/task.hpp>
 #include <string_view>
 #include <unordered_map>
@@ -30,6 +31,7 @@ class ArgDialog : public QDialog {
   virtual void keyPressEvent(QKeyEvent* e) override;
   void setFilePath(QString path);
   virtual void accept() override;
+  void setAppName(QString task_name);
   void setConfig(QString config_string);
   void notifyClientSuccess();
 
@@ -38,6 +40,9 @@ class ArgDialog : public QDialog {
  signals:
   void taskRequestReady(Scheduler::Task *task);
 
+ protected:
+  void showEvent(QShowEvent* event) override;
+
  private:
   void clearPost();
   void defaultPost();
@@ -54,6 +59,7 @@ class ArgDialog : public QDialog {
   Task *m_task;
   QString m_file_path;
   QString m_config_string;
+  QString m_app_name;
 };
 
 #endif  // ARGDIALOG_H

include/ui/mainwindow.h

@@ -99,7 +99,7 @@ public:
    private slots:
     /** Receivers */
     void connectClient();
-    void updateMessages(int t, const QString& s, StringVec v);
+    void onMessageReceived(int t, const QString& s, StringVec v);
 };
 
 

ky_gui.pro

@@ -31,7 +31,8 @@ SOURCES += \
         src/main.cpp \
         src/mainwindow.cpp \
         src/client.cpp \
-        src/instagram_task.cpp\
+        src/instagram_task.cpp \
+        src/generic_task.cpp \
         src/argdialog.cpp \
         src/messagedialog.cpp \
         src/connection_indicator.cpp \
@@ -47,8 +48,10 @@ HEADERS += \
         include/client/client.hpp \
         include/task/task.hpp \
         include/task/instagram_task.hpp\
+        include/task/generic_task.hpp\
         headers/kmessage_codec.hpp \
         headers/instatask_generated.h \
+        headers/generictask_generated.h \
         headers/util.hpp \
         headers/kiq_types.hpp \
         headers/rapidjson/writer.h \

src/argdialog.cpp

@@ -14,14 +14,6 @@ using namespace Scheduler;
 ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog), m_task(nullptr) {
   ui->setupUi(this);
 
-  m_task = new InstagramTask{};
-  m_task->defineTaskArguments();
-  m_task->setDefaultValues();
-
-  for (const auto& name : m_task->getArgumentNames()) {
-    ui->argType->addItem(name, QVariant::String);
-  }
-
   ui->argCommandButtons->button(QDialogButtonBox::Close)
       ->setStyleSheet(QString("background:%1").arg("#2f535f"));
 
@@ -155,24 +147,49 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
   });
 }
 
+void ArgDialog::showEvent(QShowEvent* event) {
+  if (event->type() == QEvent::Show) {
+    if (m_app_name == Scheduler::INSTAGRAM_NAME) {
+      m_task = new InstagramTask{};
+    } else {
+      m_task = new GenericTask{};
+    }
+    m_task->defineTaskArguments();
+    m_task->setDefaultValues();
+
+    ui->argType->clear();
+
+    for (const auto& name : m_task->getArgumentNames()) {
+      ui->argType->addItem(name, QVariant::String);
+    }
+
+    ui->user->addItems(getValueArgs(m_config_string.toUtf8(), "users"));
+    if (ui->user->count() > 0) {
+      m_task->setArgument("user", ui->user->itemText(0));
+    }
+  }
+}
+
 /**
  * @brief ArgDialog::setTaskArguments
  */
 void ArgDialog::setTaskArguments() {
-  QString hashtags{};
+  if (m_task->getType() == TaskType::INSTAGRAM) {
-  for (const auto &tag : std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue("hashtags"))) {
+    QString hashtags{};
-    hashtags += "#" + tag + " ";
+    for (const auto &tag : std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue("hashtags"))) {
-  }
+      hashtags += "#" + tag + " ";
-  hashtags.chop(1);
+    }
-  QString requested_by{};
+    hashtags.chop(1);
-  for (const auto &name : std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue("requested_by"))) {
+    QString requested_by{};
-    requested_by += "@" + name + "";
+    for (const auto &name : std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue("requested_by"))) {
-  }
+      requested_by += "@" + name + "";
-  if (requested_by.size() > 1) {
+    }
-    requested_by.chop(1);
+    if (requested_by.size() > 1) {
+      requested_by.chop(1);
+    }
+    m_task->setArgument("hashtags_string", hashtags);
+    m_task->setArgument("requested_by_string", requested_by);
   }
-  m_task->setArgument("hashtags_string", hashtags);
-  m_task->setArgument("requested_by_string", requested_by);
 }
 
 /**
@@ -348,16 +365,16 @@ void ArgDialog::keyPressEvent(QKeyEvent *e) {
  */
 void ArgDialog::setFilePath(QString path) { m_file_path = path; }
 
+void ArgDialog::setAppName(QString app_name) {
+  m_app_name = app_name;
+}
+
 /**
  * @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_task->setArgument("user", ui->user->itemText(0));
-  }
 }
 
 /**

src/client.cpp

@@ -17,9 +17,11 @@
 #define FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
 #include <headers/kmessage_codec.hpp>
 #include <headers/instatask_generated.h>
+#include <headers/generictask_generated.h>
 
 using namespace KData;
 using namespace IGData;
+using namespace GenericData;
 
 static const int MAX_PACKET_SIZE = 4096;
 static const int HEADER_SIZE = 4;
@@ -242,80 +244,89 @@ std::string getTaskFileInfo(std::vector<SentFile> files) {
  * @param [in] {Scheduler::Task*} task The task arguments
  */
 void Client::sendTaskEncoded(Scheduler::Task* task) {
+  qDebug() << getSelectedApp();
   if (task->getType() == Scheduler::TaskType::INSTAGRAM) {
     flatbuffers::Offset<IGTask> ig_task =
         CreateIGTask(
             builder,
-/*ID*/          96,
+            96, // ID
-            builder.CreateString(
+            builder.CreateString(getTaskFileInfo(sent_files)),
-/*0*/           getTaskFileInfo(sent_files)),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-            builder.CreateString(
+              task->getTaskArgumentValue("datetime")).toUtf8().constData()}),
-/*1*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-                                      task->getTaskArgumentValue("datetime")).toUtf8().constData()}),
+              task->getTaskArgumentValue("description")).toUtf8().constData()}),
-            builder.CreateString(
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-/*2*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+              task->getTaskArgumentValue("hashtags_string")).toUtf8().constData()}),
-                                      task->getTaskArgumentValue("description")).toUtf8().constData()}),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-            builder.CreateString(
+              task->getTaskArgumentValue("requested_by_string")).toUtf8().constData()}),
-/*3*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-                                      task->getTaskArgumentValue("hashtags_string")).toUtf8().constData()}),
+              task->getTaskArgumentValue("requested_by_phrase")).toUtf8().constData()}),
-            builder.CreateString(
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-/*4*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+              task->getTaskArgumentValue("promote_share")).toUtf8().constData()}),
-                                      task->getTaskArgumentValue("requested_by_string")).toUtf8().constData()}),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-            builder.CreateString(
+              task->getTaskArgumentValue("link_in_bio")).toUtf8().constData()}),
-/*5*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+            std::get<Scheduler::VariantIndex::BOOLEAN>(
-                                      task->getTaskArgumentValue("requested_by_phrase")).toUtf8().constData()}),
+              task->getTaskArgumentValue("is_video")),
-            builder.CreateString(
+              getSelectedApp(),
-/*6*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-                                      task->getTaskArgumentValue("promote_share")).toUtf8().constData()}),
+              task->getTaskArgumentValue("header")).toUtf8().constData()}),
-            builder.CreateString(
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-/*7*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+              task->getTaskArgumentValue("user")).toUtf8().constData()}));
-                                      task->getTaskArgumentValue("link_in_bio")).toUtf8().constData()}),
-/*8*/           std::get<Scheduler::VariantIndex::BOOLEAN>(
-                                      task->getTaskArgumentValue("is_video")),
-/*9*/           getSelectedApp(),
-            builder.CreateString(
-/*10*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-                                       task->getTaskArgumentValue("header")).toUtf8().constData()}),
-            builder.CreateString(
-/*11*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-                                       task->getTaskArgumentValue("user")).toUtf8().constData()}));
     builder.Finish(ig_task);
+  } else {
+    flatbuffers::Offset<GenericTask> generic_task =
+        CreateGenericTask(
+            builder,
+              96, // ID
+            builder.CreateString(getTaskFileInfo(sent_files)),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+              task->getTaskArgumentValue("datetime")).toUtf8().constData()}),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+              task->getTaskArgumentValue("description")).toUtf8().constData()}),
+            std::get<Scheduler::VariantIndex::BOOLEAN>(
+              task->getTaskArgumentValue("is_video")),
+              getSelectedApp(),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+              task->getTaskArgumentValue("header")).toUtf8().constData()}),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+              task->getTaskArgumentValue("user")).toUtf8().constData()}));
+    builder.Finish(generic_task);
+  }
 
-    uint8_t* encoded_message_buffer = builder.GetBufferPointer();
+  uint8_t* encoded_message_buffer = builder.GetBufferPointer();
-    uint32_t size = builder.GetSize();
+  uint32_t size = builder.GetSize();
-    uint8_t send_buffer[MAX_PACKET_SIZE];
+  uint8_t send_buffer[MAX_PACKET_SIZE];
 
-    memset(send_buffer, 0, MAX_PACKET_SIZE);
+  memset(send_buffer, 0, MAX_PACKET_SIZE);
 
-    send_buffer[0] = (size >> 24) & 0xFF;
+  send_buffer[0] = (size >> 24) & 0xFF;
-    send_buffer[1] = (size >> 16) & 0xFF;
+  send_buffer[1] = (size >> 16) & 0xFF;
-    send_buffer[2] = (size >> 8) & 0xFF;
+  send_buffer[2] = (size >> 8) & 0xFF;
-    send_buffer[3] = size & 0xFF;
+  send_buffer[3] = size & 0xFF;
-    send_buffer[4] = (TaskCode::IGTASKBYTE & 0xFF);
+  send_buffer[4] = (task->getTaskCode() & 0xFF);
 
-    std::memcpy(send_buffer + 5, encoded_message_buffer, size);
+  std::memcpy(send_buffer + 5, encoded_message_buffer, size);
-    qDebug() << "Ready to send:";
+  qDebug() << "Ready to send:";
-    std::string message_to_send{};
+  std::string message_to_send{};
-    for (unsigned int i = 0; i < (size + 5); i++) {
+  for (unsigned int i = 0; i < (size + 5); i++) {
-      message_to_send += (char)*(send_buffer + i);
+    message_to_send += (char)*(send_buffer + i);
-    }
+  }
-    qDebug() << "Final size: " << (size + 5);
+  qDebug() << "Final size: " << (size + 5);
-    // Send start operation
+  // Send start operation
-    ::send(m_client_socket_fd, send_buffer, size + 5, 0);
+  ::send(m_client_socket_fd, send_buffer, size + 5, 0);
-    // Cleanup and process queue
+  // Cleanup and process queue
-    builder.Clear();
+  builder.Clear();
-    sent_files.clear();
+  sent_files.clear();
-    m_outbound_task = nullptr;
+  m_outbound_task = nullptr;
-    if (!m_task_queue.isEmpty()) {
+  if (!m_task_queue.isEmpty()) {
-      m_outbound_task = m_task_queue.dequeue();
+    m_outbound_task = m_task_queue.dequeue();
-      // TODO work from here
+    // TODO work from here
-      if (m_outbound_task->hasFiles() && !outgoing_files.empty()) {
+    if (m_outbound_task->hasFiles() && !outgoing_files.empty()) {
-        qDebug() << "There are still outgoing files left over from last "
+      qDebug() << "There are still outgoing files left over from last "
-                    "task which were never sent. They are being deleted";
+                  "task which were never sent. They are being deleted";
-        outgoing_files.clear();
+      outgoing_files.clear();
-      }
-      sendFiles(m_outbound_task);
     }
+    sendFiles(m_outbound_task);
   }
 }
 

src/generic_task.cpp

@@ -0,0 +1,263 @@
+#include <include/task/generic_task.hpp>
+#include <QDebug>
+using namespace Scheduler;
+
+/**
+ * These values contained inside the TaskIndex namespace represent the order in which the tasks are to be stored.
+ */
+namespace TaskIndex {
+static const uint8_t HEADER = 0;
+static const uint8_t DESCRIPTION = 1;
+static const uint8_t DATETIME = 2;
+static const uint8_t FILES = 3;
+static const uint8_t USER = 4;
+static const uint8_t IS_VIDEO = 5;
+}  // namespace TaskIndex
+
+/**
+ * @constructor
+ */
+GenericTask::GenericTask() {}
+
+/**
+ * @brief GenericTask::defineTaskArguments
+ *
+ * This method defines all of the arguments that are available to be set for the Task
+ *
+ */
+void GenericTask::defineTaskArguments() {
+  m_arguments.clear();
+  m_arguments.emplace_back(std::move(new TaskArgument{"header", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"description", Type::TEXT, TypeVariant{QString{}}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"datetime", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"files", Type::FILEVECTOR, QVector<KFileData>{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"user", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"is_video", Type::BOOLEAN, bool{}}));
+}
+
+/**
+ * @brief GenericTask::setArgument
+ * @param [in] {QString}      name   The name of the argment
+ * @param [in] {TypeVariant}  value  The value of the argument
+ */
+void GenericTask::setArgument(QString name, TypeVariant value) {
+  for (auto&& argument : m_arguments) {
+    if (argument->text() == name) {
+      argument->setValue(value);
+      return;
+    }
+  }
+}
+
+/**
+ * @warning This method is used to add values to an argument, and can only be used on arguments whose type is a form of container.
+ *
+ * @brief GenericTask::addArgument
+ *
+ * @param [in] {QString}    name  The name of the argument
+ * @param [in] {KFileData}  file  A data structure to be added to a container of files.
+ *                                The KFileData structure contains metadata about a file and
+ *                                its data as a byte array
+ */
+void GenericTask::addArgument(QString name, Scheduler::KFileData file) {
+  for (const auto& argument : m_arguments) {
+    if (argument->text() == name) {
+      argument->insert(file);
+      return;
+    }
+  }
+}
+
+/**
+ * @warning This method is used to remove a value to an argument, and can only be used on arguments whose type is a form of container.
+ *
+ * @brief GenericTask::removeArgument
+ *
+ * @param [in] {QString}      name   The name of the argument, whose value is expected to be a container.
+ * @param [in] {TypeVariant}  value  The value to be removed from the container argument.
+ *
+ */
+void GenericTask::removeArgument(QString name, Scheduler::TypeVariant value) {
+  for (auto&& argument : m_arguments) {
+    if (argument->text() == name) {
+      if (argument->isContainer()) {
+        argument->remove(value);
+      } else {
+        argument->clear();
+      }
+      return;
+    }
+  }
+}
+
+/**
+ * @warning This method is used to add values to an argument, and can only be used on arguments whose type is a form of container.
+ *
+ * @brief GenericTask::addArgument
+ *
+ * @param [in] {QString} name     The name of the argument
+ * @param [in] {QString} string   A string value intended to be added to a container of strings
+ */
+void GenericTask::addArgument(QString name, QString string) {
+  for (const auto& argument : m_arguments) {
+    if (argument->text() == name) {
+      argument->insert(string);
+      return;
+    }
+  }
+}
+
+
+/**
+ * @brief GenericTask::getTaskArgument
+ *
+ * @param [in] {QString} name   The name of the argument to retrieve
+ * @return [out] {TaskArgument}  The argument
+ */
+TaskArgument&& GenericTask::getTaskArgument(QString name) {
+  for (const auto& argument : m_arguments) {
+    if (argument->text() == name) {
+      return std::move(*argument);
+    }
+  }
+  throw std::invalid_argument("Argument not found");
+}
+
+/**
+ * @brief GenericTask::getTaskArgumentValue
+ *
+ * @param [in] {QString} name   The name of the argument to retrieve
+ * @return [out] {TypeVariant}  The value of the argument
+ */
+const TypeVariant GenericTask::getTaskArgumentValue(QString name) {
+  for (const auto& argument : m_arguments) {
+    if (argument->text() == name) {
+      return argument->getValue();
+    }
+  }
+  return "";  // Perhaps we should throw
+}
+
+/**
+ * @warning This method does not return any task value whose type is a form of container.
+ *
+ * @brief GenericTask::getArgumentValues
+ * @typedef QVector<QString> is aliased to ArgumentValues
+ *
+ * @return [out] {ArgumentValues} A vector of strings for all of the arguments that can be represented as a string.
+ */
+ArgumentValues GenericTask::getArgumentValues() {
+  ArgumentValues values{static_cast<int>(m_arguments.size())};
+  for (auto& argument : m_arguments) {
+    if (!argument->isContainer()) {
+      values.push_back(argument->getStringValue());
+    }
+  }
+  return values;
+}
+
+/**
+ * @warning This method does not necessarily need to return all argument names.
+ *          In this use case, we are retrieving names to populate options in our
+ *          ArgType widget, thus we only return names for arguments whose values are
+ *          to be set or modified using the ArgType widget. For this reason, we have
+ *          hardcoded the return to be explicit about which arguments names are available.
+ *
+ * @brief GenericTask::getArgumentNames
+ *
+ * @return [out] {QVector<QString>} A vector of argument names as strings.
+ */
+QVector<QString> GenericTask::getArgumentNames() {
+  return QVector<QString>{
+      GenericArgs::DESCRIPTION_TYPE,
+      GenericArgs::HEADER_TYPE
+  };
+}
+
+/**
+ * @warning This method is used to claim ownership of the task's arguments. Use of this method will effectively REMOVE all arguments from
+ *          the task upon which it is called.
+ *
+ * @brief GenericTask::getTaskArguments
+ * @typedef std::vector<std::unique_ptr<TaskArgument> is aliased to TaskArguments
+ *
+ * @return [out] {std::vector<std::unique_ptr<TaskArgument>} An R-value reference to a vector of unique pointers to the task's arguments.
+ *
+ */
+const TaskArguments&& GenericTask::getTaskArguments() { return std::move(m_arguments); }
+
+/**
+ * @brief GenericTask::setDefaultValues
+ *
+ * Sets default values for the task's arguments
+ */
+void GenericTask::setDefaultValues() {
+  setArgument("header", TypeVariant{QString{"Generic Task"}});
+}
+
+/**
+ * @brief getType
+ *
+ * @return [out] {TaskType} The type of task
+ */
+Scheduler::TaskType GenericTask::getType() { return Scheduler::TaskType::GENERIC; };
+
+/**
+ * @brief getTaskCode
+ *
+ * @return [out] {int} The task bytecode
+ */
+int GenericTask::getTaskCode() { return TaskCode::GENTASKBYTE; };
+
+
+/**
+ * @brief GenericTask::clear
+ *
+ * Clears the value of each task argument
+ */
+void GenericTask::clear() {
+  for (const auto& argument : m_arguments) {
+    argument->clear();
+  }
+}
+
+/**
+ * @brief GenericTask::hasFiles
+ *
+ * @return [out] {bool} Indicates whether the task has files.
+ */
+bool GenericTask::hasFiles() {
+  return !std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files")).empty();
+}
+
+/**
+ * @brief GenericTask::hasFiles
+ *
+ * @return [out] {QVector<KFileData>} A vector of data structures representing file metadata and the file data as bytes.
+ */
+const QVector<Scheduler::KFileData> GenericTask::getFiles() {
+  return std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files"));
+}
+
+/**
+ * @brief GenericTask::isReady
+ *
+ * @return [out] {bool} A boolean value indicating whether the minimal requirements sufficient to appropriately
+ *                      perform the task have been met.
+ */
+bool GenericTask::isReady() {
+  auto header_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("header")).size();
+  auto description_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("description")).size();
+  auto datetime_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("datetime")).size();
+  auto hasFiles = std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files")).size();
+  auto user_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("user")).size();
+
+  return header_size > 0 && description_size > 0 && datetime_size > 0 &&
+         hasFiles && user_size > 0;
+}
+
+/**
+ * @destructor
+ */
+GenericTask::~GenericTask() {
+}

src/instagram_task.cpp

@@ -224,6 +224,14 @@ void InstagramTask::setDefaultValues() {
  */
 Scheduler::TaskType InstagramTask::getType() { return Scheduler::TaskType::INSTAGRAM; };
 
+
+/**
+ * @brief getTaskCode
+ *
+ * @return [out] {int} The task bytecode
+ */
+int InstagramTask::getTaskCode() { return TaskCode::IGTASKBYTE; };
+
 /**
  * @brief InstagramTask::clear
  *

src/mainwindow.cpp

@@ -149,6 +149,8 @@ void MainWindow::setConnectScreen(bool visible) {
  * @brief MainWindow::connectClient
  */
 void MainWindow::connectClient() {
+  auto text = ui->kyConfig->toPlainText();
+  qDebug() << text;
   m_config = getConfigObject(ui->kyConfig->toPlainText());
   QString file_path = m_config.at("fileDirectory");
   if (file_path != NULL) {
@@ -157,7 +159,7 @@ void MainWindow::connectClient() {
   setConnectScreen(false);
   qDebug() << "Connecting to KServer";
   QObject::connect(q_client, &Client::messageReceived, this,
-                   &MainWindow::updateMessages);
+                   &MainWindow::onMessageReceived);
 
   QProgressBar* progressBar = ui->progressBar;
   q_client->start();
@@ -179,8 +181,9 @@ void MainWindow::connectClient() {
       static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
       this, [this]() {
         QString app_name = ui->appList->currentText();
-        // TODO: I know, it's awful. Fix this
         q_client->setSelectedApp(std::vector<QString>{{app_name}});
+        arg_ui->setAppName(app_name);
+        arg_ui->setConfig(configValue(app_name, m_config, true));
       });
   QPushButton* disconnect_button = this->findChild<QPushButton*>("disconnect");
   QObject::connect(disconnect_button, &QPushButton::clicked, this, [this]() {
@@ -256,10 +259,12 @@ void MainWindow::connectClient() {
 }
 
 /**
- * @brief MainWindow::updateMessages
+ * @brief MainWindow::onMessageReceived
- * @param s
+ * @param t
+ * @param message
+ * @param v
  */
-void MainWindow::updateMessages(int t, const QString& message, StringVec v) {
+void MainWindow::onMessageReceived(int t, const QString& message, StringVec v) {
   QString timestamp_prefix = timestampPrefix();
   if (t == MESSAGE_UPDATE_TYPE) {  // Normal message
     qDebug() << "Updating message area";
@@ -271,7 +276,8 @@ void MainWindow::updateMessages(int t, const QString& message, StringVec v) {
     message_parser.handleCommands(v, default_app);
     if (message == "New Session") {  // Session has started
       ui->led->setState(true);
-      arg_ui->setConfig(configValue("instagram", m_config));
+      auto app_name = q_client->getAppName(q_client->getSelectedApp());
+      arg_ui->setConfig(configValue(app_name, m_config, true));
       if (configBoolValue("schedulerMode", std::ref(m_config))) {
         arg_ui->show();
       }
@@ -371,6 +377,8 @@ void MainWindow::MessageParser::handleCommands(StringVec commands,
     app_list->addItem(s);
     if (s.toLower() == default_command.toLower()) {
       window->ui->appList->setCurrentIndex(app_index);
+      std::vector<QString> selected{std::move(default_command)};
+      window->q_client->setSelectedApp(std::move(selected));
     }
     app_index++;
   }