rocketchatserver.cpp

/********************************************************************************************
 *                                                                                          *
 * Copyright (C) 2017 Armin Felder, Dennis Beier                                            *
 * This file is part of RocketChatMobileEngine <https://git.fairkom.net/chat/fairchat>.     *
 *                                                                                          *
 * RocketChatMobileEngine is free software: you can redistribute it and/or modify           *
 * it under the terms of the GNU General Public License as published by                     *
 * the Free Software Foundation, either version 3 of the License, or                        *
 * (at your option) any later version.                                                      *
 *                                                                                          *
 * RocketChatMobileEngine is distributed in the hope that it will be useful,                *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of                           *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                            *
 * GNU General Public License for more details.                                             *
 *                                                                                          *
 * You should have received a copy of the GNU General Public License                        *
 * along with RocketChatMobileEngine. If not, see <http://www.gnu.org/licenses/>.           *
 *                                                                                          *
 ********************************************************************************************/


#include "rocketchatserver.h"

#include "CustomModels/models.h"

RocketChatServerData::RocketChatServerData( QString pId, QString pBaseUrl, bool pUnsecure ): mBaseUrl( std::move( pBaseUrl ) ), mServerId( std::move( pId ) ), userModel( Models::getUsersModel() ), loginMethodsModel( Models::getLoginMethodsModel() ), channelsModel( Models::getPublicGroupsModel() ),
    directModel( Models::getDirectChannelsModel() ), groupsModel( Models::getPublicGroupsModel() )
{
    qRegisterMetaType<User>( "User" );
    qRegisterMetaType<QList<QSharedPointer<Emoji>>>( "QList<QSharedPointer<Emoji>>" );

    mUnsecureConnection = pUnsecure;

    mApiUri = QStringLiteral( "/api/v1" );
    mEmojiRepo = new EmojiRepo( this );

}

void RocketChatServerData::init()
{
    initDb();
}

void RocketChatServerData::initDb()
{
    mStorage = PersistanceLayer::instance();
    connect( mStorage, &PersistanceLayer::ready, this, &RocketChatServerData::initConnections, Qt::UniqueConnection );
    mStorage->init();
}

