Page MenuHomePhorge
Files F85833032

No OneTemporary
Actions

Authored By
Unknown
Size
10 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/src/kazv-io-manager.cpp b/src/kazv-io-manager.cpp
index 5c627b8..2ebeb66 100644
--- a/src/kazv-io-manager.cpp
+++ b/src/kazv-io-manager.cpp
@@ -1,107 +1,123 @@
/*
* This file is part of kazv.
* SPDX-FileCopyrightText: 2022 nannanko <nannanko@kazv.moe>
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
#include "kazv-io-manager.hpp"
#include <api/csapi/content-repo.hpp>
#include <file-desc.hpp>
#include <QObject>
#include <QVector>
#include <KIO/TransferJob>
#include <QSaveFile>
#include <QPointer>
#include <QUrl>
#include <QIODevice>
#include <QSharedPointer>
#include <QMultiMap>
#include <algorithm>
#include <execution>
#include <string>
struct KazvIODownloadJob {
QPointer<KIO::TransferJob> job;
QSharedPointer<QSaveFile> file;
};
struct KazvIOUploadJob {
QPointer<KIO::TransferJob> job;
QSharedPointer<QFile> file;
+ QString response;
};
bool operator==(const KazvIOUploadJob &lhs, const KazvIOUploadJob &rhs) {
if ((lhs.job == rhs.job) && (lhs.file == rhs.file)) {
return true;
}
return false;
}
struct KazvIOManagerPrivate {
QMap<QString, KazvIODownloadJob> downloadJobs;
QMultiMap<QString, KazvIOUploadJob> uploadJobs;
};
KazvIOManager::KazvIOManager(QObject *parent)
: QObject(parent)
, m_d(new KazvIOManagerPrivate)
{
}
KazvIOManager::~KazvIOManager() = default;
QPointer<KIO::TransferJob> KazvIOManager::startNewDownloadJob(const QUrl &serverUrl, const QString &localFileName, const QString &jobId)
{
KazvIODownloadJob job;
job.job = KIO::get(serverUrl);
job.file = QSharedPointer<QSaveFile>(new QSaveFile(localFileName));
job.file->open(QIODevice::WriteOnly);
connect(job.job, &KIO::TransferJob::data, this, [job](KJob* /*job*/, const QByteArray data) {
job.file->write(data);
});
connect(job.job, &KJob::result, this, [this, jobId](KJob* /*job*/) {
m_d->downloadJobs[jobId].file->commit();
m_d->downloadJobs.remove(jobId);
});
m_d->downloadJobs[jobId] = job;
return m_d->downloadJobs[jobId].job;
}
QPointer<KIO::TransferJob> KazvIOManager::startNewUploadJob(const QUrl &serverUrl, const QString &localFileName, const QString &token, const QString &jobId)
{
auto kazvUploadJob = Kazv::Api::UploadContentJob(serverUrl.toString().toStdString(), token.toStdString(), Kazv::FileDesc(std::string()));
- qDebug() << QString(kazvUploadJob.url().data());
KazvIOUploadJob job;
job.file = QSharedPointer<QFile>(new QFile(localFileName));
job.file->open(QIODevice::ReadOnly);
job.job = KIO::http_post(QString(kazvUploadJob.url().data()), job.file.data());
- qDebug() << serverUrl;
- job.job->addMetaData("customHTTPHeader", QString("Authorization: ").append(QString("Bearer ")).append(token));
- // header->at("Authorization")
- // Content_Type
- // Response{...}
+ job.job->addMetaData(QString("content-type") , QMimeDatabase().mimeTypeForFile(localFileName).name());
+ job.job->addMetaData("customHTTPHeader", QString("Authorization: ").append(kazvUploadJob.requestHeader()->at("Authorization").data()));
job.job->addMetaData("PropagateHttpHeader", "true");
- qDebug() << QString("Authorization: ").append(token);
- connect(job.job, &KJob::result, this, [this, jobId, job](KJob* /*job*/) {
- auto it = m_d->uploadJobs.find(jobId, job);
+ auto it = m_d->uploadJobs.insert(jobId, job);
+ connect(job.job, &KIO::TransferJob::data, this, [it](KJob* /*job*/, const QByteArray &data) {
+ it.value().response.append(data);
+ });
+ connect(job.job, &KJob::result, this, [it](KJob* /*job*/) {
it.value().file->close();
- m_d->uploadJobs.remove(jobId, job);
});
- m_d->uploadJobs.insert(jobId, job);
return job.job;
}
KIO::TransferJob *KazvIOManager::getDownloadJob(const QString &jobId)
{
auto targetJob = m_d->downloadJobs.find(jobId);
if (targetJob == m_d->downloadJobs.end()) {
return nullptr;
}
return targetJob.value().job;
}
+
+QString KazvIOManager::getUploadJobResponse(const QString &jobId, QPointer<KIO::TransferJob> job)
+{
+ auto it = std::find_if(
+ m_d->uploadJobs.values(jobId).begin(),
+ m_d->uploadJobs.values(jobId).end(),
+ [job](auto it) {
+ return it.job == job;
+ });
+ if (it == m_d->uploadJobs.values(jobId).end()) {
+ return QString();
+ }
+ auto res = it->response;
+ // Although it can pass complie,
+ // Sometime application will be crash, I guess I should not use job after the result signal emitted.
+ // I need a better way pass response from manager to kazv-io
+ m_d->uploadJobs.remove(jobId, *it);
+ return res;
+}
diff --git a/src/kazv-io-manager.hpp b/src/kazv-io-manager.hpp
index 09c569a..2bb5eec 100644
--- a/src/kazv-io-manager.hpp
+++ b/src/kazv-io-manager.hpp
@@ -1,32 +1,33 @@
/*
* This file is part of kazv.
* SPDX-FileCopyrightText: 2022 nannanko <nannanko@kazv.moe>
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
#pragma once
#include <QObject>
#include <QtQml>
#include <QUrl>
#include <QString>
#include <KIO/TransferJob>
#include <QPointer>
#include <memory>
struct KazvIOManagerPrivate;
class KazvIOManager : public QObject {
Q_OBJECT
QML_ELEMENT
std::unique_ptr<KazvIOManagerPrivate> m_d;
public:
explicit KazvIOManager(QObject *parent = 0);
~KazvIOManager() override;
QPointer<KIO::TransferJob> startNewDownloadJob(const QUrl &serverUrl, const QString &localFileName, const QString &jobId);
QPointer<KIO::TransferJob> startNewUploadJob(const QUrl &serverUrl, const QString &localFileName, const QString &token, const QString &jobId);
Q_INVOKABLE KIO::TransferJob *getDownloadJob(const QString &jobId);
+ QString getUploadJobResponse(const QString &jobId, QPointer<KIO::TransferJob> job);
};
diff --git a/src/kazv-io.cpp b/src/kazv-io.cpp
index 3cd17a7..2498d0e 100644
--- a/src/kazv-io.cpp
+++ b/src/kazv-io.cpp
@@ -1,224 +1,223 @@
/*
* This file is part of kazv.
* SPDX-FileCopyrightText: 2022 nannanko <nannanko@kazv.moe>
* SPDX-License-Identifier: AGPL-3.0-or-later
*/
#include "kazv-io.hpp"
#include "kazv-io-manager.hpp"
#include <QUrl>
#include <QObject>
struct KazvIOPrivate {
QPointer<KazvIOManager> manager;
QString roomId;
QString eventId;
QUrl localFileUrl;
QString serverUrl;
QString token;
QString mxcUri;
float progress;
QPointer<KIO::TransferJob> job;
};
KazvIO::KazvIO(QObject *parent)
: QObject(parent)
, m_d(new KazvIOPrivate)
{
connect(this, &KazvIO::jobChanged, this, &KazvIO::checkJob);
connect(this, &KazvIO::success, this, &KazvIO::result);
connect(this, &KazvIO::failure, this, &KazvIO::result);
connect(this, &KazvIO::result, this, &KazvIO::clearPercent);
}
KazvIO::~KazvIO() = default;
void KazvIO::connectJob(QPointer<KJob> job)
{
connect(job, &KJob::percentChanged, this, &KazvIO::updateProgress);
connect(job, &KJob::result, this, &KazvIO::checkResult);
}
/*
* This function is only applicable to a single thread,
* if the manager is located in other threads, please modify this function appropriately
*/
void KazvIO::download()
{
m_d->job = m_d->manager->startNewDownloadJob(m_d->serverUrl, m_d->localFileUrl.path(), m_d->eventId);
connectJob(qobject_cast<KJob *>(m_d->job));
m_d->job->start();
}
/*
* This function is only applicable to a single thread,
* if the manager is located in other threads, please modify this function appropriately
*/
void KazvIO::upload()
{
m_d->job = m_d->manager->startNewUploadJob(m_d->serverUrl, m_d->localFileUrl.path(), m_d->token, m_d->roomId);
connectJob(qobject_cast<KJob *>(m_d->job));
connect(m_d->job, &KJob::result, this, &KazvIO::setMxcUri);
m_d->job->start();
}
/*
* This function is only applicable to a single thread,
* if the manager is located in other threads, please modify this function appropriately
*/
void KazvIO::suspend()
{
m_d->job->suspend();
}
/*
* This function is only applicable to a single thread,
* if the manager is located in other threads, please modify this function appropriately
*/
void KazvIO::resume()
{
m_d->job->resume();
}
/*
* This function is only applicable to a single thread,
* if the manager is located in other threads, please modify this function appropriately
*/
void KazvIO::cancel()
{
m_d->job->kill();
Q_EMIT failure();
}
void KazvIO::checkJob()
{
if (!m_d->job.isNull()) {
updateProgress(m_d->job, m_d->job->percent());
Q_EMIT processing();
if (m_d->job->isSuspended()) {
Q_EMIT suspended();
}
connectJob(qobject_cast<KJob *>(m_d->job));
}
}
KazvIOManager *KazvIO::manager()
{
return m_d->manager;
}
void KazvIO::setManager(KazvIOManager *manager)
{
m_d->manager = manager;
Q_EMIT managerChanged();
}
QString KazvIO::roomId()
{
return m_d->roomId;
}
void KazvIO::setRoomId(QString roomId)
{
m_d->roomId = roomId;
Q_EMIT roomIdChanged();
}
QString KazvIO::eventId()
{
return m_d->eventId;
}
void KazvIO::setEventId(QString eventId)
{
m_d->eventId = eventId;
Q_EMIT eventIdChanged();
}
QUrl KazvIO::localFileUrl()
{
return m_d->localFileUrl;
}
void KazvIO::setLocalFileUrl(QUrl localFileUrl)
{
m_d->localFileUrl = localFileUrl;
Q_EMIT localFileUrlChanged();
}
QString KazvIO::serverUrl()
{
return m_d->serverUrl;
}
void KazvIO::setServerUrl(QString serverUrl)
{
m_d->serverUrl = serverUrl;
Q_EMIT serverUrlChanged();
}
QString KazvIO::mxcUri()
{
return m_d->mxcUri;
}
float KazvIO::progress()
{
return m_d->progress;
}
void KazvIO::updateProgress(KJob * /* job */, unsigned long percent)
{
m_d->progress = 1.0 * percent / 100;
Q_EMIT progressChanged();
}
void KazvIO::checkResult(KJob *job)
{
if (job->error()) {
Q_EMIT failure();
} else {
Q_EMIT success();
}
}
void KazvIO::clearPercent()
{
m_d->progress = 0;
Q_EMIT progressChanged();
}
void KazvIO::setMxcUri(KJob *job)
{
- // Response{...}
+ // Response{...}
/* TODO: get the mxcUri from the response, which requires me to understand how to get the response */
if (job->error()) {
qDebug() << job->errorText();
return;
}
- auto header = qobject_cast<KIO::Job *>(job)->queryMetaData("HTTP-Headers");
- qDebug() << "Upload Completed";
- qDebug() << header;
+ auto res = m_d->manager->getUploadJobResponse(m_d->roomId, m_d->job);
+ qDebug() << res;
}
KIO::TransferJob *KazvIO::job()
{
return m_d->job;
}
void KazvIO::setJob(KIO::TransferJob *job)
{
m_d->job = job;
Q_EMIT jobChanged();
}
QString KazvIO::token()
{
return m_d->token;
}
void KazvIO::setToken(QString token)
{
m_d->token = token;
Q_EMIT tokenChanged();
}

File Metadata

Mime Type
text/x-diff
Expires
Mon, Nov 2, 9:46 AM (2 h, 55 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
1804293
Default Alt Text
(10 KB)

Event Timeline