add files

src/DeleteRequest.cpp

@@ -0,0 +1,21 @@
+#include "DeleteRequest.h"
+#include <QNetworkRequest>
+
+namespace compilerExplorer {
+namespace network{
+DeleteRequest::DeleteRequest()
+	: GetRequest() {
+}
+
+std::unique_ptr<QNetworkReply> DeleteRequest::sendRequest(QNetworkAccessManager *manager) {
+	if(address().isEmpty() || !manager)
+		return nullptr;
+	auto request = generateRequest(manager);
+	return std::unique_ptr<QNetworkReply>(manager->deleteResource(request));
+}
+
+QString DeleteRequest::requestName() const {
+	return QObject::tr("DeleteRequest");
+}
+}
+}

src/DeleteRequest.h

@@ -0,0 +1,17 @@
+#ifndef DELETEREQUEST_H
+#define DELETEREQUEST_H
+#include "GetRequest.h"
+#include "compilerexplorer_global.h"
+
+namespace compilerExplorer {
+namespace network{
+class COMPILEREXPLORERSHARED_EXPORT DeleteRequest : public GetRequest
+{
+public:
+	DeleteRequest();
+	std::unique_ptr<QNetworkReply> sendRequest(QNetworkAccessManager *manager) override;
+	QString requestName() const override;
+};
+}
+}
+#endif // DELETEREQUEST_H

src/GetRequest.cpp

@@ -0,0 +1,63 @@
+#include "GetRequest.h"
+#include <QNetworkRequest>
+#include <QUrl>
+
+namespace compilerExplorer {
+namespace network{
+GetRequest::GetRequest()
+    : Request() {
+
+}
+
+std::unique_ptr<QNetworkReply> GetRequest::sendRequest(QNetworkAccessManager *manager) {
+	if(address().isEmpty() || !manager)
+		return nullptr;
+	auto request = generateRequest(manager);
+	return std::unique_ptr<QNetworkReply>(manager->get(request));
+}
+
+void GetRequest::addParameter(const QString &parameterName, const QString &parameterValue) {
+	mParams.insert({parameterName, parameterValue});
+}
+
+QString GetRequest::parametersString() const {
+	return parametersString(mParams);
+}
+
+QString GetRequest::parametersString(const std::map<QString, QString> &parameters) const {
+	QString result;
+	for(const auto &param : parameters) {
+		result.append(param.first);
+		result.append('=');
+		result.append(param.second);
+		result.append('&');
+	}
+	return result;
+}
+
+QNetworkRequest GetRequest::generateRequest(QNetworkAccessManager *manager) const {
+	QNetworkRequest request;
+	QUrl url(address());
+	if(address().startsWith("https")) {
+		manager->connectToHostEncrypted(address());
+	}
+
+	url.setQuery(parametersString());
+
+	QSslConfiguration sslConfiguration(QSslConfiguration::defaultConfiguration());
+	sslConfiguration.setProtocol(QSsl::SecureProtocols);
+	request.setSslConfiguration(sslConfiguration);
+	request.setUrl(url);
+	return request;
+}
+
+std::map<QString, QString> GetRequest::parameters() const {
+	return mParams;
+}
+
+QString GetRequest::requestName() const {
+	return QObject::tr("GetRequest");
+}
+
+}
+}

src/GetRequest.h

@@ -0,0 +1,27 @@
+#ifndef GETREQUEST_H
+#define GETREQUEST_H
+#include "Request.h"
+#include <QVariant>
+#include <map>
+#include "compilerexplorer_global.h"
+
+namespace compilerExplorer {
+namespace network{
+class COMPILEREXPLORERSHARED_EXPORT GetRequest : public Request
+{
+public:
+	GetRequest();
+	std::unique_ptr<QNetworkReply> sendRequest(QNetworkAccessManager *manager) override;
+	void addParameter(const QString &parameterName, const QString &parameterValue);
+	std::map<QString, QString> parameters() const;
+	QString requestName() const override;
+protected:
+	QString parametersString() const;
+	QString parametersString(const std::map<QString, QString> &parameters) const;
+	QNetworkRequest generateRequest(QNetworkAccessManager *manager) const;
+private:
+	std::map<QString, QString> mParams;
+};
+}
+}
+#endif // GETREQUEST_H