void RocketChatServerData::initConnections()
{
    historyLoaded = [ = ]( QMultiMap<QString, QSharedPointer<RocketChatMessage>> *messages ) {
        if ( messages ) {
            mStorage->transaction();

            QSet<QString> duplicateSet;

            for ( auto it = messages->begin(); it != messages->end(); it++ ) {
                if ( !duplicateSet.contains( it.key() ) ) {
                    duplicateSet.insert( it.key() );

                    if ( Q_LIKELY( mChannels->contains( it.key() ) && !mChannels->get( it.key() ).isNull() ) ) {
                        MessageList messageList = messages->values( it.key() );
                        mChannels->get( it.key() )->addMessages( messageList );
                        mMessageService->persistMessages( messageList );
                    }
                }
            }

            mStorage->askForcommit();

            delete messages;

        }
    };
    QString protocol = QStringLiteral( "https://" );

    if ( mUnsecureConnection ) {
        protocol = QStringLiteral( "http://" );
    }

    if ( mRestApi != nullptr ) {
        mRestApi->deleteLater();
    }

    if ( mFileService != nullptr ) {
        delete mFileService;
    }

    if ( mEmojiService != nullptr ) {
        delete mEmojiService;
    }

    if ( mDdpApi != nullptr ) {
        mDdpApi->deleteLater();
    }

    if ( mChannels != nullptr ) {
        mChannels->deleteLater();
    }

    if ( mMessageService != nullptr ) {
        mMessageService->deleteLater();
    }

    if ( mChannelService != nullptr ) {
        mChannelService->deleteLater();
    }

    setRestApi( new RestApi( this, protocol + mBaseUrl ) );
    mFileService = new FileService( this );
    mEmojiService = new EmojiService( this, mFileService, mStorage );

    mDdpApi = new MeteorDDP( this, mBaseUrl, mUnsecureConnection );

    mRestApi->moveToThread( QThread::currentThread() );
    mDdpApi->moveToThread( QThread::currentThread() );

    mChannels = new ChannelRepository( this );

    RocketChatServerConfig::init();

    auto result = QMetaObject::invokeMethod( mRestApi, "init" );
    Q_ASSERT( result );

    mDdpApi->registerMessageHandler( this );
    connect( mDdpApi, &MeteorDDP::ddpConnected, this, &RocketChatServerData::onDDPConnected, Qt::UniqueConnection );
    connect( mDdpApi, &MeteorDDP::ddpDisconnected, this, &RocketChatServerData::onDDPDisonnected, Qt::UniqueConnection );

    QPair<QString, uint> tokenDb = mStorage->getToken();
    QString token = tokenDb.first;
    QString userDb = mStorage->getUserName();

    if ( !token.isEmpty() && !userDb.isEmpty() ) {
        emit offlineMode();
    }

    setUserId( mStorage->getUserId() );
    mUsername = mStorage->getUserName();

    loadEmojis();

    mMessageService = new MessageService( this, mStorage, this, mEmojiRepo );
    mChannelService = new RocketChatChannelService( this, this, mMessageService );
    mChannelService->setDdp( mDdpApi );
    mChannelService->setChannels( mChannels );
    connect( mChannelService, &RocketChatChannelService::channelsLoaded, this, &RocketChatServerData::onChannelsLoaded, Qt::UniqueConnection );
    connect( mChannelService, &RocketChatChannelService::usersLoaded, this, &RocketChatServerData::onUsersLoaded, Qt::UniqueConnection );
    connect( mChannelService, &RocketChatChannelService::directChannelReady, this, &RocketChatServerData::switchChannelByName, Qt::UniqueConnection );
    connect( channelsModel, &ChannelModel::unreadMessagesChanged, this, &RocketChatServerData::onUnreadCountChanged, Qt::UniqueConnection );
    connect( directModel, &ChannelModel::unreadMessagesChanged, this, &RocketChatServerData::onUnreadCountChanged, Qt::UniqueConnection );
    connect( groupsModel, &ChannelModel::unreadMessagesChanged, this, &RocketChatServerData::onUnreadCountChanged, Qt::UniqueConnection );


    QString lastServer = mStorage->getSetting( QStringLiteral( "currentServer" ) );

    if ( lastServer == mBaseUrl ) {
        QPair<QString, uint> tokenDb = mStorage->getToken();
        QString userDb = mStorage->getUserName();
        QDateTime currentTime = QDateTime::currentDateTime();

        if ( !tokenDb.first.isEmpty() && tokenDb.second > currentTime.toTime_t() ) {
            loginWithToken( userDb, tokenDb.first );
        } else {
            wipeDbAndReconnect();
            emit loggedOut( mServerId );
        }
    } else if ( !lastServer.isEmpty() ) {
        wipeDbAndReconnect();
        emit loggedOut( mServerId );
    }

    emit readyToCheckForPendingNotification();
    mChannelService->loadJoinedChannelsFromDb();
}

void RocketChatServerData::setRestApi( RestApi *pNewRestApi )
{

    connect( pNewRestApi, &RestApi::loggedIn, this, &RocketChatServerData::onLoggedIn, Qt::UniqueConnection );
    connect( pNewRestApi, &RestApi::loginError, this, &RocketChatServerData::onLoginError, Qt::UniqueConnection );
    this->mRestApi = pNewRestApi;
    QPair<QString, uint> token = mStorage->getToken();

    if ( token.first.length() && token.second > 0 ) {
        mResumeToken = token.first;
        mTokenExpire = token.second;
    }
}

void RocketChatServerData::loadEmojis()
{

    /* QFile file(":/emoji.json");
     if(!file.open(QFile::ReadOnly)){
         qDebug()<<file.errorString();
         qDebug()<<file.error();
     }

     QJsonDocument doc = QJsonDocument::fromJson(file.readAll());

     QJsonObject obj = doc.object();

     for(QString key: obj.keys()){
         QJsonObject emojiObj = obj[key].toObject();
         QString id = ":"+key+":";
         QString file = "qrc:/res/emojis/"+emojiObj["unicode"].toString()+".png";
         QString html = "<img height='20' width='20' src='"+file+"' />";
         QString unicode = Utils::escapeUnicodeEmoji(emojiObj["unicode"].toString());
         QString category = emojiObj["category"].toString();
         QString sort_order = emojiObj["emoji_order"].toString();
         int sort_orderInt = sort_order.toInt();
         qDebug()<<sort_orderInt;
         mStorage->addCustomEmoji(id,file,html,category,unicode,sort_orderInt);
     }*/
    auto emojiModel = Models::getEmojisModel();

    auto emojiList = mEmojiService->loadEmojisFromDb();
    QHash<QString, QList<QSharedPointer<Emoji>>> emojisByCategory;

    for ( auto &emoji : emojiList ) {
        if ( mEmojiRepo != nullptr && !emoji.isNull() ) {
            mEmojiRepo->add( emoji->getIdentifier(), emoji );
        }

        auto category = emoji->getCategory();

        if ( !emojisByCategory.contains( category ) ) {
            emojisByCategory.insert( category, QList<QSharedPointer<Emoji>>() );
            emojisByCategory[category].reserve( 500 );

            if ( category == "custom" ) {
                mCustomEmojisReady = true;
            }
        }

        emojisByCategory[category].append( std::move( emoji ) );
    }

    for ( auto it = emojisByCategory.begin(); it != emojisByCategory.end(); it++ ) {
        auto result = QMetaObject::invokeMethod( emojiModel, "addEmojisByCategory", Q_ARG( QString, it.key() ), Q_ARG( QList<QSharedPointer<Emoji>>, std::move( it.value() ) ) );
        Q_ASSERT( result );
    }
}

