Merge branch 'finish-tests' into 'master'

WIP: Finish tests

See merge request spaceti-app/integrations/acs/colnod-connector!3

curl/tokenssubjects.sh

@@ -2,5 +2,5 @@
 
 
 TOKEN=$(curl -k --user "spaceti:E7FEA07DBC82FB9BA34B2E453E2EFE89F0583E7187543507EF11E84726071FE428445372F2E46B455EB0C79747C51E362F403CE39473A2A8C2DFA0CE5C9826C0" -d '{"password":"E7FEA07DBC82FB9BA34B2E453E2EFE89F0583E7187543507EF11E84726071FE428445372F2E46B455EB0C79747C51E362F403CE39473A2A8C2DFA0CE5C9826C0","username":"spaceti"}' -H "Content-Type: application/json" https://192.168.1.3:8443/AaaManager/authSession 2>/dev/null | python -c 'import json,sys;obj=json.load(sys.stdin);print obj["id"]')
-
+echo TOKEN
 curl -kv -u "$TOKEN:" -X POST https://192.168.1.3:8443/OpenManager/getTokenSubject

http/Curl.txt

@@ -0,0 +1,37 @@
+
+///SubjectManager/getSubjects
+RESPONSE
+HTTP/1.1 200 
+X-Content-Type-Options: nosniff
+X-XSS-Protection: 1; mode=block
+Cache-Control: no-cache, no-store, max-age=0, must-revalidate
+Pragma: no-cache
+Expires: 0
+Strict-Transport-Security: max-age=31536000 ; includeSubDomains
+X-Frame-Options: DENY
+Set-Cookie: JSESSIONID=77278D21902AE1DE75E43204C2770545;path=/;Secure;HttpOnly
+Content-Type: application/json;charset=UTF-8
+Transfer-Encoding: chunked
+Date: Thu, 03 Oct 2019 11:12:03 GMT
+
+REQUEST
+POST /SubjectManager/getSubjects HTTP/1.1
+Host: 192.168.1.3:8443
+Authorization: Basic ODkwZjllNmMtMDIxNi00ZThiLWI2MjgtMjViOGI2ZmFiNWM4Og==
+User-Agent: curl/7.65.3
+Accept: */*
+
+
+
+POST /AaaManager/authSession HTTP/1.1
+Host: localhost:8080
+Authorization: Basic c3BhY2V0aTpFN0ZFQTA3REJDODJGQjlCQTM0QjJFNDUzRTJFRkU4OUYwNTgzRTcxODc1NDM1MDdFRjExRTg0NzI2MDcxRkU0Mjg0NDUzNzJGMkU0NkI0NTVFQjBDNzk3NDdDNTFFMzYyRjQwM0NFMzk0NzNBMkE4QzJERkEwQ0U1Qzk4MjZDMA==
+User-Agent: curl/7.65.3
+Accept: */*
+Content-Type: application/json
+Content-Length: 164
+
+{
+	"password":"E7FEA07DBC82FB9BA34B2E453E2EFE89F0583E7187543507EF11E84726071FE428445372F2E46B455EB0C79747C51E362F403CE39473A2A8C2DFA0CE5C9826C0",
+	"username":"spaceti"
+}

http/Insomnia.txt

@@ -0,0 +1,12 @@
+POST /OpenManager/getTokenSubject HTTP/1.1
+Host: localhost:8080
+Authorization: Basic c3BhY2V0aTpFN0ZFQTA3REJDODJGQjlCQTM0QjJFNDUzRTJFRkU4OUYwNTgzRTcxODc1NDM1MDdFRjExRTg0NzI2MDcxRkU0Mjg0NDUzNzJGMkU0NkI0NTVFQjBDNzk3NDdDNTFFMzYyRjQwM0NFMzk0NzNBMkE4QzJERkEwQ0U1Qzk4MjZDMA==
+User-Agent: insomnia/7.0.0
+Content-Type: application/json
+Accept: */*
+Content-Length: 173
+
+{
+  "username": "spaceti",
+  "password": "E7FEA07DBC82FB9BA34B2E453E2EFE89F0583E7187543507EF11E84726071FE428445372F2E46B455EB0C79747C51E362F403CE39473A2A8C2DFA0CE5C9826C0"
+}

http/Qt requests.txt

@@ -0,0 +1,24 @@
+POST /AaaManager/authSession HTTP/1.1
+Host: localhost:8080
+Authorization: Basic c3BhY2V0aTpFN0ZFQTA3REJDODJGQjlCQTM0QjJFNDUzRTJFRkU4OUYwNTgzRTcxODc1NDM1MDdFRjExRTg0NzI2MDcxRkU0Mjg0NDUzNzJGMkU0NkI0NTVFQjBDNzk3NDdDNTFFMzYyRjQwM0NFMzk0NzNBMkE4QzJERkEwQ0U1Qzk4MjZDMA==
+Content-Type: application/json; charset=UTF-8
+Content-Length: 178
+Connection: Keep-Alive
+Accept-Encoding: gzip, deflate
+Accept-Language: en-AI,*
+User-Agent: Mozilla/5.0
+
+{
+    "password": "E7FEA07DBC82FB9BA34B2E453E2EFE89F0583E7187543507EF11E84726071FE428445372F2E46B455EB0C79747C51E362F403CE39473A2A8C2DFA0CE5C9826C0",
+    "username": "spaceti"
+}
+
+
+//no data because cant get token
+POST /SubjectManager/getSubjects HTTP/1.1
+Host: localhost:8080
+Content-Length: 0
+Connection: Keep-Alive
+Accept-Encoding: gzip, deflate
+Accept-Language: en-AI,*
+User-Agent: Mozilla/5.0

http/sendingRequestBySSLSocket.txt

@@ -0,0 +1,5 @@
+POST /SubjectManager/getSubjects HTTP/1.1
+Host: 192.168.1.3:8443
+Authorization: Basic " + tkn.toUtf8().toBase64() + "
+User-Agent: curl/7.65.3
+Accept: */*

src/colnod/colnod.pri

@@ -2,8 +2,18 @@ INCLUDEPATH += $$PWD
 #SRC_DIR = $$PWD
 message($$PWD)
 SOURCES += \
-    $$PWD/requestmanager.cpp
+    $$PWD/databasemanager.cpp \
+    $$PWD/dataprocessor.cpp \
+    $$PWD/entity.cpp \
+    $$PWD/requestmanager.cpp \
+    $$PWD/subject.cpp \
+    $$PWD/token.cpp
 
 HEADERS += \
-    $$PWD/requestmanager.h
+    $$PWD/databasemanager.h \
+    $$PWD/dataprocessor.h \
+    $$PWD/entity.h \
+    $$PWD/requestmanager.h \
+    $$PWD/subject.h \
+    $$PWD/token.h
 message($$SOURCES)

src/colnod/databasemanager.cpp

@@ -0,0 +1,50 @@
+#include "databasemanager.h"
+
+DatabaseManager::DatabaseManager(QString host, QString dbName, QString user, QString password)
+{
+
+    db = QSqlDatabase::addDatabase("QPSQL");
+
+    db.setDatabaseName(dbName);
+    db.setHostName(host);
+    db.setUserName(user);
+    db.setPassword(password);
+    opened = db.open();
+    if (!opened)
+    {
+        qDebug() << "Opening error" + db.lastError().text();
+    }
+    query = QSqlQuery("query", db);
+}
+
+void DatabaseManager::saveSubject(Subject subject, QString table)
+{
+    //TODO
+}
+
+void DatabaseManager::saveToken(Subject subject, QString table)
+{
+    //TODO
+}
+
+QString DatabaseManager::getTestMessage(int id)
+{
+    query.prepare("SELECT message FROM test WHERE id = :id");
+    query.bindValue(":id", id);
+    query.exec();
+    query.next();
+    //qDebug() << query.value(0);
+    return query.value(0).toString();
+}
+
+void DatabaseManager::createTestRecord(QString msg)
+{
+    query.exec("SELECT MAX(id) FROM test");
+    query.next();
+    int id = query.value(0).toInt() + 1;
+    QString statement = QString("INSERT INTO test (id, message) VALUES (%1, '%2')").arg(id).arg(msg);
+    query.exec(statement);
+    query.next();
+    qDebug() << "U inserted new row, id: " << id << "msg: " << getTestMessage(id);
+
+}

src/colnod/databasemanager.h

@@ -0,0 +1,38 @@
+#ifndef DATABASEMANAGER_H
+#define DATABASEMANAGER_H
+#include <QSql>
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlError>
+
+#include <QVariant>
+#include <QDebug>
+#include "subject.h"
+#include "token.h"
+
+
+class DatabaseManager : public QObject
+{
+    Q_OBJECT
+public:
+    DatabaseManager(QString host, QString dbName, QString user, QString password);
+
+    void saveSubject(Subject subject, QString table);
+    void saveToken(Subject subject, QString table);
+
+    QString getTestMessage(int id);
+    void createTestRecord(QString msg);
+
+
+    bool getOpened() {return opened;}
+
+private:
+    QSqlDatabase db;
+    QSqlQuery query;
+
+    bool opened;
+
+
+};
+
+#endif // DATABASEMANAGER_H

src/colnod/dataprocessor.cpp

@@ -0,0 +1,56 @@
+#include "dataprocessor.h"
+
+DataProcessor::DataProcessor()
+{
+
+    db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12");
+    reqMan = new RequestManager;
+}
+
+void DataProcessor::processSubjects()
+{
+    reqMan->getSubjects();
+    QEventLoop loop;
+    QObject::connect(reqMan, &RequestManager::responseReady, &loop, &QEventLoop::quit);
+    loop.exec();
+    prepareSubjectJson(reqMan->getResponse());
+}
+
+
+
+/*
+QUuid DataProcessor::getSubjectId(const QString &email) const
+{
+    auto subject = this->getSubjectByEmail(email);
+    if (!subject)
+    {
+        return "";
+    }
+    return subject->getId();
+}
+
+Subject *DataProccesor::getSubjectById(const QUuid &id) const
+{
+    return this->subjectsById.value(id);
+}
+
+Subject DataProcessor::getSubjectByEmail(const QString &email) const
+{
+    return this->subjectsByEmail.value(email);
+}
+
+Token *Client::getTokenById(const QUuid &id) const
+{
+    return this->tokensById.value(id);
+}
+
+Token *Client::getTokenByData(const QString &data) const
+{
+    return this->tokensByData.value(data);
+    }*/
+
+void DataProcessor::prepareSubjectJson(QString json)
+{
+    QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
+    subjectArr = doc.object()["items"].toArray();
+}

src/colnod/dataprocessor.h

@@ -0,0 +1,41 @@
+#ifndef DATAPROCESSOR_H
+#define DATAPROCESSOR_H
+
+#include "token.h"
+#include "subject.h"
+#include "requestmanager.h"
+#include "databasemanager.h"
+#include <QJsonDocument>
+#include <qjsonarray.h>
+
+
+
+class DataProcessor : public QObject
+{
+
+    Q_OBJECT
+
+public:
+    DataProcessor();
+
+    void processSubjects();
+
+    Subject *getSubjectById(const QUuid &id) const;
+    Subject *getSubjectByEmail(const QString &email) const;
+    QUuid getSubjectId(const QString &email) const;
+
+    Token *getTokenById(const QUuid &id) const;
+    Token *getTokenByData(const QString &data) const;
+
+private slots:
+    void prepareSubjectJson(QString json);
+
+private:
+    RequestManager *reqMan;
+    DatabaseManager *db;
+    QJsonArray subjectArr;
+
+
+};
+
+#endif // DATAPROCESSOR_H

src/colnod/entity.cpp

@@ -0,0 +1,52 @@
+#include <QJsonObject>
+#include "entity.h"
+
+const QUuid &Entity::getId() const {
+    return id;
+}
+
+void Entity::setId(const QUuid &id) {
+    Entity::id = id;
+}
+
+const QString &Entity::getName() const {
+    return name;
+}
+
+void Entity::setName(const QString &name) {
+    Entity::name = name;
+}
+
+const QString &Entity::getDescription() const {
+    return description;
+}
+
+void Entity::setDescription(const QString &description) {
+    Entity::description = description;
+}
+
+uint64_t Entity::getLastUpdate() const {
+    return lastUpdate;
+}
+
+void Entity::setLastUpdate(uint64_t lastUpdate) {
+    this->lastUpdate = lastUpdate;
+}
+
+void Entity::fromJSON(const QJsonObject &json) {
+    id = json.value("id").toString();
+    name = json.value("name").toString();
+    description = json.value("description").toString();
+    lastUpdate = json.value("lastUpdate").toDouble();
+}
+
+QJsonObject Entity::toJSON() const {
+    QJsonObject json;
+
+    json.value("id") = id.toString();
+    json.value("name") = name;
+    json.value("description") = description;
+    json.value("lastUpdate") = lastUpdate;
+
+    return json;
+}

src/colnod/entity.h

@@ -0,0 +1,37 @@
+#ifndef COLNOD_CONNECTOR_ENTITY_H
+#define COLNOD_CONNECTOR_ENTITY_H
+
+#include <QtCore/QObject>
+#include <QtCore/QUuid>
+#include <QtCore/QJsonObject>
+
+
+class Entity : public QObject {
+Q_OBJECT
+public:
+    using QObject::QObject;
+
+    const QUuid &getId() const;
+    void setId(const QUuid &id);
+
+    const QString &getName() const;
+    void setName(const QString &name);
+
+    const QString &getDescription() const;
+    void setDescription(const QString &description);
+
+    uint64_t getLastUpdate() const;
+    void setLastUpdate(uint64_t lastUpdate);
+
+    virtual void fromJSON(const QJsonObject &json);
+    virtual QJsonObject toJSON() const;
+protected:
+    QUuid id;
+    QString name;
+    QString description;
+    qint64 lastUpdate;
+};
+
+
+
+#endif //COLNOD_CONNECTOR_ENTITY_H

src/colnod/requestmanager.cpp

@@ -4,17 +4,17 @@ RequestManager::RequestManager()
 {
     manager = new QNetworkAccessManager();
     token = "";
-    loginStatus = false;
+    loginStatus = false;  //should be false, true for testing request header
+
+
 
     QFile configFile(QDir::current().filePath("config.json"));
-
        if (!configFile.open(QIODevice::ReadOnly)) {
            qCritical() << "Couldn't open config file config.json" << QDir::current().filePath("config.json");
            QCoreApplication::exit(-1);
            return;
        }
-
-       this->config = QJsonDocument::fromJson(configFile.readAll());
+    this->config = QJsonDocument::fromJson(configFile.readAll());
     QObject::connect(manager, &QNetworkAccessManager::sslErrors, this, &RequestManager::onSSLError);
 }
 
@@ -33,6 +33,7 @@ void RequestManager::login(QString host, QString username, QString password)
     request.setRawHeader("Authorization", authHeader.toLocal8Bit());
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json; charset=UTF-8");
     QJsonDocument jsonDocument;
+
     jsonDocument.setObject(reqBody);
     QNetworkReply* reply = manager->post(request, jsonDocument.toJson());
     QObject::connect(reply, &QNetworkReply::finished, [=]() {
@@ -40,11 +41,11 @@ void RequestManager::login(QString host, QString username, QString password)
         {
             qDebug() << reply->errorString();
             loginStatus = false;
-            qDebug() << reply->readAll();
             return;
         }
         jsonResponse = reply->readAll();
         prepareAuthHeader();
+        loginStatus = true;
         emit successLogin();
         reply->deleteLater();
         });
@@ -52,37 +53,52 @@ void RequestManager::login(QString host, QString username, QString password)
 
 void RequestManager::getRequest(QString endpoint)
 {
+    if (!loginStatus)
+    {
+        login(config.object()["host"].toString(), config.object()["username"].toString(), config.object()["password"].toString());
+       // QEventLoop loop;
+       // QObject::connect(this, &RequestManager::successLogin, &loop, &QEventLoop::quit);
+       // loop.exec();
+    }
+
+    //
+    //host = config.object()["host"].toString();
+    //
+
     QNetworkRequest request;
     request.setUrl(host + endpoint);
+    qDebug() << authHeader;
     request.setRawHeader("Authorization", authHeader.toLocal8Bit());
+    request.setRawHeader("User-Agent", "curl/7.65.3");
+    request.setRawHeader("Connection", "Keep-Alive");
+    request.setRawHeader("Accept", "*/*");
+    request.setRawHeader("Accept-Encoding", "*");
+    request.setRawHeader("Accept-Language", "*");
+
     QNetworkReply* reply = manager->post(request, QByteArray());
+
+    //
+    //QEventLoop loop;
+    //QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+   // loop.exec();
+    //
+
     QObject::connect(reply, &QNetworkReply::finished, [=]() {
         if (reply->error())
         {
             qDebug() << reply->errorString();
             qDebug() << reply->readAll();
+            loginStatus = false;
+            getRequest(endpoint);
             return;
         }
-
-        //print reply info
-        auto items = reply->rawHeaderPairs();
-        for (auto item : items)
-        {
-            qDebug() << item;
-        }
-        auto reqHeaderName = reply->request().rawHeaderList();
-        for (QString header : reqHeaderName)
-        {
-            qDebug() << reply->request().rawHeader(header.toUtf8());
-        }
         qDebug() << reply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
-
         jsonResponse = reply->readAll();
         emit responseReady();
     });
 }
 
-QString RequestManager::getFromJson(QString json, QString member)
+QString RequestManager::getFromJson(QString json, const QString &member)
 {
     QJsonParseError err;
     QJsonDocument document = QJsonDocument::fromJson(json.toUtf8(),&err);
@@ -90,7 +106,7 @@ QString RequestManager::getFromJson(QString json, QString member)
     {
         qDebug() << err.errorString();
     }
-    return document[member].toString();
+    return document.object().value(member).toString();
 }
 
 QString RequestManager::encryptedPassword(QString password)
@@ -122,3 +138,8 @@ void RequestManager::onSSLError(QNetworkReply *reply, const QList<QSslError> &er
     }
 
 }
