new message schema

changed architecture to handle multiple files

headers/instatask.fbs

@@ -2,7 +2,7 @@ namespace IGData;
 
 table IGTask {
   id: int;
-  filename: string;
+  file_info: string;
   time: string;
   description: string;
   hashtags: string;
@@ -10,6 +10,7 @@ table IGTask {
   requested_by_phrase: string;
   promote_share: string;
   link_bio: string;
+  is_video: bool;
   mask: int;
 }
 

headers/instatask_generated.h

@@ -13,7 +13,7 @@ struct IGTask;
 struct IGTask FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_ID = 4,
-    VT_FILENAME = 6,
+    VT_FILE_INFO = 6,
     VT_TIME = 8,
     VT_DESCRIPTION = 10,
     VT_HASHTAGS = 12,
@@ -21,13 +21,14 @@ struct IGTask FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_REQUESTED_BY_PHRASE = 16,
     VT_PROMOTE_SHARE = 18,
     VT_LINK_BIO = 20,
-    VT_MASK = 22
+    VT_IS_VIDEO = 22,
+    VT_MASK = 24
   };
   int32_t id() const {
     return GetField<int32_t>(VT_ID, 0);
   }
-  const flatbuffers::String *filename() const {
-    return GetPointer<const flatbuffers::String *>(VT_FILENAME);
+  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);
@@ -50,14 +51,17 @@ struct IGTask FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const flatbuffers::String *link_bio() const {
     return GetPointer<const flatbuffers::String *>(VT_LINK_BIO);
   }
+  bool is_video() const {
+    return GetField<uint8_t>(VT_IS_VIDEO, 0) != 0;
+  }
   int32_t mask() const {
     return GetField<int32_t>(VT_MASK, 0);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_ID) &&
-           VerifyOffset(verifier, VT_FILENAME) &&
-           verifier.VerifyString(filename()) &&
+           VerifyOffset(verifier, VT_FILE_INFO) &&
+           verifier.VerifyString(file_info()) &&
            VerifyOffset(verifier, VT_TIME) &&
            verifier.VerifyString(time()) &&
            VerifyOffset(verifier, VT_DESCRIPTION) &&
@@ -72,6 +76,7 @@ struct IGTask FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            verifier.VerifyString(promote_share()) &&
            VerifyOffset(verifier, VT_LINK_BIO) &&
            verifier.VerifyString(link_bio()) &&
+           VerifyField<uint8_t>(verifier, VT_IS_VIDEO) &&
            VerifyField<int32_t>(verifier, VT_MASK) &&
            verifier.EndTable();
   }
