Merge branch 'genericTask' into simplifyUi

include/task/instagram_task.hpp

@@ -8,7 +8,7 @@ namespace Scheduler {
 namespace Args {
 const QString HEADER_TYPE = "header";
 const QString DESCRIPTION_TYPE = "description";
-const QString HASHTAG_TYPE = "hashtag";
+const QString HASHTAG_TYPE = "hashtags";
 const QString PROMOTE_TYPE = "promote_share";
 const QString LINK_BIO_TYPE = "link_in_bio";
 const QString REQUESTED_BY_TYPE = "requested_by";
@@ -45,9 +45,16 @@ class InstagramTask : public Scheduler::Task {
   /**
    * 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 getTaskArgument(QString name) override;
+  virtual const Scheduler::TypeVariant getTaskArgumentValue(QString name) override;
 
   /**
    * Overrides @abstract Task::getArgumentValues
@@ -98,6 +105,13 @@ class InstagramTask : public Scheduler::Task {
    */
   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
    *

include/task/task.hpp

@@ -67,7 +67,7 @@ using TaskQueue = QQueue<Task*>;
 using ArgumentType = const char*;
 using ArgumentValues = QVector<QString>;
 using TypeVariant = std::variant<bool, int, QVector<QString>, QString, QVector<KFileData>>;
-using TaskIterator = std::vector<std::unique_ptr<TaskArgumentBase>>::iterator;
+using TaskIterator = std::vector<TaskArgumentBase*>::iterator;
 
 /**
  * The interface expected on our Task Arguments
@@ -80,6 +80,7 @@ class TaskArgumentBase {
   virtual TypeVariant getValue() = 0;
   virtual void insert(QString value) = 0;
   virtual void insert(KFileData file) = 0;
+  virtual void remove(TypeVariant value) = 0;
   virtual void setValue(TypeVariant v) = 0;
   virtual bool isContainer() = 0;
   virtual void clear() = 0;
@@ -106,7 +107,16 @@ class TaskArgument : TaskArgumentBase {
    * @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)) {}
+                                   name(std::move(a.name)), type(std::move(a.type)), value(std::move(a.value)) {}
+
+  /**
+   * Copy Constructor
+   *
+   * @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)) {}
   /**
    * text
    * @returns {QString} The name of the argument
@@ -117,7 +127,9 @@ class TaskArgument : TaskArgumentBase {
    * setValue
    * @param [in] {TypeVariant} new_value The new value for this argument
    */
-  virtual void setValue(TypeVariant new_value) override { value = new_value; }
+  virtual void setValue(TypeVariant new_value) override {
+    value = new_value;
+  }
 
   /**
    * @brief getStringValue
@@ -202,6 +214,39 @@ class TaskArgument : TaskArgumentBase {
     }
   }
 
+  /**
+   * @brief remove
+   * @param value
+   */
+  virtual void remove(TypeVariant unwanted_value) override {
+    if (value.index() == VariantIndex::STRVEC && unwanted_value.index() == VariantIndex::QSTRING) {
+      auto&& container = std::get<VariantIndex::STRVEC>(value);
+      auto value_to_remove = std::get<VariantIndex::QSTRING>(unwanted_value);
+      auto it = std::find_if(container.begin(), container.end(), [&value_to_remove](QString s) {
+        return (s == value_to_remove);
+      });
+      if (it != container.end()) {
+        container.erase(it);
+        return;
+      } else {
+        throw std::out_of_range("Could not find value requested for removal");
+      }
+    } else if (value.index() == VariantIndex::STRVEC && unwanted_value.index() == VariantIndex::FILEVEC) {
+      auto&& container = std::get<VariantIndex::STRVEC>(value);
+      auto value_to_remove = std::get<VariantIndex::QSTRING>(unwanted_value);
+      auto it = std::find_if(container.begin(), container.end(), [&value_to_remove](QString s) {
+        return (s == value_to_remove);
+      });
+      if (it != container.end()) {
+        container.erase(it);
+        return;
+      } else {
+        throw std::out_of_range("Could not find value requested for removal");
+      }
+    }
+    throw std::invalid_argument("The value provided does not match any existing container");
+  }
+
   /**
    * @brief getTypeIndex
    * @return
@@ -216,7 +261,7 @@ class TaskArgument : TaskArgumentBase {
   TypeVariant value;
 };
 
-using TaskArguments = std::vector<std::unique_ptr<TaskArgument>>;
+using TaskArguments = std::vector<TaskArgument*>;
 
 /**
  * The interface expected to be implemented in all Task types
@@ -229,8 +274,10 @@ class Task {
   virtual void setArgument(QString name, TypeVariant arg) = 0;
   virtual void addArgument(QString name, Scheduler::KFileData file) = 0;
   virtual void addArgument(QString name, QString string) = 0;
+  virtual void removeArgument(QString name, TypeVariant arg) = 0;
   virtual const TaskArguments&& getTaskArguments() = 0;
-  virtual const TypeVariant getTaskArgument(QString name) = 0;
+  virtual TaskArgument&& getTaskArgument(QString name) = 0;
+  virtual const TypeVariant getTaskArgumentValue(QString name) = 0;
   virtual ArgumentValues getArgumentValues() = 0;
   virtual QVector<QString> getArgumentNames() = 0;
   virtual TaskType getType() = 0;

src/argdialog.cpp

@@ -103,21 +103,21 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
         addHashtag(text);
       } else if (type == Args::DESCRIPTION_TYPE) {
         addItem(text, type);
-        m_task->setArgument("description", escapeText(text));
+        m_task->setArgument(Args::DESCRIPTION_TYPE, escapeText(text));
       } else if (type == Args::PROMOTE_TYPE) {
-        addOrReplaceInArgList(text, "promote/share");
-        m_task->setArgument("promote_share", text);
+        addOrReplaceInArgList(text, Args::PROMOTE_TYPE);
+        m_task->setArgument(Args::PROMOTE_TYPE, text);
       } else if (type == Args::LINK_BIO_TYPE) {
-        addOrReplaceInArgList(text, "link/bio");
-        m_task->setArgument("link_in_bio", text);
+        addOrReplaceInArgList(text, Args::LINK_BIO_TYPE);
+        m_task->setArgument(Args::LINK_BIO_TYPE, text);
       } else if (type == Args::REQUESTED_BY_TYPE) {
         addRequestedBy(text);
       } else if (type == Args::HEADER_TYPE) {
         addItem(text, type);
-        m_task->setArgument("header", text);
+        m_task->setArgument(Args::HEADER_TYPE, text);
       } else if (type == Args::REQUESTED_BY_PHRASE) {
         addItem(text, type);
-        m_task->setArgument("requested_by_phrase", text);
+        m_task->setArgument(Args::REQUESTED_BY_PHRASE, text);
       }
       ui->argInput->clear();
     }
@@ -161,12 +161,12 @@ ArgDialog::ArgDialog(QWidget *parent) : QDialog(parent), ui(new Ui::ArgDialog),
  */
 void ArgDialog::setTaskArguments() {
   QString hashtags{};
-  for (const auto &tag : std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("hashtags"))) {
+  for (const auto &tag : std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue("hashtags"))) {
     hashtags += "#" + tag + " ";
   }
   hashtags.chop(1);
   QString requested_by{};
-  for (const auto &name : std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("requested_by"))) {
+  for (const auto &name : std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue("requested_by"))) {
     requested_by += "@" + name + "";
   }
   if (requested_by.size() > 1) {
@@ -192,20 +192,29 @@ void ArgDialog::addItem(QString value, QString type) {
   QObject::connect(q_pb, &QPushButton::clicked, this, [this]() {
     auto row_index = ui->argList->currentRow();
     // If deleted item is a file, we need to remove it from the task
-    auto type = ui->argList->item(row_index, 0);
-    if (type->text() == "file") {
-      auto value = ui->argList->item(row_index, 1);
-      if (!value->text().isEmpty()) {
+    auto name = ui->argList->item(row_index, 0)->text();
+    auto value = ui->argList->item(row_index, 1)->text();
+    if (name == "file") {
+      if (!value.isEmpty()) {
         // All of the following should be done by the task
-        QVector<Scheduler::KFileData> task_files = std::get<VariantIndex::FILEVEC>(m_task->getTaskArgument("files"));
+        QVector<Scheduler::KFileData> task_files = std::get<VariantIndex::FILEVEC>(m_task->getTaskArgumentValue("files"));
         auto file_it = std::find_if(task_files.begin(), task_files.end(),
-                                    [value](const Scheduler::KFileData &file) { return file.name == value->text(); });
+                                    [value](const Scheduler::KFileData &file) { return file.name == value; });
         if (file_it != task_files.end()) {  // If file was matched
           qDebug() << "Removing file from task arguments";
           task_files.erase(file_it);
           m_task->setArgument("files", task_files); // Probably not necessary. Try without doing this
         }
       }
+    } else {
+      auto&& argument = m_task->getTaskArgument(name);
+      if (argument.isContainer()) {
+        for (auto&& s : value.split("\n")) {
+          m_task->removeArgument(name, s);
+        }
+      } else {
+        argument.clear();
+      }
     }
     ui->argList->removeRow(row_index);
   });
@@ -255,7 +264,7 @@ void ArgDialog::clearTask() { m_task->clear(); }
  */
 void ArgDialog::addRequestedBy(QString value) {
   QStringList names = value.split(" ");
-  QVector<QString> requested_by_names = std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("requested_by"));
+  QVector<QString> requested_by_names = std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue("requested_by"));
   for (const auto &name : names) {
     if (std::find(requested_by_names.begin(), requested_by_names.end(), value.toUtf8().constData()) == requested_by_names.end()) {
       m_task->addArgument("requested_by", name);
@@ -316,12 +325,13 @@ void ArgDialog::addOrReplaceInArgList(QString value, QString type) {
  * @param tag
  */
 void ArgDialog::addHashtag(QString tag) {
+  // Need to be able to handle line breaks!!
     QStringList tags = tag.split(" ");
     for (const auto& tag : tags) {
-      QVector<QString> hashtags = std::get<VariantIndex::STRVEC>(m_task->getTaskArgument("hashtags"));
+      QVector<QString> hashtags = std::get<VariantIndex::STRVEC>(m_task->getTaskArgumentValue(Args::HASHTAG_TYPE));
         if (std::find(hashtags.begin(), hashtags.end(), tag.toUtf8().constData()) == hashtags.end()) {
-          m_task->addArgument("hashtags", tag);
-          addToArgList(tag, "hashtag");
+          m_task->addArgument(Args::HASHTAG_TYPE, tag);
+          addToArgList(tag, Args::HASHTAG_TYPE);
         } else {
           const char* message = "Can't add the same hashtag twice";
           qDebug() << message;

src/client.cpp

@@ -250,25 +250,35 @@ void Client::sendTaskEncoded(Scheduler::Task* task) {
             builder.CreateString(
 /*0*/           getTaskFileInfo(sent_files)),
             builder.CreateString(
-/*1*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("datetime")).toUtf8().constData()}),
+/*1*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("datetime")).toUtf8().constData()}),
             builder.CreateString(
-/*2*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("description")).toUtf8().constData()}),
+/*2*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("description")).toUtf8().constData()}),
             builder.CreateString(
-/*3*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("hashtags_string")).toUtf8().constData()}),
+/*3*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("hashtags_string")).toUtf8().constData()}),
             builder.CreateString(
-/*4*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_string")).toUtf8().constData()}),
+/*4*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("requested_by_string")).toUtf8().constData()}),
             builder.CreateString(
-/*5*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("requested_by_phrase")).toUtf8().constData()}),
+/*5*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("requested_by_phrase")).toUtf8().constData()}),
             builder.CreateString(
-/*6*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("promote_share")).toUtf8().constData()}),
+/*6*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      task->getTaskArgumentValue("promote_share")).toUtf8().constData()}),
             builder.CreateString(
-/*7*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("link_in_bio")).toUtf8().constData()}),
-/*8*/           std::get<Scheduler::VariantIndex::BOOLEAN>(task->getTaskArgument("is_video")),
+/*7*/           std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                      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->getTaskArgument("header")).toUtf8().constData()}),
+/*10*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                       task->getTaskArgumentValue("header")).toUtf8().constData()}),
             builder.CreateString(
-/*11*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(task->getTaskArgument("user")).toUtf8().constData()}));
+/*11*/          std::string{std::get<Scheduler::VariantIndex::QSTRING>(
+                                       task->getTaskArgumentValue("user")).toUtf8().constData()}));
     builder.Finish(ig_task);
 
     uint8_t* encoded_message_buffer = builder.GetBufferPointer();

src/instagram_task.cpp

@@ -1,5 +1,5 @@
 #include <include/task/instagram_task.hpp>
-
+#include <QDebug>
 using namespace Scheduler;
 
 /**
@@ -34,19 +34,19 @@ InstagramTask::InstagramTask() {}
  */
 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, 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::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::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{"promote_share", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"link_in_bio", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"hashtags", Type::STRINGVECTOR, QVector<QString>{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"hashtags_string", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"requested_by", Type::STRINGVECTOR, QVector<QString>{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"requested_by_string", Type::TEXT, QString{}}));
+  m_arguments.emplace_back(std::move(new TaskArgument{"requested_by_phrase", 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{}}));
 }
 
 /**
@@ -55,10 +55,12 @@ void InstagramTask::defineTaskArguments() {
  * @param [in] {TypeVariant}  value  The value of the argument
  */
 void InstagramTask::setArgument(QString name, TypeVariant value) {
-  for (const auto& argument : m_arguments) {
+  for (auto&& argument : m_arguments) {
     if (argument->text() == name) {
-      argument->setValue(value);
-      return;
+      if (isIndex(value.index(), VariantIndex::STRVEC)) {
+        argument->setValue(std::get<VariantIndex::STRVEC>(value));
+        return;
+      }
     }
   }
 }
@@ -82,6 +84,29 @@ void InstagramTask::addArgument(QString name, Scheduler::KFileData file) {
   }
 }
 
+/**
+ * @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 InstagramTask::addArgument
+ *
+ * @param [in] {QString}      name  The name of the argument
+ * @param [in] {TypeVariant}  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 InstagramTask::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.
  *
@@ -99,13 +124,29 @@ void InstagramTask::addArgument(QString name, QString string) {
   }
 }
 
+
 /**
  * @brief InstagramTask::getTaskArgument
  *
  * @param [in] {QString} name   The name of the argument to retrieve
- * @return [out] {TypeVariant}  The value of the task
+ * @return [out] {TaskArgument}  The argument
+ */
+TaskArgument&& InstagramTask::getTaskArgument(QString name) {
+  for (const auto& argument : m_arguments) {
+    if (argument->text() == name) {
+      return *argument;
+    }
+  }
+  return TaskArgument{"None", "None", ""};  // Perhaps we should throw
+}
+
+/**
+ * @brief InstagramTask::getTaskArgumentValue
+ *
+ * @param [in] {QString} name   The name of the argument to retrieve
+ * @return [out] {TypeVariant}  The value of the argument
  */
-const TypeVariant InstagramTask::getTaskArgument(QString name) {
+const TypeVariant InstagramTask::getTaskArgumentValue(QString name) {
   for (const auto& argument : m_arguments) {
     if (argument->text() == name) {
       return argument->getValue();
@@ -203,7 +244,7 @@ void InstagramTask::clear() {
  * @return [out] {bool} Indicates whether the task has files.
  */
 bool InstagramTask::hasFiles() {
-  return !std::get<VariantIndex::FILEVEC>(getTaskArgument("files")).empty();
+  return !std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files")).empty();
 }
 
 /**
@@ -212,7 +253,7 @@ bool InstagramTask::hasFiles() {
  * @return [out] {QVector<KFileData>} A vector of data structures representing file metadata and the file data as bytes.
  */
 const QVector<Scheduler::KFileData> InstagramTask::getFiles() {
-  return std::get<VariantIndex::FILEVEC>(getTaskArgument("files"));
+  return std::get<VariantIndex::FILEVEC>(getTaskArgumentValue("files"));
 }
 
 /**
@@ -222,15 +263,15 @@ const QVector<Scheduler::KFileData> InstagramTask::getFiles() {
  *                      perform the task have been met.
  */
 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();
+  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 promote_share_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("promote_share")).size();
+  auto link_in_bio_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("link_in_bio")).size();
+  auto hashtags_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("hashtags_string")).size();
+  auto requested_by_size = std::get<VariantIndex::QSTRING>(getTaskArgumentValue("requested_by_string")).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 &&
          promote_share_size > 0 && link_in_bio_size > 0 &&