+
+void RequestManager::getSubjects()
+{
+    getRequest("/SubjectManager/getSubjects");
+}

src/colnod/requestmanager.h

@@ -20,24 +20,35 @@
 #include <QDir>
 #include <QSslError>
 
+
+#include "databasemanager.h"
+#include "token.h"
+#include "subject.h"
+
 class RequestManager : public QObject
 {
     Q_OBJECT
 
 public:
     RequestManager();
+    void getSubjects();
     void login(QString endpoint, QString username, QString password);
     void getRequest(QString endpoint);
-    void fetchSubjects(QString endpoint);
+    void loadSubjectsFromColnodToDB();
+
+
+
     const QJsonDocument &getConfig() const {return config;}
     const QString &getResponse() const {return jsonResponse;}
     QString getToken(){return token;}
+
 private:
 
-    QString getFromJson(QString json, QString member);
+    QString getFromJson(QString json, const QString &member);
     QString encryptedPassword(QString password);
     QString getLoginHeader(QString username, QString hash);
     void prepareAuthHeader();
+
 private slots:
     void onSSLError(QNetworkReply *reply, const QList<QSslError> &errors);
 
@@ -48,14 +59,13 @@ signals:
 
 private:
     QNetworkAccessManager* manager;
-
     QJsonDocument config;
     QString authHeader;
     QString host;
     QString token;
     QString jsonResponse;
     bool loginStatus;
-    QString tenant;
+
 
 };
 