void RocketChatServerData::switchChannel( const QString &pServer, const QString &pRid, const QString &pName, const QString &pType )
{
    Q_UNUSED( pServer )
    qDebug() << "switch channel to: " << pRid;
    bool switchPossible = false;

    QSharedPointer<RocketChatChannel> channel = nullptr;

    if ( pRid.length() ) {
        if ( mChannels != nullptr && !mChannels->contains( pRid ) ) {
            if ( pType == "d" || pType == "c" || pType == "p" ) {
                qDebug() << "create new channel object to:" << pRid;
                mChannelService->createChannelObject( pRid, pName, pType );

                if ( mChannels->contains( pRid ) && !mChannels->get( pRid ).isNull() ) {
                    channel = mChannels->get( pRid );
                    switchPossible = true;
                }
            }
        } else if ( mChannels != nullptr ) {
            channel = mChannels->get( pRid );
            switchPossible = true;
        }
    }

    if ( switchPossible ) {
        qDebug() << "current Channel " << mCurrentChannel;
        qDebug() << "room " << pRid;

        if ( mCurrentChannel != pRid ) {
            emit channelSwitchRequest( channel );
        }
    }
}

void RocketChatServerData::switchChannelByName( const QString &pName, const QString &pType )
{
    if ( mLoggedIn ) {
        if ( mChannels->getChannelByName( pName ) ) {
            auto channel = mChannels->getChannelByName( pName );
            switchChannel( QStringLiteral( "default" ), channel->getRoomId(), pName, channel->getType() );
            mPendingSwitchRoomRequest.clear();
            mPendingSwitchRoomRequestType.clear();
        } else {
            DdpCallback success = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
                if ( pResponse.contains( "result" ) ) {
                    QJsonObject result = pResponse["result"].toObject();
                    QString id = result["_id"].toString();
                    switchChannel( QStringLiteral( "default" ), id, pName, pType );
                }
            };
            auto request = QSharedPointer<RocketChatGetRoomByNameAndType>::create( pName, pType );
            request->setSuccess( success );
            sendDdprequest( request );
            //searchForRoomIdByName( pName );
        }
    } else {
        mPendingSwitchRoomRequest = pName;
        mPendingSwitchRoomRequestType = pType;
    }
}

void RocketChatServerData::requestGetChannelDetails( const QString &pChannelId )
{
    if ( mChannels->contains( pChannelId ) ) {
        auto channel = mChannels->get( pChannelId );

        if ( !channel.isNull() ) {
            auto archived = channel->getArchived();
            auto readonly = channel->getReadOnly();
            auto muted = channel->getMuted();
            auto selfMuted = channel->getSelfMuted();


            QVariantList mutedList;

            for ( const auto &entry : muted ) {
                mutedList.append( entry );
            }

            QVariantMap details;

            details[QStringLiteral( "archived" )] = archived;
            details[QStringLiteral( "ro" )] = readonly;
            details[QStringLiteral( "muted" )] = mutedList;
            details[QStringLiteral( "selfMuted" )] = selfMuted;
            details[QStringLiteral( "type" )] = channel->getType();
            details[QStringLiteral( "name" )] = channel->getName();
            details[QStringLiteral( "ownerId" )] = channel->getOwnerId();
            details[QStringLiteral( "ownerName" )] = channel->getOwnerName();
            details[QStringLiteral( "blocked" )] = channel->getBlocked();

            emit channelDetailsReady( details, pChannelId );
        }
    }
}

