usermodel.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 "usermodel.h"

UserModel::UserModel( QObject *parent ): QAbstractListModel( parent )
{

}

int UserModel::rowCount( const QModelIndex &parent ) const
{
    Q_UNUSED( parent );
    int count = userOfCurrentChannel.count();
    qDebug() << "count  of current channel users" << count;
    return count;
}

QVariant UserModel::data( const QModelIndex &index, int role ) const
{
    auto userList = userOfCurrentChannel.values();

    if ( userList.count() < index.row() ) {
        return QVariant();
    }

    auto user = userList.at( index.row() );

    if ( role == UserRoles::UserName ) {
        return user->getUserName();
    }

    if ( role == UserRoles::name ) {
        return user->getName();
    }

    if ( role == UserRoles::status ) {
        int status = 0;

        switch ( user->getStatus() ) {
            case RocketChatUser::status::ONLINE :
                status = 0;
                break;

            case RocketChatUser::status::AWAY :
                status = 1;
                break;

            case RocketChatUser::status::OFFLINE:
                status = 2;
        }

        return status;
    }

    return QVariant();
}

bool UserModel::insertUser( const QString &channelId, const QSharedPointer<RocketChatUser> &user )
{
    beginResetModel();

    if ( !user.isNull() ) {
        QSharedPointer<RocketChatUser> userToAdd;

        if ( mAllUsers.contains( user->getUserName() ) ) {
            auto oldUser = mAllUsers[user->getUserName()];

            if ( !user->getSurname().isEmpty() ) {
                oldUser->setSurname( user->getSurname() );
            }

            if ( !user->getLastname().isEmpty() ) {
                oldUser->setLastname( user->getLastname() );
            }

            if ( !user->getName().isEmpty() ) {
                oldUser->setName( user->getName() );
            }

            if ( !user->getUserId().isEmpty() ) {
                oldUser->setUserId( user->getUserId() );
            }

            userToAdd = oldUser;
        } else {
            userToAdd = user;
            mAllUsers.insert( userToAdd->getUserName(), userToAdd );
        }

        userMap.insert( channelId, userToAdd );
        setCurrent( getCurrent() );
    } else {
        return true;
    }

    endResetModel();
    //TODO: give some meainingfull return
    return true;
}

QString UserModel::getCurrent() const
{
    return current;
}

void UserModel::setCurrent( const QString &value )
{
    current = value;

    userOfCurrentChannel.clear();
    beginResetModel();
    QList<QSharedPointer<RocketChatUser>> userList = userMap.values( value );

    for ( auto current : userList ) {
        userOfCurrentChannel.insert( current->getUserName(), current );
    }

    endResetModel();
}

void UserModel::onCurrentChannelChanged( const QString &newText )
{
    current = newText;
}

QSharedPointer<RocketChatUser> UserModel::getUserByUsername( const QString &pUserName )
{
    return mAllUsers.contains( pUserName ) ? mAllUsers[pUserName] : nullptr;
}

void UserModel::addUser( QSharedPointer<RocketChatUser> pUser )
{
    if ( !pUser.isNull() ) {
        mAllUsers.insert( pUser->getUserName(), pUser );
    }
}

QHash<int, QByteArray> UserModel::roleNames() const
{
    QHash<int, QByteArray> roles;
    roles[UserName] = QByteArrayLiteral( "username" );
    roles[UserId] =  QByteArrayLiteral( "userId" );
    roles[name] = QByteArrayLiteral( "name" );
    roles[status] = QByteArrayLiteral( "status" );
    return roles;
}