fixes on client

HanoiTowers/Protockol/src/userdatarequest.cpp

@@ -0,0 +1,15 @@
+#include "userdatarequest.h"
+
+UserDataRequest::UserDataRequest()
+{
+
+}
+
+UserDataRequest::UserDataRequest(const QH::Package &package):
+    UserData(package) {
+
+}
+
+unsigned char UserDataRequest::getRequestCmd() const {
+    return Request::Get;
+}

HanoiTowers/Protockol/src/userdatarequest.h

@@ -0,0 +1,24 @@
+#ifndef USERDATAREQUEST_H
+#define USERDATAREQUEST_H
+
+#include "userdata.h"
+
+#include <request.h>
+
+class HANOITOWERSPROTOCOL_EXPORT UserDataRequest: public UserData, public QH::Request
+{
+public:
+
+    enum Request {
+        Get = 0
+    };
+
+    UserDataRequest();
+    UserDataRequest(const QH::Package& package);
+
+    // Request interface
+public:
+    unsigned char getRequestCmd() const override;
+};
+
+#endif // USERDATAREQUEST_H

HanoiTowers/Server/hanoiserver.cpp

@@ -10,7 +10,8 @@
 #include <QNetworkInterface>
 #include <QCoreApplication>
 #include <userdata.h>
-#include <user.h>
+#include <usermember.h>
+#include <userdatarequest.h>
 #include "config.h"
 
 HanoiServer::HanoiServer() {
@@ -56,6 +57,12 @@ QH::ParserResult HanoiServer::parsePackage(const QH::Package &pkg,
             return QH::ParserResult::Error;
         }
 
+        return QH::ParserResult::Processed;
+
+    } else if (H_16<UserDataRequest>() == pkg.hdr.command) {
+        UserDataRequest obj(pkg);
+
+
         return QH::ParserResult::Processed;
 
     }