void RocketChatServerData::requestIsLoggedIn()
{
    if ( mLoggedIn ) {
        emit loggedIn( QStringLiteral( "default" ) );
    }
}

void RocketChatServerData::setUserPresenceDefaultStatus( int pStatus )
{
    if ( pStatus >= 0 && pStatus < 5 && isWebsocketValid() && diffToLastDDPPing() < 29 ) {

        auto request = QSharedPointer<RocketChatChangeUserPresenceDefaultStatus>::create( static_cast<RocketChatUser::status>( pStatus ) );
        sendDdprequest( request, true );
    }
}

void RocketChatServerData::setUserPresenceStatus( int pStatus )
{
    if ( pStatus >= 0 && pStatus < 5 && isWebsocketValid() && diffToLastDDPPing() < 29 ) {

        auto request = QSharedPointer<RocketChatChangeUserPresenceStatus>::create( static_cast<RocketChatUser::status>( pStatus ) );
        sendDdprequest( request, true );
    }
}

void RocketChatServerData::onStateChanged( const Qt::ApplicationState &pState )
{
    Q_UNUSED( pState )

    if ( !isWebsocketValid() || diffToLastDDPPing() > 29 ) {
        qDebug() << "call resume";
        resume();
    } else {
        setUserPresenceStatus( static_cast<int>( RocketChatUser::status::ONLINE ) );
    }
}

void RocketChatServerData::createVideoCall( const QString &pRid )
{
    if ( !pRid.isEmpty() ) {

        auto request = QSharedPointer<RocketChatUpdateJitsiTimeout>::create( pRid );
        sendDdprequest( request );
        joinJitsiCall( pRid );
    }
}

//TODO: rename, as method is not really for searching only
void RocketChatServerData::searchForRoomIdByName( const QString &pName )
{
    auto request = QSharedPointer<RestSpotlightRequest>::create( pName );
    std::function<void ( QNetworkReply *, QJsonObject data, RestApi * )> success = [ = ]( QNetworkReply *, QJsonObject data, RestApi * ) {

        if ( data.contains( QStringLiteral( "result" ) ) ) {
            QJsonObject result = data[QStringLiteral( "result" )].toObject();

            if ( result.contains( QStringLiteral( "users" ) ) ) {
                QJsonArray users = result[QStringLiteral( "users" )].toArray();

                for ( auto user : users ) {
                    QJsonObject userObj = user.toObject();

                    if ( userObj.contains( QStringLiteral( "username" ) ) && userObj.contains( QStringLiteral( "_id" ) ) ) {
                        QString username = userObj[QStringLiteral( "username" )].toString();

                        if ( !username.compare( pName, Qt::CaseInsensitive ) ) {
                            QString id = userObj[QStringLiteral( "_id" )].toString();
                            switchChannel( QStringLiteral( "default" ), id, pName, "d" );
                        }
                    }
                }
            } else if ( result.contains( QStringLiteral( "rooms" ) ) ) {
                QJsonArray rooms = result[QStringLiteral( "rooms" )].toArray();

                for ( const auto room : rooms ) {
                    QJsonObject roomObj = room.toObject();

                    if ( roomObj.contains( QStringLiteral( "name" ) ) && roomObj.contains( QStringLiteral( "_id" ) ) ) {
                        QString roomname = roomObj[QStringLiteral( "name" )].toString();

                        if ( !roomname.compare( pName, Qt::CaseInsensitive ) ) {
                            QString id = roomObj[QStringLiteral( "_id" )].toString();
                            switchChannel( QStringLiteral( "default" ), id, pName, "c" );
                        }
                    }
                }
            }
        }

        mPendingSwitchRoomRequest.clear();
        mPendingSwitchRoomRequestType.clear();

    };
    request->setSuccess( success );
    sendApiRequest( request );
}

void RocketChatServerData::blockUser( const QString &pChannelId )
{
    auto userId = pChannelId;
    userId.replace( mUserId, "" );

    if ( userId == pChannelId ) {
        QString possibleRoom1 = userId + mUserId;
        QString possibleRoom2 = mUserId + userId;

        auto blockRequest1 = QSharedPointer<RocketChatBlockUserRequest>::create( possibleRoom1, userId );
        auto blockRequest2 = QSharedPointer<RocketChatBlockUserRequest>::create( possibleRoom2, userId );

        sendDdprequest( blockRequest1 );
        sendDdprequest( blockRequest2 );


    } else {
        auto blockRequest = QSharedPointer<RocketChatBlockUserRequest>::create( pChannelId, userId );
        sendDdprequest( blockRequest );
    }
}