src/PostJsonRequest.cpp

@@ -0,0 +1,58 @@
+#include "PostJsonRequest.h"
+#include <QNetworkRequest>
+#include <QJsonDocument>
+
+namespace compilerExplorer {
+namespace network{
+
+PostJsonRequest::PostJsonRequest()
+    : GetRequest() {
+
+}
+
+std::unique_ptr<QNetworkReply> PostJsonRequest::sendRequest(QNetworkAccessManager *manager) {
+	if(address().isEmpty() || !manager)
+		return nullptr;
+	QNetworkRequest request;
+	QUrl url(address());
+	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+	request.setUrl(url);
+	return std::unique_ptr<QNetworkReply>(manager->post(request, QJsonDocument(jsonRequest()).toJson()));
+}
+
+QJsonObject PostJsonRequest::jsonRequest() const {
+	return jsonRequest(parameters());
+}
+
+QJsonObject PostJsonRequest::jsonRequest(const std::map<QString, QString> &parameters) const {
+	QJsonObject result;
+	for(const auto &param : parameters) {
+		result.insert(param.first, param.second);
+	}
+	if(!filters().isEmpty()) {
+		QJsonObject enabledFilters;
+		for(auto filter : filters()) {
+			enabledFilters.insert(filter, "true");
+		}
+		result.insert(mFiltersKey, enabledFilters);
+	}
+	return result;
+}
+
+QStringList PostJsonRequest::filters() const {
+	return mFilters;
+}
+
+void PostJsonRequest::setFilters(const QStringList &filters) {
+	mFilters = filters;
+}
+
+void PostJsonRequest::setFiltersKey(const QString &filtersKey) {
+	mFiltersKey = filtersKey;
+}
+
+QString PostJsonRequest::requestName() const {
+	return QObject::tr("PostJsonRequest");
+}
+}
+}

src/PostJsonRequest.h

@@ -0,0 +1,28 @@
+#ifndef POSTJSONREQUEST_H
+#define POSTJSONREQUEST_H
+#include "GetRequest.h"
+#include <QJsonObject>
+#include "compilerexplorer_global.h"
+
+namespace compilerExplorer {
+namespace network{
+
+class COMPILEREXPLORERSHARED_EXPORT PostJsonRequest : public GetRequest
+{
+public:
+	PostJsonRequest();
+	std::unique_ptr<QNetworkReply> sendRequest(QNetworkAccessManager *manager) override;
+	QStringList filters() const;
+	void setFilters(const QStringList &filters);
+	void setFiltersKey(const QString &filtersKey);
+	QString requestName() const override;
+protected:
+	QJsonObject jsonRequest() const;
+	QJsonObject jsonRequest(const std::map<QString, QString> &parameters) const;
+private:
+	QStringList mFilters;
+	QString mFiltersKey;
+};
+}
+}
+#endif // POSTJSONREQUEST_H

src/PutJsonRequest.cpp

@@ -0,0 +1,37 @@
+#include "PutJsonRequest.h"
+#include <QNetworkRequest>
+#include <QJsonDocument>
+
+namespace compilerExplorer {
+namespace network{
+PutJsonRequest::PutJsonRequest()
+	: PostJsonRequest() {
+
+}
+
+void PutJsonRequest::addGetParameter(const QString &parameterName, const QString &parameterValue) {
+	mGetParameters.insert({parameterName, parameterValue});
+}
+
+void PutJsonRequest::addPostParameter(const QString &parameterName, const QString &parameterValue) {
+	mPostParameters.insert({parameterName, parameterValue});
+}
+
+std::unique_ptr<QNetworkReply> PutJsonRequest::sendRequest(QNetworkAccessManager *manager) {
+	if(address().isEmpty() || !manager)
+		return nullptr;
+	QNetworkRequest request;
+	QUrl url(address());
+	url.setQuery(parametersString(mGetParameters));
+	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+	request.setUrl(url);
+	return std::unique_ptr<QNetworkReply>(manager->put(request, QJsonDocument(jsonRequest(mPostParameters)).toJson()));
+}
+
+QString PutJsonRequest::requestName() const {
+	return QObject::tr("PutJsonRequest");
+}
+}
+}
+
+

