POST int values (#13)

Author: RomanPodymov

BackendlessAPI.cpp

@@ -22,7 +22,7 @@ BackendlessAPI::BackendlessAPI(QString _appId, QString _apiKey, QString _endpoin
 
 }
 
-void BackendlessAPI::addItemToTable(QString tableName, QMap<QString, QString> params) {
+void BackendlessAPI::addItemToTable(QString tableName, PostParams params) {
     request(
         &networkAccessManager,
         this,

BackendlessAPI.hpp

@@ -26,7 +26,7 @@ class BackendlessAPI: public QObject, public BasicAPI {
 
 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);
 

BackendlessUser.cpp

@@ -14,9 +14,9 @@ BasicBackendlessRegisterUser::BasicBackendlessRegisterUser(
 ): email(_email), password(_password) {
 }
 
-QMap<QString, QString> BasicBackendlessRegisterUser::getAllParams() {
+PostParams BasicBackendlessRegisterUser::getAllParams() {
     return {
-        {"email", email},
-        {"password", password}
+        {"email", new StringPostParam(email)},
+        {"password", new StringPostParam(password)}
     };
 }

BackendlessUser.hpp

@@ -12,11 +12,13 @@
 #include <QJsonObject>
 #include <QMap>
 #include <QString>
+#include <QJsonParseError>
+#include "BasicAPI.hpp"
 
 class BackendlessRegisterUserRepresentable {
 public:
     virtual ~BackendlessRegisterUserRepresentable() = default;
-    virtual QMap<QString, QString> getAllParams() = 0;
+    virtual PostParams getAllParams() = 0;
 };
 
 struct BasicBackendlessRegisterUser: BackendlessRegisterUserRepresentable {
@@ -26,7 +28,7 @@ struct BasicBackendlessRegisterUser: BackendlessRegisterUserRepresentable {
         QString _password
     );
 
-    QMap<QString, QString> getAllParams() override;
+    PostParams getAllParams() override;
 
 protected:
     QString email;

BackendlessUserAPI.cpp

@@ -12,14 +12,17 @@
 #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() << userToken;
 }
 
 void BackendlessUserAPI::registerUser(BackendlessRegisterUserRepresentable& user) {
@@ -44,8 +47,8 @@ void BackendlessUserAPI::signInUser(QString login, QString password) {
         this,
         endpoint + appId + "/" + apiKey + "/users/login",
         {
-            {"login", login},
-            {"password", password}
+            {"login", new StringPostParam(login)},
+            {"password", new StringPostParam(password)}
         },
         BERequestMethod::post,
         [&](QNetworkReply* reply){
@@ -69,6 +72,8 @@ void BackendlessUserAPI::signInUser(QString login, QString password) {
             extractResult<BackendlessSignInUser>(
                 replyValue,
                 [&](auto user) {
+                    userToken = user.userToken;
+                    saveTokenOnDisk();
                     emit signInUserSuccess(user);
                 },
                 [&](auto beError) {
@@ -83,6 +88,28 @@ void BackendlessUserAPI::signInUser(QString login, QString password) {
     );
 }
 
+void BackendlessUserAPI::readTokenFromDisk() {
+    auto path = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
+    auto fileName = path + "/backendless_token.txt";
+    QFile file(fileName);
+    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        QTextStream stream(&file);
+        stream >> userToken;
+    }
+    file.close();
+}
+
+void BackendlessUserAPI::saveTokenOnDisk() {
+    auto path = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation);
+    auto fileName = path + "/backendless_token.txt";
+    QFile file(fileName);
+    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        QTextStream stream(&file);
+        stream << userToken;
+    }
+    file.close();
+}
+
 void BackendlessUserAPI::validateUserToken() {
     request(
         networkAccessManager,

BackendlessUserAPI.hpp

@@ -29,6 +29,10 @@ class BackendlessUserAPI: public QObject, public BasicAPI {
     void validateUserToken();
     void restorePassword(QString);
 
+private:
+    void readTokenFromDisk();
+    void saveTokenOnDisk();
+
 signals:
     void registerUserResult();
 

BasicAPI.cpp

@@ -18,7 +18,7 @@ void BasicAPI::request(
     QNetworkAccessManager* networkAccessManager,
     const QObject* context,
     QString urlString,
-    QMap<QString, QString> customParams,
+    PostParams customParams,
     BERequestMethod method,
     std::function<void(QNetworkReply*)> const& handleRequest
 ) {
@@ -34,9 +34,7 @@ void BasicAPI::request(
         params += key;
         params += "\"";
         params += ":";
-        params += "\"";
-        params += value;
-        params += "\"";
+        params += value->asParam();
         params += ",";
     }
 

BasicAPI.hpp

@@ -14,6 +14,38 @@
 #include <QNetworkAccessManager>
 #include <QJsonObject>
 
+class PostParam {
+public:
+    virtual ~PostParam() = default;
+    virtual QString asParam() = 0;
+};
+
+typedef QMap<QString, PostParam*> PostParams;
+
+class StringPostParam: public PostParam {
+public:
+    StringPostParam(QString _value): value(_value) { }
+
+    QString asParam() override {
+        return "\"" + value + "\"";
+    }
+
+private:
+    QString value;
+};
+
+class IntPostParam: public PostParam {
+public:
+    IntPostParam(int _value): value(_value) { }
+
+    QString asParam() override {
+        return QString::number(value);
+    }
+
+private:
+    int value;
+};
+
 enum class BackendlessErrorCode {
     noError = 0,
     entityNotFound = 1000,
@@ -84,7 +116,7 @@ class BasicAPI {
         QNetworkAccessManager*,
         const QObject*,
         QString,
-        QMap<QString, QString>,
+        PostParams,
         BERequestMethod,
         std::function<void(QNetworkReply*)> const&
     );