void RocketChatServerData::unBlockUser( const QString &pChannelId )
{
    auto userId = pChannelId;
    userId.replace( mUserId, "" );

    if ( userId == pChannelId ) {
        QString possibleRoom1 = userId + mUserId;
        QString possibleRoom2 = mUserId + userId;
        auto unBlockRequest1 = QSharedPointer<RocketChatUnblockUserRequest>::create( possibleRoom1, userId );
        auto unBlockRequest2 = QSharedPointer<RocketChatUnblockUserRequest>::create( possibleRoom2, userId );
        sendDdprequest( unBlockRequest1 );
        sendDdprequest( unBlockRequest2 );
    } else {
        auto unBlockRequest = QSharedPointer<RocketChatUnblockUserRequest>::create( pChannelId, userId );
        sendDdprequest( unBlockRequest );
    }
}

QString RocketChatServerData::getUserId() const
{
    return mUserId;
}

void RocketChatServerData::setUserId( const QString &userId )
{
    auto users = Models::getUsersModel();
    auto user = users->getUserById( userId );

    if ( user.isNull() && !userId.isEmpty() ) {
        user = QSharedPointer<RocketChatUser>::create( userId ) ; //QSharedPointer<RocketChatUser>( new RocketChatUser( userId ) );
        auto result = QMetaObject::invokeMethod( userModel, "addUser", Q_ARG( User, user ) );
        Q_ASSERT( result );
    }

    if ( !user.isNull() && !userId.isEmpty() ) {
        mUserId = userId;

        connect( user.data(), &RocketChatUser::statusChanged, this, [ = ]() {
            emit userStatusChanged( static_cast<int>( user->getStatus() ) );
        } );
    }
}

void RocketChatServerData::disconnectFromServer()
{
    mConnectionState = ConnectionState::OFFLINE;
    mDdpApi->disconnectFromServer();
}

void RocketChatServerData::loadHistories()
{
    QStringList channelIds;

    for ( const auto &currentChannel : mChannels->getElements() ) {
        if ( Q_LIKELY( !currentChannel.isNull() && currentChannel->getJoined() ) ) {
            //joinChannel( currentChannel->getRoomId() );
            channelIds.append( currentChannel->getRoomId() );
        }
    }

    auto request = QSharedPointer<LoadHistoryServiceRequest>::create( channelIds, 1 );

    request->setLimit( 1 );
    request->setSuccess( historyLoaded );
    request->setNoLastThreeDays( true );
    mMessageService->loadHistory( request );
}

void RocketChatServerData::loadHistoryTill( const QString &pChannelId, qint64 pTs )
{

    std::function<void ( QMultiMap<QString, QSharedPointer<RocketChatMessage>> *messages )> success = [ = ]( QMultiMap<QString, QSharedPointer<RocketChatMessage>> *messages ) {
        historyLoaded( messages );
    };
    auto request = QSharedPointer<LoadHistoryServiceRequest>::create( pChannelId );
    request->setEnd( pTs );
    request->setLimit( 0 );
    request->setSuccess( success );
    request->setNoLastThreeDays( true );
    request->setStart( 0 );
    request->setSource( LoadHistoryServiceRequest::Source::SERVER );

    mMessageService->loadHistory( request );
}

void RocketChatServerData::onUsersLoaded( const QString &pChannelId, const QVector<QSharedPointer<RocketChatUser> > &pUserList )
{
    if ( Q_LIKELY( mChannels->contains( pChannelId ) ) ) {
        auto channel = mChannels->get( pChannelId );

        if ( !channel.isNull() ) {
            for ( const auto &user : pUserList ) {
                if ( !user.isNull() ) {
                    channel->addUser( user );
                    auto result = QMetaObject::invokeMethod( userModel, "insertUser", Q_ARG( QString, pChannelId ), Q_ARG( User, user ) );
                    Q_ASSERT( result );
                }
            }
        }
    }
}