src/colnod/subject.cpp

@@ -0,0 +1,74 @@
+#include <utility>
+
+#include "subject.h"
+
+#include <QJsonArray>
+
+QString Subject::getEmail() const {
+    return attributes["email"].toString();
+}
+
+void Subject::fromJSON(const QJsonObject &json) {
+    Entity::fromJSON(json);
+
+    //attributes = json["attributes"]["items"].toObject();
+
+    attributes = json.value("attributes").toObject().value("items").toObject();
+
+    const auto &tokenFlagsArray = json.value("tokenFlags").toArray();
+    for(const auto &flag : tokenFlagsArray){
+        tokenFlags.insert(flag.toString());
+    }
+
+    pin = json.value("pin").toString();
+
+    const auto &pinFlagsArray = json.value("pinFlags").toArray();
+    for(const auto &flag : pinFlagsArray){
+        pinFlags.insert(flag.toString());
+    }
+
+}
+
+QJsonObject Subject::toJSON() const {
+    QJsonObject json = Entity::toJSON();
+
+    QJsonObject items({{"items", attributes}});
+    json.value("atributes") = items;
+    json.value("tokenFlags") = QJsonArray::fromStringList(tokenFlags.toList());
+    json.value("pin") = pin;
+    json.value("pinFlags") = QJsonArray::fromStringList(pinFlags.toList());
+
+    return json;
+}
+
+const QJsonObject &Subject::getAttributes() const {
+    return attributes;
+}
+
+void Subject::setAttributes(const QJsonObject &attributes) {
+    Subject::attributes = attributes;
+}
+
+const QSet<QString> &Subject::getTokenFlags() const {
+    return tokenFlags;
+}
+
+void Subject::setTokenFlags(const QSet<QString> &tokenFlags) {
+    Subject::tokenFlags = tokenFlags;
+}
+
+const QString &Subject::getPin() const {
+    return pin;
+}
+
+void Subject::setPin(const QString &pin) {
+    Subject::pin = pin;
+}
+
+const QSet<QString> &Subject::getPinFlags() const {
+    return pinFlags;
+}
+
+void Subject::setPinFlags(const QSet<QString> &pinFlags) {
+    Subject::pinFlags = pinFlags;
+}