@@ -70,3 +77,16 @@ QStringList HanoiServer::SQLSources() const {
 QVariantMap HanoiServer::defaultDbParams() const {
     return QH::DataBaseNode::defaultDbParams();
 }
+
+bool HanoiServer::workWirthUserData(const UserData *obj,
+                                    const QH::AbstractNodeInfo *sender) {
+
+    QH::BaseId requesterId = getSender(sender, obj);
+    const DBObject *userData;
+
+    if (getObject(requesterId, *obj, &userData) != QH::DBOperationResult::Allowed) {
+        return false;
+    }
+
+    return sendData(userData, sender->networkAddress());
+}

HanoiTowers/Server/hanoiserver.h

@@ -7,6 +7,8 @@
 #include <quasarapp.h>
 #include <singleserver.h>
 
+class UserData;
+
 class HanoiServer : public QH::SingleServer
 {
     Q_OBJECT
@@ -20,8 +22,9 @@ protected:
 
     QVariantMap defaultDbParams() const override;
 
-    // DataBaseNode interface
-protected:
+private:
+    bool workWirthUserData(const UserData *obj,
+                           const QH::AbstractNodeInfo *sender);
 };
 
 #endif // SNAKESERVER_H

HanoiTowers/client/hanoiclient.cpp

@@ -7,10 +7,12 @@
 
 #include "hanoiclient.h"
 #include <qmlnotifyservice.h>
-#include <user.h>
+#include <usermember.h>
 #include <userdata.h>
 #include <sqldbcache.h>
 #include <localuser.h>
+#include <authrequest.h>
+#include <userdatarequest.h>
 
 HanoiClient::HanoiClient() {
     initSqlDb("", new QH::SqlDBCache(DEFAULT_UPDATE_INTERVAL, QH::SqlDBCasheWriteMode::Force));
@@ -35,8 +37,8 @@ QH::ParserResult HanoiClient::parsePackage(const QH::Package &pkg,
 
         return QH::ParserResult::Processed;
 
-    } else if (H_16<QH::PKG::User>() == pkg.hdr.command) {
-        QH::PKG::User obj(pkg);
+    } else if (H_16<QH::PKG::UserMember>() == pkg.hdr.command) {
+        QH::PKG::UserMember obj(pkg);
 
         auto localuser = db()->getObject(obj)->cloneRaw();
         localuser->copyFrom(&obj);
@@ -62,20 +64,32 @@ void HanoiClient::handleError(const QString &error) {
                 QmlNotificationService::NotificationData::Error);
 }
 
-const LocalUser *HanoiClient::getUser(const QString& userId) const {
-    LocalUser request;
+bool HanoiClient::login(const QString& userId) {
+    QH::PKG::AuthRequest request;
     request.setId(userId);
+    request.setRequest(QH::PKG::UserRequestType::Login);
 
-    if (!db()) {
-        return nullptr;
-    }
-
-    return db()->getObject(request);
+    return sendData(&request, _serverAddress);
 }
 
-const UserData *HanoiClient::getUserData(const QString &userId) const {
-    UserData request;
-    request.setName(userId);
+bool HanoiClient::signIn(const QString &userId) {
+    QH::PKG::AuthRequest request;
+    request.setId(userId);
+    request.setRequest(QH::PKG::UserRequestType::SignIn);
+
+    return sendData(&request, _serverAddress);
+}
+
+bool HanoiClient::userDatarequest(const QString &userId) {
+    UserDataRequest request;
+    request.setId(userId);
+
+    return sendData(&request, _serverAddress);
+}
+
+const LocalUser *HanoiClient::getLocalUser(const QString &userId) const {
+    LocalUser request;
+    request.setId(userId);
 
     if (!db()) {
         return nullptr;
@@ -98,7 +112,7 @@ void HanoiClient::setCurrentUserName(const QString &currentUserName) {
 
 ProfileData HanoiClient::currentProfile() {
 
-    auto userData = getUserData(_currentUserName);
+    auto userData = getLocalUser(_currentUserName);
 
     if (userData)
         return userData->userData();

HanoiTowers/client/hanoiclient.h

@@ -20,6 +20,12 @@
 class LocalUser;
 class UserData;
 
+namespace QH {
+namespace PKG {
+class UserMember;
+}
+}
+
 enum class Status {
     OfflineUser,
     Dissconnected,
@@ -51,13 +57,19 @@ private slots:
 
 private:
 
-    const LocalUser *getUser(const QString &userId) const;
-    const UserData *getUserData(const QString &userId) const;
-    defaultProfile();
+    bool login(const QString &userId);
+    bool signIn(const QString &userId);
+
+    bool userDatarequest(const QString &userId);
+    const LocalUser *getLocalUser(const QString &userId) const;
+
+
+    ProfileData defaultProfile() const;
 
     Status _status;
     QString _currentUserName;
     QH::HostAddress _serverAddress;
+    QList<LocalUser*> _usersList;
 
 
 };

HanoiTowers/client/localuser.cpp

@@ -2,12 +2,15 @@
 #include <accesstoken.h>
 
 using MT = QH::PKG::MemberType;
-LocalUser::LocalUser() {
+
+LocalUser::LocalUser():
+    QH::PKG::DBObject("Users"),
+    _userData("") {
 
 }
 
 bool LocalUser::copyFrom(const QH::PKG::AbstractData *other) {
-    if (!QH::PKG::User::copyFrom(other))
+    if (!QH::PKG::DBObject::copyFrom(other))
         return false;
 
     auto otherObject = dynamic_cast<const LocalUser*>(other);
@@ -15,6 +18,9 @@ bool LocalUser::copyFrom(const QH::PKG::AbstractData *other) {
         return false;
 
     this->_online = otherObject->_online;
+    this->_hashPassword = otherObject->_hashPassword;
+    this->_token = otherObject->_token;
+    this->_userData = otherObject->_userData;
 
     return true;
 }
@@ -24,26 +30,58 @@ bool LocalUser::fromSqlRecord(const QSqlRecord &q) {
         return false;
     }
 
-    setAuthenticationData(q.value("passwordHash").toByteArray());
+    setHashPassword(q.value("passwordHash").toByteArray());
     setToken(QH::AccessToken{q.value("token").toByteArray()});
     setOnline(q.value("onlineUser").toBool());
+    setUserData({q.value("userdata").toByteArray()});
 
     return LocalUser::isValid();
 }
 
 QH::PKG::DBVariantMap LocalUser::variantMap() const {
-    return {{"passwordHash",       {authenticationData(), MT::InsertUpdate}},
-            {"token",              {token().toBytes(),    MT::InsertUpdate}},
+    return {{"passwordHash",       {_hashPassword,        MT::InsertUpdate}},
+            {"token",              {_token.toBytes(),     MT::InsertUpdate}},
+            {"userdata",           {_userData.toBytes(),  MT::InsertUpdate}},
             {"onlineUser",         {_online,              MT::InsertUpdate}}};
 
 }
 
-bool LocalUser::online() const
-{
+QH::BaseId LocalUser::generateId() const {
+    return getId();
+}
+
+QH::PKG::DBObject *LocalUser::createDBObject() const {
+    return create<LocalUser>();
+}
+
+ProfileData LocalUser::userData() const {
+    return _userData;
+}
+
+void LocalUser::setUserData(const ProfileData &userData) {
+    _userData = userData;
+}
+
+QH::AccessToken LocalUser::token() const {
+    return _token;
+}
+
+void LocalUser::setToken(const QH::AccessToken &token) {
+    _token = token;
+}
+
+QByteArray LocalUser::hashPassword() const {
+    return _hashPassword;
+}
+
+void LocalUser::setHashPassword(const QByteArray &hashPassword) {
+    _hashPassword = hashPassword;
+}
+
+bool LocalUser::online() const {
     return _online;
 }
 
-void LocalUser::setOnline(bool online)
-{
+void LocalUser::setOnline(bool online) {
     _online = online;
 }

HanoiTowers/client/localuser.h

@@ -1,24 +1,46 @@
 #ifndef LOCALUSER_H
 #define LOCALUSER_H
 
-#include "user.h"
+#include "dbobject.h"
+#include <accesstoken.h>
+#include <profiledata.h>
 
-class LocalUser: public QH::PKG::User
+
+class LocalUser: public QH::PKG::DBObject
 {
 public:
     LocalUser();
 
-    bool copyFrom(const QH::PKG::AbstractData *other);
-    bool fromSqlRecord(const QSqlRecord &q);
+    bool copyFrom(const QH::PKG::AbstractData *other) override;
+    bool fromSqlRecord(const QSqlRecord &q) override;
 
     // DBObject interface
     bool online() const;
     void setOnline(bool online);
 
+    QString userName() const;
+    void setUserName(const QString &userName);
+
+    QByteArray hashPassword() const;
+    void setHashPassword(const QByteArray &hashPassword);
+
+    QH::AccessToken token() const;
+    void setToken(const QH::AccessToken &token);
+
+    ProfileData userData() const;
+    void setUserData(const ProfileData &userData);
+
 protected:
-    QH::PKG::DBVariantMap variantMap() const;
+    QH::PKG::DBVariantMap variantMap() const override;
+    QH::BaseId generateId() const override;
+    QH::PKG::DBObject *createDBObject() const override;
+
 private:
     bool _online = false;
+    QByteArray _hashPassword;
+    QH::AccessToken _token;
+    ProfileData _userData;
+
 };
 
 #endif // LOCALUSER_H

HanoiTowers/client/sql/database.sql

@@ -2,12 +2,6 @@ CREATE TABLE IF NOT EXISTS Users (
     id VARCHAR(64) PRIMARY KEY NOT NULL,
     passwordHash BLOB default NULL,
     token BLOB default NULL,
-    onlineUser BOOLEAN default false
-);
-
-CREATE TABLE IF NOT EXISTS UsersData (
-    id VARCHAR(64) PRIMARY KEY NOT NULL,
-    name VARCHAR(64) UNIQUE NOT NULL,
-    points INTEGER default 0
+    onlineUser BOOLEAN default false,
     userdata BLOB default NULL,
 );