void RocketChatServerData::onUnreadCountChanged()
{
    uint number = 0;
    qDebug() << "on Unread count changed";

    for ( const auto &channel : mChannels->getElements() ) {
        if ( !channel.isNull() ) {
            number += channel->getUnreadMessages();
        }
    }

    emit unreadCountChanged( QStringLiteral( "default" ), number );
}

bool RocketChatServerData::handlesMessage( const QJsonObject &message )
{
    qDebug() << "RocketChatServerData message handler";
    onDDPMessageReceived( message );
    return true;
}

EmojiRepo *RocketChatServerData::getEmojiRepo() const
{
    return mEmojiRepo;
}

void RocketChatServerData::setEmojiRepo( EmojiRepo *emojiRepo )
{
    mEmojiRepo = emojiRepo;
}

void RocketChatServerData::createAccount( const QString &username, const QString &email, const QString &password )
{
    auto request = QSharedPointer<RocketChatCreateAccount>::create( username, email, password );
    sendDdprequest( request );
}

void RocketChatServerData::offlineLogin()
{
    QString userId = mStorage->getUserId();
    QString userName = mStorage->getUserName();

    if ( !userId.isEmpty() && !userName.isEmpty() ) {
        setUserId( userId );
        emit loggedIn( QStringLiteral( "default" ) );
    }
}

void RocketChatServerData::wipeDbAndReconnect()
{
    disconnectFromServer();
    mStorage->wipeDb();
    resume();
}

QSharedPointer<RocketChatUser> RocketChatServerData::getOwnUser() const
{
    return mOwnUser;
}

void RocketChatServerData::setOwnUser( const QSharedPointer<RocketChatUser> &ownUser )
{
    mOwnUser = ownUser;
}

QString RocketChatServerData::getBaseUrl() const
{
    QString protocol = "https://";

    if ( mDdpApi->getUnsecure() ) {
        protocol = "http://";
    }

    return protocol + mBaseUrl;
}

void RocketChatServerData::login( const QString &pUsername, const QString &pPassword )
{
    QString pass;

    QByteArray hashArray = QCryptographicHash::hash( pPassword.toUtf8(), QCryptographicHash::Sha256 );
    pass = hashArray.toHex();

    loginWithHash( pUsername, pass );
}

void RocketChatServerData::loginWithHash( const QString &pUsername, const QString &pPswHash )
{
    qDebug() << "login with hash";

    RestRequestCallback meCallBackSuccess = [ = ]( QNetworkReply *, QJsonObject data, RestApi * ) {

        if ( data.contains( QStringLiteral( "username" ) ) ) {
            mUsername = data[QStringLiteral( "username" )].toString();
            mStorage->transaction();
            mStorage->setUserData( mUsername, "" );
            mStorage->setToken( mResumeToken, mTokenExpire );
            mStorage->setUserId( mUserId );
            mStorage->askForcommit();
            onResume();
            onDDPAuthenticated();
        }

    };
    auto request = QSharedPointer<DDPLoginRequest>::create( pUsername, pPswHash );

    DdpCallback success = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
        qDebug() << "authenticated";

        if ( pResponse.contains( QStringLiteral( "result" ) ) ) {
            QJsonObject result = pResponse[QStringLiteral( "result" )].toObject();

            if ( result.contains( QStringLiteral( "token" ) ) && result.contains( QStringLiteral( "id" ) ) ) {
                mConnectionState = ConnectionState::ONLINE;
                mResumeToken = result[QStringLiteral( "token" )].toString();
                QJsonObject expireObject = result[QStringLiteral( "tokenExpires" )].toObject();
                double expireDouble = expireObject[QStringLiteral( "$date" )].toDouble();
                mTokenExpire = static_cast<uint>( expireDouble / 1000 );
                QString userId = result[QStringLiteral( "id" )].toString();

                setUserId( userId );
                mStorage->transaction();
                mStorage->setUserData( pUsername, pPswHash );

                mRestApi->setToken( mResumeToken );
                mRestApi->setUserId( userId );
                mStorage->askForcommit();
                mDdpApi->setToken( mResumeToken );
                mDdpApi->unsetResponseBinding( request->getFrame() );

                RestApiRequest meRequest
                    = RestApiRequest( new restMeRequest( meCallBackSuccess ) );

                mRestApi->sendRequest( meRequest );
            }
        }
    };
    DdpCallback error = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
        Q_UNUSED( pResponse );
        onLoginError();
    };

    request->setSuccess( success );
    request->setError( error );
    sendDdprequest( request, true, true );
    emit loggingIn();
    this->mUsername = pUsername;
}