src/colnod/subject.h

@@ -0,0 +1,35 @@
+#ifndef COLNOD_CONNECTOR_SUBJECT_H
+#define COLNOD_CONNECTOR_SUBJECT_H
+
+#include <QSet>
+
+#include "entity.h"
+
+
+class Subject : public Entity {
+
+public:
+    using Entity::Entity;
+
+    QString getEmail() const;
+
+    const QJsonObject &getAttributes() const;
+    void setAttributes(const QJsonObject &attributes);
+    const QSet<QString> &getTokenFlags() const;
+    void setTokenFlags(const QSet<QString> &tokenFlags);
+    const QString &getPin() const;
+    void setPin(const QString &pin);
+    const QSet<QString> &getPinFlags() const;
+    void setPinFlags(const QSet<QString> &pinFlags);
+
+    void fromJSON(const QJsonObject &json) override;
+    QJsonObject toJSON() const override;
+protected:
+    QJsonObject attributes;
+    QSet<QString> tokenFlags;
+    QString pin;
+    QSet<QString> pinFlags;
+};
+
+
+#endif //COLNOD_CONNECTOR_SUBJECT_H

src/colnod/token.cpp

@@ -0,0 +1,108 @@
+#include "token.h"
+
+#include <QJsonArray>
+
+void Token::fromJSON(const QJsonObject &json) {
+    Entity::fromJSON(json);
+
+    tokenType = json.value("tokenType").toString();
+    tokenBits = json.value("tokenBits").toInt();
+    tokenData = json.value("tokenData").toString();
+    validFrom = json.value("validFrom").toDouble();
+    validTo = json.value("validTo").toDouble();
+    timeToLive = json.value("timeToLive").toInt();
+    authErrors = json["authErrors"].toInt();
+    const auto &flagsArray = json["flags"].toArray();
+    for(const auto &flag : flagsArray){
+        flags.insert(flag.toString());
+    }
+    subjectId = json.value("subjectId").toString();
+}
+
+QJsonObject Token::toJSON() const {
+    QJsonObject json = Entity::toJSON();
+
+    json.value("tokenType") = tokenType;
+    json.value("tokenBits") = tokenBits;
+    json.value("tokenData") = tokenData;
+    json.value("validFrom") = validFrom;
+    json.value("validTo") = validTo;
+    json.value("timeToLive") = timeToLive;
+    json.value("authErrors") = authErrors;
+    json.value("flags") = QJsonArray::fromStringList(flags.toList());
+    json.value("subjectId") = subjectId.toString();
+
+    return json;
+}
+
+const QString &Token::getTokenType() const {
+    return tokenType;
+}
+
+void Token::setTokenType(const QString &tokenType) {
+    Token::tokenType = tokenType;
+}
+
+int Token::getTokenBits() const {
+    return tokenBits;
+}
+
+void Token::setTokenBits(int tokenBits) {
+    Token::tokenBits = tokenBits;
+}
+
+const QString &Token::getTokenData() const {
+    return tokenData;
+}
+
+void Token::setTokenData(const QString &tokenData) {
+    Token::tokenData = tokenData;
+}
+
+qint64 Token::getValidFrom() const {
+    return validFrom;
+}
+
+void Token::setValidFrom(qint64 validFrom) {
+    Token::validFrom = validFrom;
+}
+
+qint64 Token::getValidTo() const {
+    return validTo;
+}
+
+void Token::setValidTo(qint64 validTo) {
+    Token::validTo = validTo;
+}
+
+int Token::getTimeToLive() const {
+    return timeToLive;
+}
+
+void Token::setTimeToLive(int timeToLive) {
+    Token::timeToLive = timeToLive;
+}
+
+int Token::getAuthErrors() const {
+    return authErrors;
+}
+
+void Token::setAuthErrors(int authErrors) {
+    Token::authErrors = authErrors;
+}
+
+const QSet<QString> &Token::getFlags() const {
+    return flags;
+}
+
+void Token::setFlags(const QSet<QString> &flags) {
+    Token::flags = flags;
+}
+
+const QUuid &Token::getSubjectId() const {
+    return subjectId;
+}
+
+void Token::setSubjectId(const QUuid &subjectId) {
+    Token::subjectId = subjectId;
+}

