compilation succeeds

business logic refactored to make use of new generic task
remaining work: implement files properly, so that hasFiles returns a valid value

headers/kstring.hpp

@@ -0,0 +1,17 @@
+#ifndef __KSTRING_HPP__
+#define __KSTRING_HPP__
+
+#include <QString>
+/**
+ * @brief The KString class
+ * Solves the interface problem with FlatBuffers, which seems designed to work best with std::string
+ */
+
+class KString : public QString {
+ public:
+  const char* c_str() const {
+    return toUtf8().constData();
+  }
+};
+
+#endif // __KSTRING_HPP__

include/client/client.hpp

@@ -14,6 +14,7 @@
 #include <QUuid>
 #include <QVector>
 #include <headers/util.hpp>
+#include <headers/kstring.hpp>
 #include <include/task/task.hpp>
 #include <string>
 #include <thread>
@@ -36,18 +37,6 @@ 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;

include/task/task.hpp

@@ -41,13 +41,14 @@ static constexpr const char* STRINGVECTOR = "StringVector";
 static constexpr const char* FILEVECTOR = "FileVector";
 static constexpr const char* DATETIME = "DateTime";
 static constexpr const char* BOOLEAN = "Boolean";
+static constexpr const char* INTEGER = "Integer";
 }  // namespace Type
 
 namespace VariantIndex {
 static const uint8_t BOOLEAN = 0;
 static const uint8_t INTEGER = 1;
-static const uint8_t QSTRING = 2;
-static const uint8_t STRVEC = 3;
+static const uint8_t STRVEC = 2;
+static const uint8_t QSTRING = 3;
 static const uint8_t FILEVEC = 4;
 }  // namespace VariantIndex
 
@@ -65,7 +66,7 @@ class Task;
 using TaskQueue = QQueue<Task*>;
 using ArgumentType = const char*;
 using ArgumentValues = QVector<QString>;
-using TypeVariant = std::variant<bool, int, QString, QVector<QString>, QVector<KFileData>>;
+using TypeVariant = std::variant<bool, int, QVector<QString>, QString, QVector<KFileData>>;
 using TaskIterator = std::vector<std::unique_ptr<TaskArgumentBase>>::iterator;
 
 /**
@@ -75,7 +76,7 @@ class TaskArgumentBase {
  public:
   virtual const QString text() = 0;
   virtual const QString getStringValue() = 0;
-  virtual uint8_t getTypeIndex();
+  virtual uint8_t getTypeIndex() = 0;
   virtual TypeVariant getValue() = 0;
   virtual void insert(QString value) = 0;
   virtual void insert(KFileData file) = 0;
@@ -94,6 +95,7 @@ class TaskArgumentBase {
 class TaskArgument : TaskArgumentBase {
  public:
   TaskArgument(QString n, ArgumentType t, TypeVariant _value) {
+    auto index = _value.index();
     name = n;
     type = t;
     value = _value;
@@ -138,12 +140,18 @@ class TaskArgument : TaskArgumentBase {
    * @return [out] {TypeVariant}
    */
   virtual TypeVariant getValue() override {
+    size_t index = value.index();
+    bool equivalence = index == VariantIndex::STRVEC;
     if (isIndex(value.index(), VariantIndex::QSTRING)) {
       return std::get<VariantIndex::QSTRING>(value);
     } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
       return std::get<VariantIndex::BOOLEAN>(value);
     } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
       return std::get<VariantIndex::INTEGER>(value);
+    } else if (isIndex(value.index(), VariantIndex::STRVEC)) {
+      return std::get<VariantIndex::STRVEC>(value);
+    } else if (isIndex(value.index(), VariantIndex::FILEVEC)) {
+      return std::get<VariantIndex::FILEVEC>(value);
     }
   }
 