void RocketChatServerData::loginWithToken( const QString &pUsername, const QString &pToken, bool pResume )
{
    Q_UNUSED( pResume );
    qDebug() << "login with token";

    qDebug() << "token from db: " << pToken;

    if ( !pToken.isEmpty() ) {
        auto self = this;
        RestRequestCallback meCallBackSuccess = [ self ]( QNetworkReply *, QJsonObject data, RestApi * ) {

            if ( data.contains( QStringLiteral( "username" ) ) ) {
                self->mUsername = data[QStringLiteral( "username" )].toString();
                self->mStorage->setUserName( self->mUsername );
                self->onResume();
                self->onDDPAuthenticated();
            }

        };

        auto request = QSharedPointer<DDPLoginRequest>::create( pToken );
        DdpCallback success = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
            qDebug() << "authenticated";
            mConnectionState = ConnectionState::ONLINE;

            if ( pResponse.contains( QStringLiteral( "result" ) ) ) {
                QJsonObject result = pResponse[QStringLiteral( "result" )].toObject();

                if ( result.contains( QStringLiteral( "token" ) ) && result.contains( QStringLiteral( "id" ) ) ) {
                    mResumeToken = result[QStringLiteral( "token" )].toString();
                    QJsonObject expireObject = result[QStringLiteral( "tokenExpires" )].toObject();
                    double expireDouble = expireObject[QStringLiteral( "$date" )].toDouble();
                    mTokenExpire = static_cast<uint>( expireDouble / 1000 );

                    QString userId = result[QStringLiteral( "id" )].toString();
                    setUserId( userId );
                    mStorage->setToken( self->mResumeToken, self->mTokenExpire );
                    mStorage->setUserId( userId );
                    mRestApi->setToken( self->mResumeToken );
                    mRestApi->setUserId( userId );
                    mDdpApi->setToken( self-> mResumeToken );
                    mDdpApi->unsetResponseBinding( request->getFrame() );

                    RestApiRequest meRequest
                        = RestApiRequest( new restMeRequest( meCallBackSuccess ) );

                    mRestApi->sendRequest( meRequest );
                }
            }
        };
        DdpCallback error = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
            Q_UNUSED( pResponse );
            qDebug() << "login error";
            //onLoginError();
            //try again with hash

            QString userDb = mStorage->getUserName();
            QString passDb = mStorage->getPassword();

            if ( !userDb.isEmpty() && !passDb.isEmpty() ) {

                loginWithHash( userDb, passDb );
            } else {
                qWarning() << "token rejected and no user+hash information present";
                onLoginError();
            }
        };

        request->setSuccess( success );
        request->setError( error );
#ifdef Q_OS_IOS
        mDdpApi->sendRequest( request );
#else
        sendDdprequest( request, true, true );
#endif
        emit loggingIn();

        this->mUsername = pUsername;
    } else {
        qDebug() << "empty token";
    }
}

void RocketChatServerData::loginWtihSamlToken( const QString &pToken )
{
    if ( !pToken.isEmpty() ) {
        qDebug() << pToken;
        
        RestRequestCallback meCallBackSuccess = [ = ]( QNetworkReply *, QJsonObject data, RestApi * ) {

            if ( data.contains( QStringLiteral( "username" ) ) ) {
                mUsername = data[QStringLiteral( "username" )].toString();
                mStorage->setUserName( mUsername );
                onResume();
                this->onDDPAuthenticated();
            }
            
        };
        
        auto request = QSharedPointer<ddpSamlLoginRequest>::create( pToken );
        DdpCallback success = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
            qDebug() << "authenticated";
            mConnectionState = ConnectionState::ONLINE;
            
            if ( pResponse.contains( QStringLiteral( "result" ) ) ) {
                QJsonObject result = pResponse[QStringLiteral( "result" )].toObject();
                
                if ( result.contains( QStringLiteral( "token" ) ) && result.contains( QStringLiteral( "id" ) ) ) {
                    this->mResumeToken = result[QStringLiteral( "token" )].toString();
                    QJsonObject expireObject = result[QStringLiteral( "tokenExpires" )].toObject();
                    double expireDouble = expireObject[QStringLiteral( "$date" )].toDouble();
                    mTokenExpire = static_cast<uint>( expireDouble / 1000 );
                    
                    QString userId = result[QStringLiteral( "id" )].toString();
                    setUserId( userId );
                    mStorage->setToken( mResumeToken, mTokenExpire );
                    mStorage->setUserId( userId );
                    mRestApi->setToken( mResumeToken );
                    mRestApi->setUserId( userId );
                    mDdpApi->setToken( mResumeToken );
                    mDdpApi->unsetResponseBinding( request->getFrame() );
                    
                    
                    RestApiRequest meRequest
                        = RestApiRequest( new restMeRequest( meCallBackSuccess ) );

                    mRestApi->sendRequest( meRequest );
                    
                    
                    
                }
            }
        };
        DdpCallback error = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
            Q_UNUSED( pResponse );
            qDebug() << "login error";
            qWarning() << "SAML2 token rejected";
            onLoginError();
        };
        
        request->setSuccess( success );
        request->setError( error );
        sendDdprequest( request, true, true );
        emit loggingIn();

    } else {
        qDebug() << "empty token";
    }
}

