class session : public QObject {
		Q_OBJECT
	public:
		session(void);

		response get(QUrl url, QUrlQuery query = QUrlQuery(),
					 std::map<QString, QVariant> headers = std::map<QString, QVariant>(), uint timeout_sec = 60);
		response post(QUrl url, JSON json = JSON(), std::map<QString, QVariant> headers = std::map<QString, QVariant>(),
					  uint timeout_sec = 60);
		response post(QUrl url, QUrlQuery data = QUrlQuery(),
					  std::map<QString, QVariant> headers = std::map<QString, QVariant>(), uint timeout_sec = 60);

	signals:
		void request_start_signal(void);

	public slots:
		void request_process_slot(void);

	private:
		QNetworkAccessManager manager;
		QByteArray request_data;
		MethodsEnum request_method;
		bool is_finished = true;
		bool is_running = false;
		QNetworkRequest* request = nullptr;
		QNetworkReply* reply = nullptr;

		response wait_for_reply(uint timeout_sec);
	};

.cpp

session::session(void) { connect(this, &session::request_start_signal, this, &session::request_process_slot); }

	void session::request_process_slot(void) {
		qDebug() << "request slot";
		this->is_running = true;
		switch (request_method) {
			case GET: this->reply = this->manager.get(*this->request); break;
			case POST: this->reply = this->manager.post(*this->request, this->request_data); break;
			default: break;
		}
		QEventLoop loop;
		connect(this->reply, &QNetworkReply::readyRead, &loop, &QEventLoop::quit);
		loop.exec();
		qDebug() << "request slot finished";
		this->is_finished = true;
		this->is_running = false;
	}

	response session::wait_for_reply(uint timeout_sec) {
		uint64_t start_time = QDateTime::currentMSecsSinceEpoch();
		while (!this->is_finished) { // just do blocking request is fine for this project's case
			qDebug() << "waiting for reply" << (QDateTime::currentMSecsSinceEpoch() - start_time) / 1000;
			if (timeout_sec > 0 && QDateTime::currentMSecsSinceEpoch() - start_time > timeout_sec * 1000) {
				qDebug() << "request timeout";
				this->is_finished = true;
				this->reply->disconnect();
				delete this->reply;
				return response();
			}
			QThread::msleep(100);
		}
		response res = response(this->request, this->reply);
		this->reply->disconnect();
		delete this->request;
		this->request = nullptr;
		delete this->reply;
		this->reply = nullptr;
		return res;
	}

	response session::get(QUrl url, QUrlQuery query, std::map<QString, QVariant> headers, uint timeout_sec) {
		qDebug() << "GET";
		while (!this->is_finished) {
			qDebug() << "waiting for prev request to finish";
			QThread::msleep(100);
		}
		url.setQuery(query.query());
		if (this->request != nullptr) {
			delete this->request;
		}
		this->request = new QNetworkRequest(url);
		qDebug() << 3;
		for (const auto& [key, value] : headers) {
			this->request->setRawHeader(key.toUtf8(), value.toByteArray());
		}
		this->request_method = GET;
		this->is_finished = false;
		emit this->request_start_signal();
		return this->wait_for_reply(timeout_sec);
	}