@@ -230,7 +238,6 @@ class Task {
   virtual void defineTaskArguments() = 0;
   virtual void setDefaultValues() = 0;
   virtual const QVector<KFileData> getFiles() = 0;
-  virtual void addFile(KFileData file) = 0;
   virtual bool hasFiles() = 0;
   virtual bool isReady() = 0;
   virtual void clear() = 0;

src/argdialog.cpp

@@ -15,6 +15,10 @@ 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();
+
   ui->argCommandButtons->button(QDialogButtonBox::Close)
       ->setStyleSheet(QString("background:%1").arg("#2f535f"));
 
@@ -126,8 +130,8 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
                        &QDialogButtonBox::clicked),
                    this, [this](QAbstractButton *button) {
                      if (button->text() == "Save") {
+                       setTaskArguments();
                        if (m_task->isReady()) {
-                         setTaskArguments();
                          emit ArgDialog::taskRequestReady(m_task);
                        }
                        clearPost(); // reset m_ig_post to default values
@@ -157,8 +161,8 @@ void ArgDialog::setTaskArguments() {
   if (requested_by.size() > 1) {
     requested_by.chop(1);
   }
-  m_task->setArgument("hashtags", hashtags);
-  m_task->setArgument("requested_by", requested_by);
+  m_task->setArgument("hashtags_string", hashtags);
+  m_task->setArgument("requested_by_string", requested_by);
 }
 
 /**
@@ -353,9 +357,12 @@ void ArgDialog::setConfig(QString config_string) {
   }
 }
 
-ArgDialog::~ArgDialog()
-{
-    delete ui;
+/**
+ * @brief ArgDialog::~ArgDialog
+ */
+ArgDialog::~ArgDialog() {
+  delete m_task;
+  delete ui;
 }
 
 void ArgDialog::accept() { qDebug() << "Sending request to schedule a task.."; }

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), executing(false), m_commands({}) {
+Client::Client(QWidget *parent, int count, char** arguments) : QDialog(parent), argc(count), argv(arguments), m_client_socket_fd(-1), m_outbound_task(nullptr), executing(false), m_commands({}) {
     qRegisterMetaType<QVector<QString>>("QVector<QString>");
 }
 
@@ -243,17 +243,17 @@ 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()};
+    const auto hashtags = KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("hashtags"))};
     flatbuffers::Offset<IGTask> ig_task =
         CreateIGTask(
             builder,
             96,
             builder.CreateString(getTaskFileInfo(sent_files)),
-            builder.CreateString(datetime),
+            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("datetime")).toUtf8().constData()}),
             builder.CreateString(
-                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("description"))}),
-            builder.CreateString(
-                KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("hashtags"))}),
+                std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("description")).toUtf8().constData()}),
+            builder.CreateString(hashtags
+               ),
             builder.CreateString(
                 KString{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_phrase"))}),
             builder.CreateString(

src/instagram_task.cpp

@@ -9,13 +9,22 @@ static const uint8_t DATETIME = 2;
 static const uint8_t PROMOTE_SHARE = 3;
 static const uint8_t LINK_IN_BIO = 4;
 static const uint8_t HASHTAGS = 5;
-static const uint8_t REQUESTED_BY = 6;
-static const uint8_t REQUESTED_BY_PHRASE = 7;
-static const uint8_t FILES = 8;
-static const uint8_t USER = 9;
-static const uint8_t IS_VIDEO = 10;
+static const uint8_t HASHTAGS_STRING = 6;
+static const uint8_t REQUESTED_BY = 7;
+static const uint8_t REQUESTED_BY_STRING = 8;
+static const uint8_t REQUESTED_BY_PHRASE = 9;
+static const uint8_t FILES = 10;
+static const uint8_t USER = 11;
+static const uint8_t IS_VIDEO = 12;
+static const uint8_t MASK = 13;
 }  // namespace TaskIndex
 
+/**
+ * @constructor
+ */
+InstagramTask::InstagramTask() : files(QVector<KFileData>{}) {}
+
+
 /**
  * @constructor
  * @param [in] {KFileData} k_file
@@ -34,16 +43,19 @@ InstagramTask::InstagramTask(QVector<KFileData> k_files) : files(k_files) {}
 void InstagramTask::defineTaskArguments() {
   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>("description", Type::TEXT, TypeVariant{QString{}}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("datetime", Type::TEXT, 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>("hashtags", Type::STRINGVECTOR, QVector<QString>{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("hashtags_string", 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_string", Type::TEXT, 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{}));
+  m_arguments.emplace_back(std::make_unique<TaskArgument>("mask", Type::INTEGER, -1));
 }
 
 /**
@@ -52,35 +64,22 @@ 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; });
-for (const auto& argument : m_arguments) {
-  if (argument.get()->text() == name) {
-    if (isIndex(value.index(), VariantIndex::QSTRING)) {
-      argument.get()->setValue(value);
-    } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
-      argument.get()->setValue(QString::number(std::get<VariantIndex::BOOLEAN>(value)));
-    } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
-      argument.get()->setValue(QString::number(std::get<VariantIndex::INTEGER>(value)));
-    } else {
-      // Could not set argument value
-      // TODO: Log here
+  for (const auto& argument : m_arguments) {
+    if (argument->text() == name) {
+      argument->setValue(value);
+//      if (isIndex(argument->, VariantIndex::QSTRING)) {
+//        argument->setValue(value);
+//      } else if (isIndex(value.index(), VariantIndex::BOOLEAN)) {
+//        argument->setValue(QString::number(std::get<VariantIndex::BOOLEAN>(value)));
+//      } else if (isIndex(value.index(), VariantIndex::INTEGER)) {
+//        argument->setValue(QString::number(std::get<VariantIndex::INTEGER>(value)));
+//      } else {
+//        // Could not set argument value
+//        // TODO: Log here
+//      }
+      return;
     }
   }
-  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
-//    }
-//  }
 }
 
 /**
@@ -90,8 +89,8 @@ for (const auto& argument : m_arguments) {
  */
 void InstagramTask::addArgument(QString name, Scheduler::KFileData file) {
   for (const auto& argument : m_arguments) {
-    if (argument.get()->text() == name) {
-      argument.get()->insert(file);
+    if (argument->text() == name) {
+      argument->insert(file);
       return;
     }
   }
@@ -104,8 +103,8 @@ void InstagramTask::addArgument(QString name, Scheduler::KFileData file) {
  */
 void InstagramTask::addArgument(QString name, QString string) {
   for (const auto& argument : m_arguments) {
-    if (argument.get()->text() == name) {
-      argument.get()->insert(string);
+    if (argument->text() == name) {
+      argument->insert(string);
       return;
     }
   }
@@ -118,8 +117,8 @@ void InstagramTask::addArgument(QString name, QString string) {
  */
 const TypeVariant InstagramTask::getTaskArgument(QString name) {
   for (const auto& argument : m_arguments) {
-    if (argument.get()->text() == name) {
-      return argument.get()->getValue();
+    if (argument->text() == name) {
+      return argument->getValue();
     }
   }
   return "";  // Perhaps we should throw
@@ -156,21 +155,17 @@ const QVector<KFileData> InstagramTask::getFiles() { return files; }
  * @brief InstagramTask::setDefaultValues
  */
 void InstagramTask::setDefaultValues() {
-  m_arguments.at(TaskIndex::HEADER)
-      ->setValue("Learn to speak like native Korean speakers 🙆‍♀️🇰🇷");
-  m_arguments.at(TaskIndex::PROMOTE_SHARE)
-      ->setValue("Share the post through IG story if you enjoy the phrase 🙋‍♀️");
-  m_arguments.at(TaskIndex::LINK_IN_BIO)
-      ->setValue("Subscribe to my YouTube channel (link 🔗in bio) to learn more about Korean language and culture ❤");
-  m_arguments.at(TaskIndex::REQUESTED_BY_PHRASE)
-      ->setValue("The phrase was requested by ");
+  setArgument("header", TypeVariant{QString{"Learn to speak like native Korean speakers 🙆‍♀️🇰🇷"}});
+  setArgument("promote_share", TypeVariant{QString{"Share the post through IG story if you enjoy the phrase 🙋‍♀️"}});
+  setArgument("link_in_bio", TypeVariant{QString{"Subscribe to my YouTube channel (link 🔗in bio) to learn more about Korean language and culture ❤"}});
+  setArgument("requested_by_phrase", TypeVariant{QString{"The phrase was requested by "}});
 }
 
 /**
  * @brief getType
  * @return {Scheduler::TaskType} The type of task
  */
-Scheduler::TaskType getType() { return Scheduler::TaskType::INSTAGRAM; };
+Scheduler::TaskType InstagramTask::getType() { return Scheduler::TaskType::INSTAGRAM; };
 
 /**
  * @brief InstagramTask::clear
@@ -189,6 +184,26 @@ bool InstagramTask::hasFiles() {
   return !files.empty();
 }
 
+/**
+ * @brief InstagramTask::isReady
+ * @return
+ */
+bool InstagramTask::isReady() {
+  auto header_size = std::get<VariantIndex::QSTRING>(getTaskArgument("header")).size();
+  auto description_size = std::get<VariantIndex::QSTRING>(getTaskArgument("description")).size();
+  auto datetime_size = std::get<VariantIndex::QSTRING>(getTaskArgument("datetime")).size();
+  auto promote_share_size = std::get<VariantIndex::QSTRING>(getTaskArgument("promote_share")).size();
+  auto link_in_bio_size = std::get<VariantIndex::QSTRING>(getTaskArgument("link_in_bio")).size();
+  auto hashtags_size = std::get<VariantIndex::QSTRING>(getTaskArgument("hashtags_string")).size();
+  auto requested_by_size = std::get<VariantIndex::QSTRING>(getTaskArgument("requested_by_string")).size();
+  auto hasFiles = std::get<VariantIndex::FILEVEC>(getTaskArgument("files")).size();
+  auto user_size = std::get<VariantIndex::QSTRING>(getTaskArgument("user")).size();
+
+  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 && hasFiles && user_size > 0;
+}
+
 /**
  * @destructor
  */