@@ -83,8 +88,8 @@ struct IGTaskBuilder {
   void add_id(int32_t id) {
     fbb_.AddElement<int32_t>(IGTask::VT_ID, id, 0);
   }
-  void add_filename(flatbuffers::Offset<flatbuffers::String> filename) {
-    fbb_.AddOffset(IGTask::VT_FILENAME, filename);
+  void add_file_info(flatbuffers::Offset<flatbuffers::String> file_info) {
+    fbb_.AddOffset(IGTask::VT_FILE_INFO, file_info);
   }
   void add_time(flatbuffers::Offset<flatbuffers::String> time) {
     fbb_.AddOffset(IGTask::VT_TIME, time);
@@ -107,6 +112,9 @@ struct IGTaskBuilder {
   void add_link_bio(flatbuffers::Offset<flatbuffers::String> link_bio) {
     fbb_.AddOffset(IGTask::VT_LINK_BIO, link_bio);
   }
+  void add_is_video(bool is_video) {
+    fbb_.AddElement<uint8_t>(IGTask::VT_IS_VIDEO, static_cast<uint8_t>(is_video), 0);
+  }
   void add_mask(int32_t mask) {
     fbb_.AddElement<int32_t>(IGTask::VT_MASK, mask, 0);
   }
@@ -125,7 +133,7 @@ struct IGTaskBuilder {
 inline flatbuffers::Offset<IGTask> CreateIGTask(
     flatbuffers::FlatBufferBuilder &_fbb,
     int32_t id = 0,
-    flatbuffers::Offset<flatbuffers::String> filename = 0,
+    flatbuffers::Offset<flatbuffers::String> file_info = 0,
     flatbuffers::Offset<flatbuffers::String> time = 0,
     flatbuffers::Offset<flatbuffers::String> description = 0,
     flatbuffers::Offset<flatbuffers::String> hashtags = 0,
@@ -133,6 +141,7 @@ inline flatbuffers::Offset<IGTask> CreateIGTask(
     flatbuffers::Offset<flatbuffers::String> requested_by_phrase = 0,
     flatbuffers::Offset<flatbuffers::String> promote_share = 0,
     flatbuffers::Offset<flatbuffers::String> link_bio = 0,
+    bool is_video = false,
     int32_t mask = 0) {
   IGTaskBuilder builder_(_fbb);
   builder_.add_mask(mask);
@@ -143,15 +152,16 @@ inline flatbuffers::Offset<IGTask> CreateIGTask(
   builder_.add_hashtags(hashtags);
   builder_.add_description(description);
   builder_.add_time(time);
-  builder_.add_filename(filename);
+  builder_.add_file_info(file_info);
   builder_.add_id(id);
+  builder_.add_is_video(is_video);
   return builder_.Finish();
 }
 
 inline flatbuffers::Offset<IGTask> CreateIGTaskDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     int32_t id = 0,
-    const char *filename = nullptr,
+    const char *file_info = nullptr,
     const char *time = nullptr,
     const char *description = nullptr,
     const char *hashtags = nullptr,
@@ -159,8 +169,9 @@ inline flatbuffers::Offset<IGTask> CreateIGTaskDirect(
     const char *requested_by_phrase = nullptr,
     const char *promote_share = nullptr,
     const char *link_bio = nullptr,
+    bool is_video = false,
     int32_t mask = 0) {
-  auto filename__ = filename ? _fbb.CreateString(filename) : 0;
+  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 hashtags__ = hashtags ? _fbb.CreateString(hashtags) : 0;
@@ -171,7 +182,7 @@ inline flatbuffers::Offset<IGTask> CreateIGTaskDirect(
   return IGData::CreateIGTask(
       _fbb,
       id,
-      filename__,
+      file_info__,
       time__,
       description__,
       hashtags__,
@@ -179,6 +190,7 @@ inline flatbuffers::Offset<IGTask> CreateIGTaskDirect(
       requested_by_phrase__,
       promote_share__,
       link_bio__,
+      is_video,
       mask);
 }
 

headers/util.hpp

@@ -26,6 +26,17 @@ public:
 };
 }
 
+enum FileType {
+    VIDEO = 1,
+    IMAGE = 2
+};
+
+struct KFileData {
+    FileType type;
+    QString name;
+    QByteArray bytes;
+};
+
 namespace {
 using namespace rapidjson;
 using json = nlohmann::json;

include/argdialog.h

@@ -8,6 +8,7 @@
 #include <QPushButton>
 #include <string_view>
 #include <unordered_map>
+#include <headers/util.hpp>
 
 namespace Args {
 const QString DESCRIPTION_TYPE = "description";
@@ -16,11 +17,9 @@ const QString PROMOTE_TYPE = "promote/share";
 const QString LINK_BIO_TYPE = "link/bio";
 const QString REQUESTED_BY_TYPE = "requested by";
 }  // namespace Args
+
 typedef std::string Str;
-//namespace Emoji {
-//    Str SmilingFaceEyes{"U+1F60A"};
-//    const char* SmilingFaceEyesBytes = "😊";
-//}
+
 typedef struct Task {
     int mask;
     std::vector<std::string> args;
@@ -29,6 +28,7 @@ typedef struct Task {
 typedef struct KFile {
   QString name;
   QString path;
+  FileType type;
 } KFile;
 
 typedef struct IGPost {
@@ -40,12 +40,13 @@ typedef struct IGPost {
   std::vector<std::string> hashtags;
   std::vector<std::string> requested_by;
   const char *requested_by_phrase = "The phrase was requested by ";
-  KFile video;
+  std::vector<KFile> files;
+  bool is_video;
   bool isReady() {
     return description.size() > 0 && datetime.size() > 0 &&
            promote_share.size() > 0 && link_in_bio.size() > 0 &&
-           hashtags.size() > 0 && requested_by.size() > 0 &&
-           video.path.size() > 0;
+             hashtags.size() > 0 && requested_by.size() > 0 && !files.empty() &&
+             files.at(0).path.size() > 0;
   }
 } IGPost;
 
@@ -61,7 +62,7 @@ class ArgDialog : public QDialog {
   ~ArgDialog();
 
  signals:
-  void uploadFile(QByteArray bytes);
+  void uploadFiles(QVector<KFileData> files);
   void taskRequestReady(Task task, bool file_pending);
 
  private:

include/client.hpp

@@ -10,11 +10,13 @@
 #include <QLabel>
 #include <QString>
 #include <QVector>
+#include <QQueue>
 #include <QThread>
 #include <QMetaType>
 #include <thread>
 #include <string>
 #include <utility>
+#include <headers/util.hpp>
 
 static constexpr int MESSAGE_UPDATE_TYPE = 1;
 static constexpr int COMMANDS_UPDATE_TYPE = 2;
@@ -35,7 +37,14 @@ typedef std::map<int, std::string> CommandMap;
 typedef std::map<int, std::vector<std::string>> CommandArgMap;
 typedef QVector<QString> StringVec;
 
+struct SentFile {
+    int timestamp;
+    QString name;
+    FileType type;
+};
+
 Q_DECLARE_METATYPE(StringVec)
+Q_DECLARE_METATYPE(QVector<QByteArray>);
 
 class Client : public QDialog
 {
@@ -68,17 +77,18 @@ public:
 
 public slots:
     void sendMessage(const QString& s);
-    void sendEncoded(std::string message);
-    void sendFileEncoded(QByteArray bytes);
-    void sendTaskEncoded(TaskType type, std::vector<std::string> args);
     void setSelectedApp(std::vector<QString> app_names);
-    void sendFile(QByteArray bytes);
+    void sendFiles(QVector<KFileData> files);
 
 signals:
     void messageReceived(int t, QString s, QVector<QString> args);
     void eventReceived(int t, std::string event, StringVec args);
 
 private:
+    void sendEncoded(std::string message);
+    void sendFileEncoded(QByteArray bytes);
+    void sendTaskEncoded(TaskType type, std::vector<std::string> args);
+    void processFileQueue();
     void handleMessages();
     void sendPackets(uint8_t* data, int size);
     int argc;
@@ -89,6 +99,7 @@ private:
     CommandMap m_commands;
     CommandArgMap m_command_arg_map;
     std::vector<int> selected_commands;
-    QByteArray outgoing_file;
+    QQueue<KFileData> outgoing_files;
+    std::vector<SentFile> sent_files;
 };
 #endif // CLIENT_HPP

include/mainwindow.h

@@ -49,24 +49,29 @@ public:
     virtual void keyPressEvent(QKeyEvent* e);
     ~MainWindow();
 private:
-    Ui::MainWindow *ui;
-    ArgDialog *arg_ui;
-    void connectUi();
-    void runApp();
-    void updateProcessResult(QString request_id, QString result);
-    QString parseMessage(const QString& s, StringVec v);
+    /** Process arguments */
     int cli_argc;
     char** cli_argv;
+    /** UI & Messages */
+    void connectUi();
+    QString parseMessage(const QString& s, StringVec v);
+    void updateProcessResult(QString request_id, QString result);
+    /** UI Members */
+    Ui::MainWindow *ui;
+    ArgDialog *arg_ui;
+    ConsoleDialog console_ui;
+    /** Client member */
     Client* q_client;
+    /** Models */
     std::vector<Process> m_processes;
     QStandardItemModel* m_process_model;
     QList<QString> m_events;
-    ConsoleDialog m_console;
 
 private slots:
+    /** Receivers */
     void connectClient();
     void updateMessages(int t, const QString& s, StringVec v);
-    void handleInputEnterKey();
+    void handleKey();
 };
 
 

src/argdialog.cpp

@@ -8,7 +8,7 @@
 #include <QTableWidgetItem>
 #include <QDateTime>
 #include <QCalendarWidget>
-#include <headers/util.hpp>
+#include <QMimeDatabase>
 
 ArgDialog::ArgDialog(QWidget *parent) :
     QDialog(parent),
@@ -24,11 +24,17 @@ ArgDialog::ArgDialog(QWidget *parent) :
         if (file_path.size() > 0) {
             auto slash_index = file_path.lastIndexOf("/") + 1;
             QString file_name = file_path.right(file_path.size() - slash_index);
-
+            QMimeDatabase db;
+            auto is_video = db.mimeTypeForFile(file_path).name().contains("video");
             addItem(file_name, "file");
+            m_ig_post.files.push_back(KFile{
+                .name=file_name, .path=file_path, .type = is_video ? FileType::VIDEO : FileType::IMAGE
+            });
 
-            m_ig_post.video.name = file_name;
-            m_ig_post.video.path = file_path;
+            if (!m_ig_post.is_video && is_video) {
+                qDebug() << "File discovered to be video";
+                m_ig_post.is_video = true; // rename to "sending_video"
+            }
         }
     });
 
@@ -73,19 +79,29 @@ ArgDialog::ArgDialog(QWidget *parent) :
         if (button->text() == "Save") {
             if (m_ig_post.isReady()) {
                 setTaskArguments();
-                QFile file(m_ig_post.video.path);
-                std::vector<char> byte_array{};
-                if (file.open(QIODevice::ReadOnly)) {
-                    QByteArray bytes = file.readAll();
-                    emit ArgDialog::uploadFile(bytes);
-                    qDebug() << "Would be sending file..";
-                } else {
-                    QMessageBox::warning(
-                        this,
-                        tr("File Error"),
-                        tr("Unable to read file")
-                    );
+                QVector<KFileData> k_file_v{};
+                k_file_v.reserve(m_ig_post.files.size());
+
+                for (const auto& kfile : m_ig_post.files) {
+                    QFile file(kfile.path);
+                    if (file.open(QIODevice::ReadOnly)) {
+                        k_file_v.push_back(KFileData{
+                            .type = kfile.type,
+                            .name = kfile.name,
+                            .bytes = file.readAll()
+                        });
+                    } else {
+                        QMessageBox::warning(
+                            this,
+                            tr("File Error"),
+                            tr("Unable to read file")
+                        );
+                    }
                 }
+                if (!k_file_v.empty()) {
+                    emit ArgDialog::uploadFiles(k_file_v);
+                }
+
                 emit ArgDialog::taskRequestReady(m_task, true);
             }
         }
@@ -101,7 +117,7 @@ ArgDialog::ArgDialog(QWidget *parent) :
             .link_in_bio = escapeText("Download a FREE PDF of 245 basic verbs (link 🔗 in bio 👆").toUtf8().constData(),
             .hashtags = {"love", "life"},
             .requested_by = {"unwillingagent"},
-            .video = {.name = "holy.jpg", .path = "/data/c/ky_gui/assets/holy.jpg"}
+            .files = {{ .name = "holy.jpg", .path = "/data/c/ky_gui/assets/holy.jpg", .type = FileType::IMAGE }}
         };
     });
 }
@@ -122,7 +138,7 @@ void ArgDialog::setTaskArguments() {
     requested_by.pop_back();
     }
 
-    m_task.args.push_back(m_ig_post.video.name.toUtf8().constData());
+//    m_task.args.push_back(m_ig_post.file.name.toUtf8().constData());
     m_task.args.push_back(m_ig_post.datetime);
     m_task.args.push_back(m_ig_post.description);
     m_task.args.push_back(hashtags);
@@ -130,6 +146,7 @@ void ArgDialog::setTaskArguments() {
     m_task.args.push_back(m_ig_post.requested_by_phrase);
     m_task.args.push_back(m_ig_post.promote_share);
     m_task.args.push_back(m_ig_post.link_in_bio);
+    m_task.args.push_back(std::to_string(m_ig_post.is_video));
 }
 
 void ArgDialog::addItem(QString value, QString type) {
@@ -142,7 +159,7 @@ void ArgDialog::addItem(QString value, QString type) {
 }
 
 void ArgDialog::clearPost() {
-    m_ig_post.video = KFile{};
+    m_ig_post.files.clear();
     m_ig_post.datetime = "";
     m_ig_post.hashtags = {};
     m_ig_post.description = "";

src/client.cpp

@@ -16,12 +16,10 @@
 #define FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
 #include <headers/kmessage_codec.hpp>
 #include <headers/instatask_generated.h>
-#include <headers/util.hpp>
 
 using namespace KData;
 using namespace IGData;
 
-static const int MAX_BUFFER_SIZE = 2048;
 static const int MAX_PACKET_SIZE = 4096;
 static const int HEADER_SIZE = 4;
 
@@ -29,8 +27,8 @@ flatbuffers::FlatBufferBuilder builder(1024);
 
 /**
  * @brief Client::createMessageHandler
- * @param cb
- * @return
+ * @param [in] {std::function<void()>} cb A non-returning function to be called without parameter
+ * @returns {MessageHandler} A message loop handler
  */
 Client::MessageHandler Client::createMessageHandler(
     std::function<void()> cb) {
@@ -40,9 +38,9 @@ Client::MessageHandler Client::createMessageHandler(
 /**
  * @brief Client::Client
  * @constructor
- * @param parent
- * @param count
- * @param arguments
+ * @param [in] {QWidget*} parent
+ * @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), m_commands({}), executing(false) {
     qRegisterMetaType<QVector<QString>>("QVector<QString>");
@@ -66,27 +64,33 @@ void Client::handleMessages() {
         ssize_t bytes_received = 0;
         bytes_received = recv(m_client_socket_fd, receive_buffer, 2048 - 2, 0);
         receive_buffer[2047] = 0;
-        if (bytes_received == 0) {
+        if (bytes_received == 0) { // Finish message loop
             break;
         }
         size_t end_idx = findNullIndex(receive_buffer);
         std::string data_string{receive_buffer, receive_buffer + end_idx};
         StringVec s_v{};
-        if (isNewSession(data_string.c_str())) {
+        if (isNewSession(data_string.c_str())) { // Session Start
             m_commands = getArgMap(data_string.c_str());
-            for (const auto& [k, v] : m_commands) {
+            for (const auto& [k, v] : m_commands) { // Receive available commands
                 s_v.push_back(v.data());
             }
-            emit Client::messageReceived(COMMANDS_UPDATE_TYPE, "New Session", s_v);
-        } else if (serverWaitingForFile(data_string.c_str())) {
-            sendFileEncoded(outgoing_file);
-        } else if (isEvent(data_string.c_str())) {
+            emit Client::messageReceived(COMMANDS_UPDATE_TYPE, "New Session", s_v); // Update UI
+        } else if (serverWaitingForFile(data_string.c_str())) { // Server expects a file
+            processFileQueue();
+        } else if (isEvent(data_string.c_str())) { // Receiving event
             QString event = getEvent(data_string.c_str());
             QVector<QString> args = getArgs(data_string.c_str());
-            emit Client::messageReceived(EVENT_UPDATE_TYPE, event, args);
-            if (isUploadCompleteEvent(event.toUtf8().constData())) {
-                outgoing_file.clear();
-                sendTaskEncoded(TaskType::INSTAGRAM, m_task);
+            emit Client::messageReceived(EVENT_UPDATE_TYPE, event, args); // Update UI (event)
+            if (isUploadCompleteEvent(event.toUtf8().constData())) { // Upload complete
+                if (!args.isEmpty()) {
+                    sent_files.at(sent_files.size() - 1).timestamp = std::stoi(args.at(0).toUtf8().constData());
+                    if (outgoing_files.isEmpty()) {
+                        sendTaskEncoded(TaskType::INSTAGRAM, m_task);
+                    } else { // More files to send
+                        processFileQueue();
+                    }
+                }
             }
         }
         std::string formatted_json = getJsonString(data_string);
@@ -97,9 +101,13 @@ void Client::handleMessages() {
 //    ::shutdown(m_client_socket_fd, SHUT_RDWR);
 }
 
+void Client::processFileQueue() {
+    KFileData outgoing_file = outgoing_files.dequeue();
+    sendFileEncoded(outgoing_file.bytes);
+    sent_files.push_back(SentFile{.name = outgoing_file.name, .type = outgoing_file.type });
+}
 /**
  * @brief Client::start
- * @return A meaningless integer
  */
 void Client::start() {
     if (m_client_socket_fd == -1) {
@@ -112,7 +120,6 @@ void Client::start() {
             if (port_value < 0 || end == argv[2]) {
                 return;
             }
-
             int socket_option = 1;
             // Free up the port to begin listening again
             setsockopt(m_client_socket_fd, SOL_SOCKET, SO_REUSEADDR, &socket_option,
@@ -148,7 +155,7 @@ void Client::start() {
 
 /**
  * @brief Client::sendMessage
- * @param s[in] <const QString&> The message to send
+ * @param [in] {const QString&} The message to send
  */
 void Client::sendMessage(const QString& s) {
     if (m_client_socket_fd != -1) {
@@ -162,6 +169,10 @@ void Client::sendMessage(const QString& s) {
     }
 }
 
+/**
+ * @brief Client::sendEncoded
+ * @param [in] {std::string message} The message to send
+ */
 void Client::sendEncoded(std::string message) {
     std::vector<uint8_t> fb_byte_vector{message.begin(), message.end()};
     auto byte_vector = builder.CreateVector(fb_byte_vector);
@@ -180,35 +191,61 @@ void Client::sendEncoded(std::string message) {
     send_buffer[3] = (size & 0xFF);
     send_buffer[4] = (TaskCode::GENMSGBYTE & 0xFF);
     std::memcpy(send_buffer + 5, encoded_message_buffer, size);
-    qDebug() << "Ready to send:";
+    qDebug() << "Sending encoded message";
     std::string message_to_send{};
     for (unsigned int i = 0; i < (size + 5); i++) {
         message_to_send += (char)*(send_buffer + i);
-        qDebug() << (char)*(send_buffer + i);
     }
-    qDebug() << "Final size: " << (size + 5);
+    qDebug() << "Encoded message size: " << (size + 5);
     // Send start operation
     ::send(m_client_socket_fd, send_buffer, size + 5, 0);
     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 == FileType::VIDEO) {
+            info += "video";
+        } else {
+            info += "image";
+        }
+        info += "::";
+    }
+    qDebug() << "File Info: " << info.c_str();
+    return info;
+}
 
+/**
+ * @brief Client::sendTaskEncoded
+ * @param [in] {TaskType}                 type The type of task
+ * @param [in] {std::vector<std::string>} args The task arguments
+ */
 void Client::sendTaskEncoded(TaskType type, std::vector<std::string> args) {
     if (type == TaskType::INSTAGRAM) {
-        if (args.size() < 7) {
+        if (args.size() < 6) {
             qDebug() << "Not enough arguments to send an IGTask";
             return;
         }
-        auto filename = builder.CreateString(args.at(0).c_str(), args.at(0).size());
-        auto time = builder.CreateString(args.at(1).c_str(), args.at(1).size());
-        auto description = builder.CreateString(args.at(2).c_str(), args.at(2).size());
-        auto hashtags = builder.CreateString(args.at(3).c_str(), args.at(3).size());
-        auto requested_by = builder.CreateString(args.at(4).c_str(), args.at(4).size());
-        auto requested_by_phrase = builder.CreateString(args.at(5).c_str(), args.at(5).size());
-        auto promote_share = builder.CreateString(args.at(6).c_str(), args.at(6).size());
-        auto link_bio = builder.CreateString(args.at(7).c_str(), args.at(7).size());
-//        auto mask = std::stoi(args.at(8));
-
-        flatbuffers::Offset<IGTask> ig_task = CreateIGTask(builder, 96, filename, time, description, hashtags, requested_by, requested_by_phrase, promote_share, link_bio, 16);
+        auto file_info = builder.CreateString(getTaskFileInfo(sent_files));
+        auto time = builder.CreateString(args.at(0).c_str(), args.at(0).size());
+        auto description = builder.CreateString(args.at(1).c_str(), args.at(1).size());
+        auto hashtags = builder.CreateString(args.at(2).c_str(), args.at(2).size());
+        auto requested_by = builder.CreateString(args.at(3).c_str(), args.at(3).size());
+        auto requested_by_phrase = builder.CreateString(args.at(4).c_str(), args.at(4).size());
+        auto promote_share = builder.CreateString(args.at(5).c_str(), args.at(5).size());
+        auto link_bio = builder.CreateString(args.at(6).c_str(), args.at(6).size());
+        auto is_video = args.at(7) == "1";
+
+        flatbuffers::Offset<IGTask> ig_task = CreateIGTask(builder, 96, file_info, time, description, hashtags, requested_by, requested_by_phrase, promote_share, link_bio, is_video, 16);
 
         builder.Finish(ig_task);
 
@@ -237,6 +274,11 @@ void Client::sendTaskEncoded(TaskType type, std::vector<std::string> args) {
     }
 }
 
+/**
+ * @brief Client::sendPackets
+ * @param [in] {uint8_t*} data A pointer to a buffer of bytes
+ * @param [in] {int}      size The size of the buffer to be packetized and sent
+ */
 void Client::sendPackets(uint8_t* data, int size) {
     uint32_t total_size = static_cast<uint32_t>(size + HEADER_SIZE);
     uint32_t total_packets = static_cast<uint32_t>(ceil(
@@ -244,9 +286,7 @@ void Client::sendPackets(uint8_t* data, int size) {
             static_cast<double>(total_size) / static_cast<double>(MAX_PACKET_SIZE)) // total size / packet
         )
     );
-
     uint32_t idx = 0;
-
     for (; idx < total_packets; idx++) {
         bool is_first_packet = (idx == 0);
         bool is_last_packet = (idx == (total_packets - 1));
@@ -281,15 +321,22 @@ void Client::sendPackets(uint8_t* data, int size) {
         ::send(m_client_socket_fd, packet, packet_size, 0);
         if (is_last_packet) {
             // cleanup
-            outgoing_file.clear();
+            qDebug() << "Last packet of file sent";
         }
     }
 }
 
+/**
+ * @brief Client::sendFileEncoded
+ * @param [in] {QByteArray} bytes An array of bytes to send
+ */
 void Client::sendFileEncoded(QByteArray bytes) {
     sendPackets(reinterpret_cast<uint8_t*>(bytes.data()), bytes.size());
 }
 
+/**
+ * @brief Client::closeConnection
+ */
 void Client::closeConnection() {
     if (m_client_socket_fd != -1) {
         std::string stop_operation_string = createOperation("stop", {});
@@ -304,6 +351,10 @@ void Client::closeConnection() {
     qDebug() << "There is no active connection to close";
 }
 
+/**
+ * @brief Client::setSelectedApp
+ * @param [in] TYPE SHOULD CHANGE app_names
+ */
 void Client::setSelectedApp(std::vector<QString> app_names) {
     selected_commands.clear();
     for (const auto& name : app_names) {
@@ -316,6 +367,10 @@ void Client::setSelectedApp(std::vector<QString> app_names) {
     }
 }
 
+/**
+ * @brief Client::getSelectedApp
+ * @returns {int} The mask representing the selected application
+ */
 int Client::getSelectedApp() {
     if (selected_commands.size() == 1) {
         return selected_commands.at(0);
@@ -325,6 +380,11 @@ int Client::getSelectedApp() {
     return -1;
 }
 
+/**
+ * @brief Client::getAppName
+ * @param [in] {int} mask The mask representing the application
+ * @returns {QString} The application name
+ */
 QString Client::getAppName(int mask) {
     auto app = m_commands.find(mask);
     if (app != m_commands.end()) {
@@ -333,8 +393,9 @@ QString Client::getAppName(int mask) {
     return QString{""};
 }
 
-
-
+/**
+ * @brief Client::execute
+ */
 void Client::execute() {
     if (!selected_commands.empty()) {
         executing = true;
@@ -349,24 +410,32 @@ void Client::execute() {
     }
 }
 
+/**
+ * @brief Client::scheduleTask
+ * @param [in] {std::vector<std::string>} task_args The task arguments
+ * @param [in] {bool}                     file_pending A boolean indicating whether there are files being sent for this task
+ */
 void Client::scheduleTask(std::vector<std::string> task_args, bool file_pending) {
     if (file_pending) {
         m_task = task_args;
     } else {
         qDebug() << "Requesting a task to be scheduled";
-//        std::string operation_string = createOperation("Schedule", task_args);
         sendTaskEncoded(TaskType::INSTAGRAM, task_args);
     }
 }
 
-void Client::sendFile(QByteArray bytes) {
-    if (outgoing_file.isNull()) {
+/**
+ * @brief Client::sendFiles
+ * @param [in] {QVector<const QByteArray} files The files to be sent
+ */
+void Client::sendFiles(QVector<KFileData> files) {
+    if (outgoing_files.isEmpty()) {
+        for (const auto & file : files) {
+            outgoing_files.enqueue(file);
+        }
         std::string send_file_operation = createOperation("FileUpload", {});
-        int size = bytes.size();
-        qDebug() << size << " bytes to send";
         sendEncoded(send_file_operation);
-        outgoing_file = bytes;
     } else {
-        qDebug() << "Outgoing file buffer is not ready";
+        qDebug() << "Still attempting to send a different file";
     }
 }

src/mainwindow.cpp

@@ -35,10 +35,10 @@ QString getTime() {
  */
 MainWindow::MainWindow(int argc, char** argv, QWidget *parent) :
     QMainWindow(parent),
-    ui(new Ui::MainWindow),
-    arg_ui(new ArgDialog),
     cli_argc(argc),
     cli_argv(argv),
+    ui(new Ui::MainWindow),
+    arg_ui(new ArgDialog),
     q_client(nullptr) {
     m_process_model = new QStandardItemModel(this);
     q_client = new Client(this, cli_argc, cli_argv);
@@ -110,8 +110,8 @@ void MainWindow::connectClient() {
         }
     });
 
-    QObject::connect(arg_ui, &ArgDialog::uploadFile, this, [this](QByteArray bytes) {
-        q_client->sendFile(bytes);
+    QObject::connect(arg_ui, &ArgDialog::uploadFiles, this, [this](QVector<KFileData> files) {
+        q_client->sendFiles(files);
     });
 
     QObject::connect(arg_ui, &ArgDialog::taskRequestReady, this, [this](Task task, bool file_pending) {
@@ -119,7 +119,7 @@ void MainWindow::connectClient() {
         auto mask = q_client->getSelectedApp();
         if (mask > -1) {
             if (q_client->getAppName(mask) == "Instagram") {
-                auto datetime = task.args.at(1);
+                auto datetime = task.args.at(0);
                 auto current_datetime = QDateTime::currentDateTime().toTime_t();
                 auto seconds_diff = std::stoi(datetime) - current_datetime;
                 qDebug() << "Time difference: " << seconds_diff;
@@ -138,12 +138,12 @@ void MainWindow::connectClient() {
     });
 
     QObject::connect(ui->viewConsole, &QPushButton::clicked, this, [this]() {
-        m_console.show();
+        console_ui.show();
     });
 
     // TODO: Handle enter key
     //    QObject::connect(static_cast<KTextEdit*>(ui->inputText), &KTextEdit::textInputEnter, this, &MainWindow::handleInputEnterKey);
-    QObject::connect(static_cast<KTextEdit*>(ui->inputText), &KTextEdit::textInputEnter, this, &MainWindow::handleInputEnterKey);
+    QObject::connect(static_cast<KTextEdit*>(ui->inputText), &KTextEdit::textInputEnter, this, &MainWindow::handleKey);
 
     QObject::connect(ui->processList, &QListView::clicked, this, [this](const QModelIndex &index) {
         auto process = m_processes.at(index.row());
@@ -157,7 +157,7 @@ void MainWindow::connectClient() {
     });
 }
 
-void MainWindow::handleInputEnterKey() {
+void MainWindow::handleKey() {
     q_client->sendMessage(ui->inputText->toPlainText());
     ui->inputText->clear();
 }
@@ -176,12 +176,9 @@ QString MainWindow::parseMessage(const QString& message, StringVec v) {
 }
 
 QStandardItem* createProcessListItem(Process process) {
-
     return new QStandardItem(QString("%0 requested for execution. ID: %1\nStatus: %2\nTime: %3   Done: %4").arg(process.name).arg(process.id).arg(ProcessNames[process.state - 1]).arg(process.start).arg(process.end));
 }
 
-
-
 /**
  * @brief MainWindow::updateMessages
  * @param s
@@ -192,7 +189,7 @@ void MainWindow::updateMessages(int t, const QString& message, StringVec v) {
         qDebug() << "Updating message area";
         auto simple_message = timestamp_prefix + parseMessage(message, v);
         ui->messages->append(simple_message);
-        m_console.updateText(message);
+        console_ui.updateText(message);
     } else if (t == COMMANDS_UPDATE_TYPE) {
         if (message == "New Session") {
             ui->led->setState(true);
@@ -203,8 +200,6 @@ void MainWindow::updateMessages(int t, const QString& message, StringVec v) {
         for (const auto& s : v) {
             app_list->addItem(s);
         }
-        //TODO: We do this because a CommandLinkButton turns transparent by default, except when hovered or checked
-        ui->connect->setChecked(true);
     } else if (t == PROCESS_REQUEST_TYPE) {
         qDebug() << "Updating process list";
         m_processes.push_back(Process{ .name=v.at(1), .state=ProcessState::PENDING, .start=getTime(), .id=v.at(2) });
@@ -213,9 +208,6 @@ void MainWindow::updateMessages(int t, const QString& message, StringVec v) {
             m_process_model->setItem(row, createProcessListItem(process));
             row++;
         }
-
-        //TODO: We do this because a CommandLinkButton turns transparent by default, except when hovered or checked
-        ui->connect->setChecked(true);
     } else if (t == EVENT_UPDATE_TYPE) {
         QString event_message{timestamp_prefix};
         if (!v.empty()) {