setup electron app with boilerplate

cpp/src/mediaparticlegenerator.cpp

@@ -0,0 +1,152 @@
+#include "mediaparticlegenerator.h"
+#include "networkmanager.h"
+#include "store.h"
+#include <QFile>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+
+MediaParticleGenerator::MediaParticleGenerator(Store *store, QObject *parent)
+    : QObject{parent}, m_store{store}, m_qnam{new QNetworkAccessManager{this}}
+{
+}
+
+bool MediaParticleGenerator::isGenerating() const
+{
+  return m_isGenerating;
+}
+
+void MediaParticleGenerator::generate(const QUrl &url, const QString &mimeType, const QString &networkId, qint64 durationMs, const QString &streamId)
+{
+  if (m_isGenerating)
+  {
+    qWarning() << "Already generating media particle, ignoring request";
+    return;
+  }
+  if (!url.isValid())
+  {
+    emit errorOccurred("Invalid URL");
+    return;
+  }
+
+  assert(!mimeType.isEmpty() && "mimeType should never be empty here");
+  assert(!networkId.isEmpty() && "networkId should never be empty here");
+
+  QFile *file = new QFile{url.toLocalFile()};
+  assert(file->exists() && "File should exist at this point");
+  assert(file->size() > 0 && "File should have non-zero size at this point");
+
+  cleanup();
+  setGenerating(true);
+
+  m_uploadInfo = new UploadInfo{};
+  m_uploadInfo->networkId = networkId;
+  m_uploadInfo->streamId = streamId;
+  m_uploadInfo->mimeType = mimeType;
+  m_uploadInfo->durationMs = durationMs;
+  m_uploadInfo->file = file;
+  m_uploadInfo->bytes = file->size();
+
+  // 1. get presigned url
+  QJsonObject body;
+  body["network_id"] = m_uploadInfo->networkId;
+  body["name"] = url.fileName();
+  body["content_type"] = m_uploadInfo->mimeType;
+  body["content_length"] = m_uploadInfo->bytes;
+  QNetworkReply *reply = NetworkManager::instance().post("/depot/upload", QJsonDocument(body));
+  connect(reply, &QNetworkReply::finished, this, [this, reply]() {
+    reply->deleteLater();
+
+    if (reply->error() != QNetworkReply::NoError)
+    {
+      QByteArray body = reply->readAll();
+      QJsonDocument doc = QJsonDocument::fromJson(body);
+      QString message = doc.isObject() ? doc.object().value("message").toString() : QString();
+      if (message.isEmpty())
+      {
+        message = reply->errorString();
+      }
+      qWarning() << message;
+      cleanup();
+      emit errorOccurred("Failed to upload media");
+      return;
+    }
+
+    QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
+    onUploadUrlReceived(doc);
+  });
+}
+
+void MediaParticleGenerator::cleanup()
+{
+  if (m_uploadInfo)
+  {
+    if (m_uploadInfo->file)
+    {
+      m_uploadInfo->file->close();
+      delete m_uploadInfo->file;
+    }
+    delete m_uploadInfo;
+    m_uploadInfo = nullptr;
+  }
+
+  setGenerating(false);
+}
+
+void MediaParticleGenerator::onUploadUrlReceived(const QJsonDocument &response)
+{
+  QJsonObject obj = response.object();
+  m_uploadInfo->uploadUrl = obj["upload_url"].toString();
+  QJsonObject uploadHeaders = obj["upload_headers"].toObject();
+  m_uploadInfo->objectId = obj["object_id"].toString();
+
+  if (!m_uploadInfo->file->open(QIODevice::ReadOnly))
+  {
+    cleanup();
+    emit errorOccurred("Failed to open media file");
+    return;
+  }
+
+  QNetworkRequest request = QNetworkRequest(QUrl(m_uploadInfo->uploadUrl));
+  for (auto it = uploadHeaders.constBegin(); it != uploadHeaders.constEnd(); ++it)
+  {
+    request.setRawHeader(it.key().toUtf8(), it.value().toString().toUtf8());
+  }
+  QNetworkReply *reply = m_qnam->put(request, m_uploadInfo->file);
+  connect(reply, &QNetworkReply::finished, this, [this, reply]() {
+    reply->deleteLater();
+
+    if (reply->error() != QNetworkReply::NoError)
+    {
+      qWarning() << "Failed to upload media: " << reply->errorString();
+      cleanup();
+      emit errorOccurred("Failed to upload media");
+      return;
+    }
+
+    onUploadComplete();
+  });
+}
+
+void MediaParticleGenerator::setGenerating(bool generating)
+{
+  if (m_isGenerating != generating)
+  {
+    m_isGenerating = generating;
+    emit isGeneratingChanged();
+  }
+}
+
+void MediaParticleGenerator::onUploadComplete()
+{
+  auto op = m_store->createParticle(m_uploadInfo->streamId, "media", {
+    {"object_id", m_uploadInfo->objectId},
+    {"duration_ms", m_uploadInfo->durationMs},
+    {"mime_type", m_uploadInfo->mimeType}
+  });
+
+  connect(op, &Operation::success, this, &MediaParticleGenerator::complete);
+  connect(op, &Operation::success, this, &MediaParticleGenerator::cleanup);
+}