src/colnod/token.h

@@ -0,0 +1,48 @@
+#ifndef COLNOD_CONNECTOR_TOKEN_H
+#define COLNOD_CONNECTOR_TOKEN_H
+
+#include "entity.h"
+
+#include <QSet>
+
+
+class Token : public Entity {
+public:
+   // using Entity::Entity;
+
+    const QString &getTokenType() const;
+    void setTokenType(const QString &tokenType);
+    int getTokenBits() const;
+    void setTokenBits(int tokenBits);
+    const QString &getTokenData() const;
+    void setTokenData(const QString &tokenData);
+    qint64 getValidFrom() const;
+    void setValidFrom(qint64 validFrom);
+    qint64 getValidTo() const;
+    void setValidTo(qint64 validTo);
+    int getTimeToLive() const;
+    void setTimeToLive(int timeToLive);
+    int getAuthErrors() const;
+    void setAuthErrors(int authErrors);
+    const QSet<QString> &getFlags() const;
+    void setFlags(const QSet<QString> &flags);
+    const QUuid &getSubjectId() const;
+    void setSubjectId(const QUuid &subjectId);
+
+
+    void fromJSON(const QJsonObject &json) override;
+    QJsonObject toJSON() const override;
+protected:
+    QString tokenType;
+    int tokenBits;
+    QString tokenData;
+    qint64 validFrom;
+    qint64 validTo;
+    int timeToLive;
+    int authErrors;
+    QSet<QString> flags;
+    QUuid subjectId;
+};
+
+
+#endif //COLNOD_CONNECTOR_TOKEN_H