src/PutJsonRequest.h

@@ -0,0 +1,25 @@
+#ifndef PUTJSONREQUEST_H
+#define PUTJSONREQUEST_H
+#include "PostJsonRequest.h"
+#include <QJsonObject>
+#include "compilerexplorer_global.h"
+
+namespace compilerExplorer {
+namespace network{
+
+class COMPILEREXPLORERSHARED_EXPORT PutJsonRequest : public PostJsonRequest
+{
+public:
+	PutJsonRequest();
+	void addGetParameter(const QString &parameterName, const QString &parameterValue);
+	void addPostParameter(const QString &parameterName, const QString &parameterValue);
+	void addParameter(const QString &parameterName, const QString &parameterValue) = delete;
+	std::unique_ptr<QNetworkReply> sendRequest(QNetworkAccessManager *manager) override;
+	QString requestName() const override;
+private:
+	std::map<QString, QString> mGetParameters;
+	std::map<QString, QString> mPostParameters;
+};
+}
+}
+#endif // PUTJSONREQUEST_H

src/Request.cpp

@@ -0,0 +1,30 @@
+#include "Request.h"
+
+namespace compilerExplorer {
+namespace network{
+
+Request::Request()
+    : mPort(80) {
+}
+
+Request::~Request() {
+}
+
+QString Request::address() const {
+	return mAddress;
+}
+
+void Request::setAddress(const QString &address) {
+	mAddress = address;
+}
+
+int Request::port() const {
+	return mPort;
+}
+
+void Request::setPort(int port) {
+	mPort = port;
+}
+
+}
+}

src/Request.h

@@ -0,0 +1,31 @@
+#ifndef REQUEST_H
+#define REQUEST_H
+#include <QByteArray>
+#include <memory>
+#include <QString>
+#include <QNetworkReply>
+#include "compilerexplorer_global.h"
+
+class QNetworkRequest;
+class QNetworkAccessManager;
+namespace compilerExplorer {
+namespace network{
+class COMPILEREXPLORERSHARED_EXPORT Request
+{
+public:
+	Request();
+	virtual ~Request();
+	virtual std::unique_ptr<QNetworkReply> sendRequest(QNetworkAccessManager *manager) = 0;
+	virtual QString requestName() const = 0;
+	QString address() const;
+	void setAddress(const QString &address);
+	int port() const;
+	void setPort(int port);
+
+private:
+	QString mAddress;
+	int mPort;
+};
+}
+}
+#endif // REQUEST_H

src/RequestSender.cpp

@@ -0,0 +1,46 @@
+#include "RequestSender.h"
+#include "Request.h"
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QTimer>
+#include <QEventLoop>
+#include <QDebug>
+
+const int timeout = 15000;
+
+namespace compilerExplorer {
+namespace network{
+
+RequestSender::RequestSender(QObject *parent) :
+    QObject(parent),
+    mManager(new QNetworkAccessManager(this)) {
+
+}
+
+QByteArray RequestSender::sendRequest(const std::unique_ptr<Request> &request) const {
+	QTimer timer;
+	timer.setInterval(timeout);
+	timer.setSingleShot(true);
+	qInfo() << "Sending " << request->requestName();
+	QEventLoop loop;
+	auto reply = request->sendRequest(mManager);
+	if(!reply)
+		return {};
+	connect(reply.get(), &QNetworkReply::finished, &loop, &QEventLoop::quit);
+	connect(&timer, &QTimer::timeout, reply.get(), &QNetworkReply::abort);
+	timer.start();
+	loop.exec();
+
+	QByteArray result;
+	if (reply->isFinished() && reply->error() == QNetworkReply::NoError) {
+		result = reply->readAll();
+	}
+	else if(reply->error() != QNetworkReply::NoError) {
+		result.append("ERROR: ");
+		result.append(reply->errorString().toUtf8());
+	}
+	return result;
+}
+
+}
+}