void RocketChatServerData::loginWithOpenIDToken( const QString &pToken, const QString &pSecret )
{
    if ( !pToken.isEmpty() && !pSecret.isEmpty() ) {
        auto self = this;
        RestRequestCallback meCallBackSuccess = [ self ]( QNetworkReply *, QJsonObject data, RestApi * ) {

            if ( data.contains( QStringLiteral( "username" ) ) ) {
                self->mUsername = data[QStringLiteral( "username" )].toString();
                self->mStorage->transaction();
                self->mStorage->setUserData( self->mUsername, "" );
                self->mStorage->setToken( self->mResumeToken, self->mTokenExpire );
                self->mStorage->setUserId( self->mUserId );
                self->mStorage->askForcommit();
                self->onResume();
                self->onDDPAuthenticated();
            }

        };

        auto request = QSharedPointer<DDPOpenIDLoginRequest>::create( pToken, pSecret );
        DdpCallback success = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
            qDebug() << "authenticated";
            self->mConnectionState = ConnectionState::ONLINE;

            if ( pResponse.contains( QStringLiteral( "result" ) ) ) {
                QJsonObject result = pResponse[QStringLiteral( "result" )].toObject();

                if ( result.contains( QStringLiteral( "token" ) ) && result.contains( QStringLiteral( "id" ) ) ) {
                    mConnectionState = ConnectionState::ONLINE;
                    mResumeToken = result[QStringLiteral( "token" )].toString();
                    QJsonObject expireObject = result[QStringLiteral( "tokenExpires" )].toObject();
                    double expireDouble = expireObject[QStringLiteral( "$date" )].toDouble();
                    mTokenExpire = static_cast<uint>( expireDouble / 1000 );

                    QString userId = result[QStringLiteral( "id" )].toString();

                    setUserId( userId );
                    mRestApi->setToken( mResumeToken );
                    mRestApi->setUserId( userId );
                    mDdpApi->setToken( mResumeToken );
                    mDdpApi->unsetResponseBinding( request->getFrame() );

                    // emit onHashLoggedIn( self->mServerId ) ;

                    RestApiRequest meRequest
                        = RestApiRequest( new restMeRequest( meCallBackSuccess ) );

                    self->mRestApi->sendRequest( meRequest );

                }
            }
        };
        DdpCallback error = [ = ]( QJsonObject pResponse, MeteorDDP * ) {
            Q_UNUSED( pResponse );
            qDebug() << "login error";

            qWarning() << "token rejected and no user+hash information present";
            onLoginError();
        };

        request->setSuccess( success );
        request->setError( error );
        sendDdprequest( request, true, true );
        emit loggingIn();


    } else {
        qDebug() << "empty token";
    }
}

void RocketChatServerData::loginWithMethod( const QString &method, const QString &payload )
{
    if ( mLoginMethodRepo.contains( method ) ) {
        LoginMethod loginMethod = mLoginMethodRepo[method];

        if ( loginMethod.getType() == LoginMethod::Type::OPENID ) {
            QString token;
            QString secret;
            QJsonDocument doc = QJsonDocument::fromJson( payload.toUtf8() );
            QJsonObject obj = doc.object();

            if ( obj.contains( QStringLiteral( "credentialToken" ) ) && obj.contains( QStringLiteral( "credentialSecret" ) ) ) {
                token = obj[QStringLiteral( "credentialToken" )].toString();
                secret = obj[QStringLiteral( "credentialSecret" )].toString();
                // if app went offline during webview
                disconnectFromServer();