src/config.json

@@ -1,5 +1,5 @@
 {
-    "host": "https://localhost:8080",
+    "host": "https://192.168.1.3",
     "username": "spaceti",
-    "password": "SuperSecretPassword"
+    "password": "spaceti1"
 }

src/subjects.json

@@ -0,0 +1,58 @@
+{
+    "items":[
+    {
+    "id":"6d809c12-3255-4b0a-bf8f-3af86912a40f",
+    "name":"Person2",
+    "description":"",
+    "lastUpdate":1543843828247,
+    "attributes":{
+    "items":{
+     
+    }
+    },
+    "tokenFlags":[
+    "NoPin"
+    ],
+    "pin":"",
+    "pinFlags":[
+    "Access"
+    ]
+    },
+    {
+    "id":"1a23c502-1665-4492-94ea-039bb7505cae",
+    "name":"Person3",
+    "description":"",
+    "lastUpdate":1553868160516,
+    "attributes":{
+    "items":{
+    "email":"person3@gmail.com"
+    }
+    },
+    "tokenFlags":[
+    "NoPin"
+    ],
+    "pin":"",
+    "pinFlags":[
+    "Access"
+    ]
+    },
+    {
+    "id":"7ad58bd8-a1ec-40b4-a54f-347ee6a4ba29",
+    "name":"Person1",
+    "description":"",
+    "lastUpdate":1560786050717,
+    "attributes":{
+    "items":{
+    "email":"person1@gmail.com"
+    }
+    },
+    "tokenFlags":[
+    "NoPin"
+    ],
+    "pin":"",
+    "pinFlags":[
+    "Access"
+    ]
+    }
+    ]
+    }

