Merge branch 'main' into feature/tests

Author: RomanPodymov

BackendlessAPI.cpp

@@ -22,27 +22,59 @@ BackendlessAPI::BackendlessAPI(QString _appId, QString _apiKey, QString _endpoin
 
 }
 
-void BackendlessAPI::addItemToTable(QString tableName, QMap<QString, QString> params) {
-    return request(
+void BackendlessAPI::addItemToTable(QString tableName, PostParams params) {
+    request(
         &networkAccessManager,
         this,
         endpoint + appId + "/" + apiKey + "/data/" + tableName,
-        params, true, [&](QNetworkReply* reply){
+        params,
+        BERequestMethod::post,
+        [&](QNetworkReply* reply){
             auto replyValue = reply->readAll();
             qDebug() << replyValue;
             emit itemAdded();
         }
     );
 }
 
+void BackendlessAPI::deleteItemFromTable(QString tableName, QString objectId) {
+    request(
+        &networkAccessManager,
+        this,
+        endpoint + appId + "/" + apiKey + "/data/" + tableName + "/" + objectId,
+        {
+
+        },
+        BERequestMethod::deleteResource,
+        [&](QNetworkReply* reply){
+            auto replyValue = reply->readAll();
+            qDebug() << replyValue;
+            extractResult<DeletionResult>(
+                replyValue,
+                [&](auto result) {
+                    emit deleteItemFromTableSuccess(result);
+                },
+                [&](auto beError) {
+                    emit deleteItemFromTableError(beError);
+                },
+                [&](auto jsonError) {
+
+                }
+            );
+        }
+    );
+}
+
 void BackendlessAPI::loadTableItems(QString tableName) {
-    return request(
+    request(
         &networkAccessManager,
         this,
         endpoint + appId + "/" + apiKey + "/data/" + tableName,
         {
 
-        }, false, [&](QNetworkReply* reply){
+        },
+        BERequestMethod::get,
+        [&](QNetworkReply* reply){
             auto replyValue = reply->readAll();
             qDebug() << replyValue;
 #ifdef BACKENDLESS_VARIANT_RESPONSE

BackendlessAPI.hpp

@@ -11,24 +11,34 @@
 
 #include <QString>
 #include <QMap>
+#include <QJsonObject>
 #include <QNetworkAccessManager>
 #include "BackendlessUserAPI.hpp"
 
+struct DeletionResult {
+    long deletionTime;
+
+    DeletionResult(QJsonObject jsonObject): deletionTime(jsonObject["deletionTime"].toInteger()) { }
+};
+
 class BackendlessAPI: public QObject, public BasicAPI {
     Q_OBJECT
 
 public:
     BackendlessAPI(QString _appId, QString _apiKey, QString _endpoint = "https://eu-api.backendless.com/");
-    void addItemToTable(QString, QMap<QString, QString>);
+    void addItemToTable(QString, PostParams);
+    void deleteItemFromTable(QString, QString);
     void loadTableItems(QString);
 
 signals:
     void itemAdded();
+    void deleteItemFromTableSuccess(DeletionResult);
+    void deleteItemFromTableError(BackendlessError);
 #ifdef BACKENDLESS_VARIANT_RESPONSE
 
 #else
     void loadTableItemsSuccess(QString);
-    void loadTableItemsError(BackendlessErrorCode);
+    void loadTableItemsError(BackendlessError);
 #endif
 
 public:

BackendlessUser.cpp

@@ -11,10 +11,15 @@
 BasicBackendlessRegisterUser::BasicBackendlessRegisterUser(
     QString _email,
     QString _password
-): email(_email), password(_password) {
+): email(new StringPostParam(_email)), password(new StringPostParam(_password)) {
 }
 
-QMap<QString, QString> BasicBackendlessRegisterUser::getAllParams() {
+BasicBackendlessRegisterUser::~BasicBackendlessRegisterUser() {
+    delete email;
+    delete password;
+}
+
+PostParams BasicBackendlessRegisterUser::getAllParams() {
     return {
         {"email", email},
         {"password", password}

BackendlessUser.hpp

@@ -9,12 +9,16 @@
 #ifndef BACKENDLESS_USER_H
 #define BACKENDLESS_USER_H
 
+#include <QJsonObject>
 #include <QMap>
 #include <QString>
+#include <QJsonParseError>
+#include "BasicAPI.hpp"
 
 class BackendlessRegisterUserRepresentable {
 public:
-    virtual QMap<QString, QString> getAllParams() = 0;
+    virtual ~BackendlessRegisterUserRepresentable() = default;
+    virtual PostParams getAllParams() = 0;
 };
 
 struct BasicBackendlessRegisterUser: BackendlessRegisterUserRepresentable {
@@ -23,20 +27,23 @@ struct BasicBackendlessRegisterUser: BackendlessRegisterUserRepresentable {
         QString _email,
         QString _password
     );
+    ~BasicBackendlessRegisterUser() override;
 
-    QMap<QString, QString> getAllParams() override;
+    PostParams getAllParams() override;
 
 protected:
-    QString email;
-    QString password;
+    StringPostParam* email;
+    StringPostParam* password;
 };
 
 struct BackendlessSignInUser {
     QString userToken;
 
     BackendlessSignInUser(
-        QString _userToken
-    ): userToken(_userToken) { }
+        QJsonObject jsonObject
+    ): userToken(jsonObject["user-token"].toString()) {
+
+    }
 };
 
 #endif

BackendlessUserAPI.cpp

@@ -12,23 +12,26 @@
 #include <QNetworkReply>
 #include <QJsonDocument>
 #include <QJsonObject>
+#include <QStandardPaths>
+#include <QFile>
 #include "BackendlessUserAPI.hpp"
 
 BackendlessUserAPI::BackendlessUserAPI(QNetworkAccessManager* _networkAccessManager, QString _appId, QString _apiKey, QString _endpoint): QObject(),
     networkAccessManager(_networkAccessManager),
     appId(_appId),
     apiKey(_apiKey),
     endpoint(_endpoint) {
-
+    readTokenFromDisk();
+    qDebug() << userTokenValue;
 }
 
 void BackendlessUserAPI::registerUser(BackendlessRegisterUserRepresentable& user) {
-    return request(
+    request(
         networkAccessManager,
         this,
         endpoint + appId + "/" + apiKey + "/users/register",
         user.getAllParams(),
-        true,
+        BERequestMethod::post,
         [&](QNetworkReply* reply){
             auto replyValue = reply->readAll();
             qDebug() << replyValue;
@@ -39,14 +42,16 @@ void BackendlessUserAPI::registerUser(BackendlessRegisterUserRepresentable& user
 }
 
 void BackendlessUserAPI::signInUser(QString login, QString password) {
-    return request(
+    request(
         networkAccessManager,
         this,
         endpoint + appId + "/" + apiKey + "/users/login",
         {
-            {"login", login},
-            {"password", password}
-        }, true, [&](QNetworkReply* reply){
+            {"login", new StringPostParam(login)},
+            {"password", new StringPostParam(password)}
+        },
+        BERequestMethod::post,
+        [&](QNetworkReply* reply){
             auto replyValue = reply->readAll();
             qDebug() << replyValue;
 
@@ -67,6 +72,8 @@ void BackendlessUserAPI::signInUser(QString login, QString password) {
             extractResult<BackendlessSignInUser>(
                 replyValue,
                 [&](auto user) {
+                    userTokenValue = user.userToken;
+                    saveTokenOnDisk();
                     emit signInUserSuccess(user);
                 },
                 [&](auto beError) {
@@ -81,14 +88,39 @@ void BackendlessUserAPI::signInUser(QString login, QString password) {
     );
 }
 
+QString BackendlessUserAPI::tokenFilePath() {
+    auto path = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
+    return path + "/backendless_token.txt";
+}
+
+void BackendlessUserAPI::readTokenFromDisk() {
+    QFile file(tokenFilePath());
+    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        QTextStream stream(&file);
+        stream >> userTokenValue;
+    }
+    file.close();
+}
+
+void BackendlessUserAPI::saveTokenOnDisk() {
+    QFile file(tokenFilePath());
+    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        QTextStream stream(&file);
+        stream << userTokenValue;
+    }
+    file.close();
+}
+
 void BackendlessUserAPI::validateUserToken() {
-    return request(
+    request(
         networkAccessManager,
         this,
-        endpoint + appId + "/" + apiKey + "/users/isvalidusertoken/" + userToken,
+        endpoint + appId + "/" + apiKey + "/users/isvalidusertoken/" + userTokenValue,
         {
 
-        }, false, [&](QNetworkReply* reply){
+        },
+        BERequestMethod::get,
+        [&](QNetworkReply* reply){
             auto replyValue = reply->readAll();
             qDebug() << replyValue;
 
@@ -114,17 +146,23 @@ void BackendlessUserAPI::validateUserToken() {
 }
 
 void BackendlessUserAPI::restorePassword(QString email) {
-    return request(
+    request(
         networkAccessManager,
         this,
         endpoint + appId + "/" + apiKey + "/users/restorepassword/" + email,
         {
 
-        }, false, [&](QNetworkReply* reply){
+        },
+        BERequestMethod::get,
+        [&](QNetworkReply* reply){
             auto replyValue = reply->readAll();
             qDebug() << replyValue;
 
             emit restorePasswordSuccess(replyValue);
         }
     );
 }
+
+QString BackendlessUserAPI::userToken() {
+    return userTokenValue;
+}

BackendlessUserAPI.hpp

@@ -28,6 +28,12 @@ class BackendlessUserAPI: public QObject, public BasicAPI {
     void signInUser(QString, QString);
     void validateUserToken();
     void restorePassword(QString);
+    QString userToken();
+
+private:
+    QString tokenFilePath();
+    void readTokenFromDisk();
+    void saveTokenOnDisk();
 
 signals:
     void registerUserResult();
@@ -54,7 +60,7 @@ class BackendlessUserAPI: public QObject, public BasicAPI {
     QString appId;
     QString apiKey;
     QString endpoint;
-    QString userToken;
+    QString userTokenValue;
 };
 
 #endif

BasicAPI.cpp

@@ -18,8 +18,8 @@ void BasicAPI::request(
     QNetworkAccessManager* networkAccessManager,
     const QObject* context,
     QString urlString,
-    QMap<QString, QString> customParams,
-    bool isPost,
+    PostParams customParams,
+    BERequestMethod method,
     std::function<void(QNetworkReply*)> const& handleRequest
 ) {
     QUrl url(urlString);
@@ -34,9 +34,7 @@ void BasicAPI::request(
         params += key;
         params += "\"";
         params += ":";
-        params += "\"";
-        params += value;
-        params += "\"";
+        params += value->asParam();
         params += ",";
     }
 
@@ -46,10 +44,19 @@ void BasicAPI::request(
     QObject::connect(networkAccessManager, &QNetworkAccessManager::finished, context, [handleRequest](QNetworkReply* reply) {
         handleRequest(reply);
     }, Qt::SingleShotConnection);
-    if (isPost) {
-        networkAccessManager->post(request, params.toUtf8());
-    } else {
+    switch (method) {
+    case BERequestMethod::get:
         networkAccessManager->get(request);
+        break;
+    case BERequestMethod::post:
+        networkAccessManager->post(request, params.toUtf8());
+        break;
+    case BERequestMethod::deleteResource:
+        networkAccessManager->deleteResource(request);
+        break;
+    case BERequestMethod::put:
+        networkAccessManager->put(request, params.toUtf8());
+        break;
     }
 }