making helper functions to create tasks

include/task/task.hpp

@@ -15,14 +15,17 @@ enum TaskType { INSTAGRAM = 1, GENERIC = 2, OTHER = 3 };
 
 namespace TaskCode {
 static constexpr uint32_t GENTASKCODE = 0xFC;
-static constexpr uint32_t IGTASKCODE = 0xFF;
+static constexpr uint32_t IGTASKCODE  = 0xFF;
 }
 
+static constexpr uint32_t GENERIC_TASK_ID   = 96;
+static constexpr uint32_t INSTAGRAM_TASK_ID = 97;
+
 namespace TaskIndex {
-static constexpr uint32_t ERROR = 0x03;
-static constexpr uint32_t UUID = 0x00;
-static constexpr uint32_t ID = 0x01;
-static constexpr uint32_t MASK = 0x02;
+static constexpr uint32_t ERROR   = 0x03;
+static constexpr uint32_t UUID    = 0x00;
+static constexpr uint32_t ID      = 0x01;
+static constexpr uint32_t MASK    = 0x02;
 static constexpr uint32_t ENVFILE = 0x03;
 static constexpr uint32_t FILENUM = 0x04;
 } // namespace TaskInfo
@@ -64,10 +67,10 @@ enum FileType { VIDEO = 1, IMAGE = 2 };
  * Structure for holding file bytes and metadata
  */
 struct KFileData {
-  QString name;
-  FileType type;
-  QString path;
-  QByteArray bytes;
+  QString     name;
+  FileType    type;
+  QString     path;
+  QByteArray  bytes;
 
 //  friend std::ostream &operator<<(std::ostream &out, const KFileData& file) {
 //    out << "Name: " << file.name.toUtf8()
@@ -82,21 +85,21 @@ struct KFileData {
  * Describes the types of task arguments available for use
  */
 namespace Type {
-static constexpr const char* TEXT = "Text";
-static constexpr const char* FILE = "File";
+static constexpr const char* TEXT         = "Text";
+static constexpr const char* FILE         = "File";
 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";
+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 STRVEC = 2;
-static const uint8_t QSTRING = 3;
-static const uint8_t FILEVEC = 4;
+static const uint8_t BOOLEAN  = 0;
+static const uint8_t INTEGER  = 1;
+static const uint8_t STRVEC   = 2;
+static const uint8_t QSTRING  = 3;
+static const uint8_t FILEVEC  = 4;
 }  // namespace VariantIndex
 
 inline bool isIndex(uint8_t v, uint8_t i) { return v == i; }
@@ -144,19 +147,20 @@ class TaskArgumentBase {
  */
 class TaskArgument : TaskArgumentBase {
  public:
-  TaskArgument(QString n, ArgumentType t, TypeVariant _value) {
-    name = n;
-    type = t;
-    value = _value;
-  }
+  TaskArgument(QString n, ArgumentType t, TypeVariant _value)
+      : name(n),
+        type(t),
+        value(_value) {}
   /**
    * Move Constructor
    *
    * @constructor
    * @param [in] {TaskArgument&&} a The R-value reference to a TaskArgument
    */
-  TaskArgument(TaskArgument&& a) :
-                                   name(std::move(a.name)), type(std::move(a.type)), value(std::move(a.value)) {}
+  TaskArgument(TaskArgument&& a)
+      : name(std::move(a.name)),
+        type(std::move(a.type)),
+        value(std::move(a.value)) {}
 
   /**
    * Copy Constructor
@@ -164,8 +168,10 @@ class TaskArgument : TaskArgumentBase {
    * @constructor
    * @param [in] {TaskArgument&&} a The const reference to a TaskArgument
    */
-  TaskArgument(const TaskArgument& a) :
-                                        name(std::move(a.name)), type(std::move(a.type)), value(std::move(a.value)) {}
+  TaskArgument(const TaskArgument& a)
+      : name(std::move(a.name)),
+        type(std::move(a.type)),
+        value(std::move(a.value)) {}
   /**
    * text
    * @returns {QString} The name of the argument
@@ -305,9 +311,9 @@ class TaskArgument : TaskArgumentBase {
   }
 
  private:
-  QString name;
-  ArgumentType type;
-  TypeVariant value;
+  QString       name;
+  ArgumentType  type;
+  TypeVariant   value;
 };
 
 using TaskArguments = std::vector<TaskArgument*>;

src/client.cpp

@@ -28,6 +28,94 @@ static const int HEADER_SIZE = 4;
 
 flatbuffers::FlatBufferBuilder builder(1024);
 
+namespace Task {
+/**
+ * @brief getTaskFileInfo
+ * @param [in] {std::vector<SentFile>} files The files to produce an information string from
+ * @return std::string A string with the following format denoting each file:
+ * `1580057341filename|image::`
+ */
+std::string getTaskFileInfo(std::vector<SentFile> files) {
+  std::string info{};
+  for (const auto& f : files) {
+    info += std::to_string(f.timestamp);
+    info += f.name.toUtf8().constData();
+    info += "|";
+    if (f.type == Scheduler::FileType::VIDEO) {
+      info += "video";
+    } else {
+      info += "image";
+    }
+    info += ":";
+  }
+  qDebug() << "File Info: " << info.c_str();
+  return info;
+}
+
+flatbuffers::Offset<GenericTask> createGenericTask(
+    Scheduler::Task* task, uint32_t app_mask, std::vector<SentFile> sent_files) {
+  return CreateGenericTask(
+    builder,
+    Scheduler::GENERIC_TASK_ID, // 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")),
+        app_mask,
+    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()}),
+      std::get<Scheduler::VariantIndex::INTEGER>(
+        task->getTaskArgumentValue("recurring")));
+}
+
+flatbuffers::Offset<IGTask> createIGTask(
+    Scheduler::Task* task, uint32_t app_mask, std::vector<SentFile> sent_files) {
+  return CreateIGTask(
+    builder,
+    Scheduler::INSTAGRAM_TASK_ID, // 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()}),
+    builder.CreateString(
+      std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+        task->getTaskArgumentValue("hashtags_string")).toUtf8().constData()}),
+    builder.CreateString(
+      std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+        task->getTaskArgumentValue("requested_by_string")).toUtf8().constData()}),
+    builder.CreateString(
+      std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+        task->getTaskArgumentValue("requested_by_phrase")).toUtf8().constData()}),
+    builder.CreateString(
+      std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+        task->getTaskArgumentValue("promote_share")).toUtf8().constData()}),
+    builder.CreateString(
+      std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+        task->getTaskArgumentValue("link_in_bio")).toUtf8().constData()}),
+    std::get<Scheduler::VariantIndex::BOOLEAN>(
+        task->getTaskArgumentValue("is_video")),
+        app_mask,
+    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()}));
+}
+}
+
 /**
  * @param [in] {std::function<void()>} cb A non-returning function to be called without parameter
  * @returns {MessageHandler} A message loop handler
@@ -232,82 +320,18 @@ void Client::sendEncoded(std::string message) {
     builder.Clear();
 }
 
-/**
- * @brief getTaskFileInfo
- * @param [in] {std::vector<SentFile>} files The files to produce an information string from
- * @return std::string A string with the following format denoting each file:
- * `1580057341filename|image::`
- */
-std::string getTaskFileInfo(std::vector<SentFile> files) {
-    std::string info{};
-    for (const auto& f : files) {
-        info += std::to_string(f.timestamp);
-        info += f.name.toUtf8().constData();
-        info += "|";
-        if (f.type == Scheduler::FileType::VIDEO) {
-            info += "video";
-        } else {
-            info += "image";
-        }
-        info += ":";
-    }
-    qDebug() << "File Info: " << info.c_str();
-    return info;
-}
-
 /**
  * @brief Client::sendTaskEncoded
  * @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,
-            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()}),
-            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-              task->getTaskArgumentValue("hashtags_string")).toUtf8().constData()}),
-            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-              task->getTaskArgumentValue("requested_by_string")).toUtf8().constData()}),
-            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-              task->getTaskArgumentValue("requested_by_phrase")).toUtf8().constData()}),
-            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-              task->getTaskArgumentValue("promote_share")).toUtf8().constData()}),
-            builder.CreateString(std::string{std::get<Scheduler::VariantIndex::QSTRING>(
-              task->getTaskArgumentValue("link_in_bio")).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()}));
+      Task::createIGTask(task, getSelectedApp(), sent_files);
     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()}));
-            std::get<Scheduler::VariantIndex::INTEGER>(
-              task->getTaskArgumentValue("recurring"));
+      Task::createGenericTask(task, getSelectedApp(), sent_files);
     builder.Finish(generic_task);
   }