BackendlessQt/BackendlessUserAPI.hpp at main · RomanPodymov/BackendlessQt · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
//
//  BackendlessUserAPI.hpp
//  BackendlessQt
//
//  Created by Roman Podymov on 07/08/2024.
//  Copyright © 2024 BackendlessQt. All rights reserved.
//

#ifndef BACKENDLESS_USER_API_H
#define BACKENDLESS_USER_API_H

// #define BACKENDLESS_VARIANT_RESPONSE

#include <QString>
#include <QMap>
#include <QNetworkAccessManager>
#include <QJsonParseError>
#include "BackendlessUser.hpp"
#include "BasicAPI.hpp"

class AnyNetworkAccessManager;

class BackendlessSignInUserCoder: public Coder {
    Codable* decode(QJsonObject obj) override {
        return new BackendlessSignInUser(obj);
    }

    void write(QTextStream& stream, QSharedPointer<Codable> codable, QSharedPointer<Codable> defaultValue) override {
        auto userValue = (BackendlessSignInUser*)(defaultValue.get() ? defaultValue.get() : codable.get());
        stream << userValue->userToken << Qt::endl;
        stream << userValue->email << Qt::endl;
        stream << userValue->name << Qt::endl;
    }

    Codable* read(QTextStream& stream) override {
        auto result = new BackendlessSignInUser();
        stream >> result->userToken >> Qt::endl;
        stream >> result->email >> Qt::endl;
        stream >> result->name >> Qt::endl;
        return result;
    }
};

class BackendlessUserAPI: public QObject, public BasicAPI {
    Q_OBJECT

    friend class BackendlessQtTests;

public:
    BackendlessUserAPI(AnyNetworkAccessManager*, QSharedPointer<Coder> coder, QString _appId, QString _apiKey, QString _endpoint = "https://eu-api.backendless.com/");

    void registerUser(BackendlessRegisterUserRepresentable&);
    void signInUser(QString, QString);
    void validateUserToken();
    void restorePassword(QString);
    void logout();
    BackendlessSignInUser* user() const {
        return userValue.get();
    }

private:
    QString tokenFilePath();
    void readUserFromDisk();
    void saveUserOnDisk(QSharedPointer<BackendlessSignInUser> = QSharedPointer<BackendlessSignInUser>(nullptr));
    void removeUserFromDisk();

signals:
    void registerUserResult();

#ifdef BACKENDLESS_VARIANT_RESPONSE
    void signInUserResult(std::variant<BackendlessSignInUser, BackendlessError, QJsonParseError>);
#else
    void signInUserSuccess(BackendlessSignInUser*);
    void signInUserErrorBackendless(BackendlessError);
    void signInUserErrorJson(QJsonParseError);
#endif

#ifdef BACKENDLESS_VARIANT_RESPONSE
    void validateUserTokenResult(std::variant<bool, BackendlessValidateUserTokenError>);
#else
    void validateUserTokenSuccess(bool);
    void validateUserTokenError(BackendlessValidateUserTokenError);
#endif

    void restorePasswordSuccess(QString);
    void logoutSuccess();

private:
    AnyNetworkAccessManager* networkAccessManager;
    QSharedPointer<Coder> coder;
    QString appId;
    QString apiKey;
    QString endpoint;
    QSharedPointer<BackendlessSignInUser> userValue;
};

#endif