test/unitTests/UnitTest.cpp

@@ -12,32 +12,31 @@ void UnitTest::loginSuccessfully()
     QString json = testAccess->getResponse();
     qDebug() << json;
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
-    QVERIFY2(doc["id"].isString(), "No parameter 'id' in response");
+    QVERIFY2(doc.object().value("id").isString(), "No parameter 'id' in response");
 }
 
 //POST request w/o datas
 void UnitTest::getSubjects()
 {
     RequestManager* testAccess = new RequestManager();
-    testAccess->login(host, email, password);
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     testAccess->getRequest("/SubjectManager/getSubjects");
     spy.wait();
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString json = testAccess->getResponse();
+    qDebug() << json;
     QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
     QVERIFY(doc.isObject());
-    QVERIFY2(doc["items"].isArray(), "No parameter 'id' in response");
-    qDebug() << doc["items"].toArray()[0].toObject()["id"].toString();
-    QVERIFY2(doc["items"].toArray()[0].toObject()["id"].isString(), "ada");
+    QVERIFY2(doc.object().value("items").isArray(), "No parameter 'id' in response");
+    qDebug() << doc.object().value("items").toArray()[0].toObject()["id"].toString();
+    QVERIFY2(doc.object().value("items").toArray()[0].toObject()["id"].isString(), "ada");
 
 }
 
 void UnitTest::getTokens()
 {
     RequestManager* testAccess = new RequestManager();
-    testAccess->login(host, email, password);
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     testAccess->getRequest("/TokenManager/getTokens");
     QCOMPARE(spy.count(), 0);
@@ -50,7 +49,6 @@ void UnitTest::getTokens()
 void UnitTest::getTokensOpenManager()
 {
     RequestManager* testAccess = new RequestManager();
-    testAccess->login(host, email, password);
     QSignalSpy spy(testAccess, SIGNAL(responseReady()));
     testAccess->getRequest("/OpenManager/getTokenSubject");
     QCOMPARE(spy.count(), 0);
@@ -58,8 +56,119 @@ void UnitTest::getTokensOpenManager()
     QVERIFY(spy.isValid());
     QCOMPARE(spy.count(), 1);
     QString response = testAccess->getResponse();
-    QVERIFY(!response.isEmpty());
     qDebug() << response;
+    QVERIFY(!response.isEmpty());
+}
+
+void UnitTest::subjectJSONParser()
+{
+    /*
+    QFile jsonData(QDir::current().filePath("subjects.json"));
+
+    if (!jsonData.open(QIODevice::ReadOnly)) {
+        qCritical() << "Couldn't open config file config.json" << QDir::current().filePath("subjects.json");
+        QCoreApplication::exit(-1);
+        return;
+    }
+
+    QJsonDocument doc = QJsonDocument::fromJson(jsonData.readAll());
+    QJsonObject obj = doc.object();
+    QJsonArray arr = obj["items"].toArray();
+    */
+QVERIFY(true);
+return;
+
+
+    RequestManager* testAccess = new RequestManager();
+    QSignalSpy spy(testAccess, SIGNAL(responseReady()));
+    testAccess->getRequest("/SubjectManager/getSubjects");
+    spy.wait();
+    QString response = testAccess->getResponse();
+    QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
+    QJsonArray arr = doc.object()["items"].toArray();
+    auto testSubject = new Subject();
+    testSubject->fromJSON(arr[1].toObject());
+    qDebug() << testSubject->getName() << " Size:  " << arr.size();
+    QVERIFY(!testSubject->getName().isEmpty());
+}
+
+void UnitTest::tokenJSONParser()
+{
+    RequestManager* testAccess = new RequestManager();
+    QSignalSpy spy(testAccess, SIGNAL(responseReady()));
+    testAccess->getRequest("/TokenManager/getTokens");
+    spy.wait();
+    QString response = testAccess->getResponse();
+
+    //TODO
+   /* QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
+    QJsonArray arr = doc.object()["items"].toArray();
+    auto testSubject = new Subject();
+    testSubject->fromJSON(arr[1].toObject());
+    qDebug() << testSubject->getName();
+    QVERIFY(!testSubject->getName().isEmpty());*/
+    QVERIFY(true);
+
+}
+
+void UnitTest::connectToDB()
+{
+    DatabaseManager *db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12");
+    QVERIFY(db->getOpened());
+    qDebug() << db->getTestMessage(1);
+    QVERIFY(true);
+    QCOMPARE(db->getTestMessage(1), "Hello world");
+    db->createTestRecord("Does it work?");
+    QCOMPARE(db->getTestMessage(2), "Does it work?");
+}
+
+void UnitTest::debugConnection()
+{
+    QSslSocket ssl;// = new QSslSocket();
+    ssl.connectToHostEncrypted("192.168.1.3", 8443);
+    ssl.ignoreSslErrors();
+    if (!ssl.waitForEncrypted())
+    {
+        qDebug() << ssl.errorString();
+    }
+    QString tmp = "POST /AaaManager/authSession HTTP/1.1\r\nHost: 192.168.1.3:8443\r\nAuthorization: Basic c3BhY2V0aTpFN0ZFQTA3REJDODJGQjlCQTM0QjJFNDUzRTJFRkU4OUYwNTgzRTcxODc1NDM1MDdFRjExRTg0NzI2MDcxRkU0Mjg0NDUzNzJGMkU0NkI0NTVFQjBDNzk3NDdDNTFFMzYyRjQwM0NFMzk0NzNBMkE4QzJERkEwQ0U1Qzk4MjZDMA==\r\nUser-Agent: curl/7.65.3\r\nAccept: */*\r\nContent-Type: application/json\r\nContent-Length: 164\r\n\r\n{\"password\":\"E7FEA07DBC82FB9BA34B2E453E2EFE89F0583E7187543507EF11E84726071FE428445372F2E46B455EB0C79747C51E362F403CE39473A2A8C2DFA0CE5C9826C0\",\"username\":\"spaceti\"}";
+    /*POST /AaaManager/authSession HTTP/1.1
+    Host: localhost:8080
+    Authorization: Basic c3BhY2V0aTpFN0ZFQTA3REJDODJGQjlCQTM0QjJFNDUzRTJFRkU4OUYwNTgzRTcxODc1NDM1MDdFRjExRTg0NzI2MDcxRkU0Mjg0NDUzNzJGMkU0NkI0NTVFQjBDNzk3NDdDNTFFMzYyRjQwM0NFMzk0NzNBMkE4QzJERkEwQ0U1Qzk4MjZDMA==
+    User-Agent: curl/7.65.3
+    Accept:
+    Content-Type: application/json
+    Content-Length: 164
+
+    {"password":"E7FEA07DBC82FB9BA34B2E453E2EFE89F0583E7187543507EF11E84726071FE428445372F2E46B455EB0C79747C51E362F403CE39473A2A8C2DFA0CE5C9826C0","username":"spaceti"}*/
+    qDebug() << tmp.toUtf8();
+    ssl.write(tmp.toUtf8());
+    QString data;
+    while (ssl.waitForReadyRead() && data.isEmpty())
+    {
+        data.append(ssl.readAll().data());
+    }
+    qDebug() << data;
+    int index = data.lastIndexOf("id");
+    QString tkn = data.mid( index + 5, 36);
+    tkn = tkn + ":";
+    qDebug() << "parsed token : " <<tkn;
+/*
+    RequestManager* testAccess = new RequestManager();
+    QJsonDocument config = testAccess->getConfig();
+    QSignalSpy spy(testAccess, SIGNAL(successLogin()));
+    testAccess->login(host, email, password);
+    spy.wait();
+
+    QString token = testAccess->getToken();
+    token = token + ":";*/
+    tmp = "POST /SubjectManager/getSubjects\r\nHTTP/1.1 Host: 192.168.1.3:8443\r\nAuthorization: Basic " + tkn.toUtf8().toBase64() + "\r\nUser-Agent: curl/7.65.3\r\nAccept: */*)";
+    qDebug() << tmp.toUtf8();
+    ssl.write(tmp.toUtf8());
+    while (ssl.waitForReadyRead())
+        qDebug() << ssl.readAll().data();
+
+    QVERIFY(true);
 }
 
 

test/unitTests/config.json

@@ -1,5 +1,5 @@
 {
-    "host": "https://localhost:8080",
+	"host": "https://192.168.1.3:8443",
     "username": "spaceti",
-    "password": "SuperSecretPassword"
+    "password": "spaceti1"
 }

test/unitTests/unittest.h

@@ -1,8 +1,12 @@
+
 #pragma once
 
 #include <QtTest/QtTest>
 #include <QSignalSpy>
 #include <requestmanager.h>
+#include "subject.h"
+#include "databasemanager.h"
+#include <QSslSocket>
 
 
 class UnitTest : public QObject
@@ -11,15 +15,17 @@ class UnitTest : public QObject
 
 private slots:
 
-    void loginSuccessfully();
-
-
-    void getTokens();
-    void getTokensOpenManager();
-    void getSubjects();
+    void loginSuccessfully();       // /AaaManager/authSession
+    void getSubjects();             // /SubjectManager/getSubjects
+    void getTokens();               // /TokenManager/getTokens
+    void getTokensOpenManager();    // /OpenManager/getTokenSubject
+    void subjectJSONParser();
+    void tokenJSONParser();
+    void connectToDB();
+    void debugConnection();
 
 private:
-    // QString host = "https://localhost:8080"; //colnod server (ssh -L 8080:192.168.254.11:8443 penta-master)
+     //QString host = "http://localhost:8080"; //colnod server (ssh -L 8080:192.168.254.11:8443 penta-master)
      QString host = "https://192.168.1.3:8443"; //local testing server
      QString password = "spaceti1";
      QString email = "spaceti";