/********************************************************************************************
* *
* 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 "messagemodel.h"
#include <repos/entities/rocketchatreplymessage.h>
MessagesModel::MessagesModel()
{
duplicateCheck.reserve( 10000 );
}
QVariant MessagesModel::data( const QModelIndex &index, int role ) const
{
int row = index.row();
QSharedPointer<RocketChatMessage> messageAtIndex = messagesOfCurrentChannel.at( row );
auto roleType = static_cast<MessageRoles>( role );
switch ( roleType ) {
case MessageRoles::type:
return messageAtIndex->getMessageType();
case MessageRoles::text:
return messageAtIndex->getMessageString();
case MessageRoles::linkurl:
if ( !messageAtIndex->getAttachments().empty() ) {
return messageAtIndex->getAttachments().first()->getUrl();
} else {
qWarning() << "linkurl not found";
}
break;
case MessageRoles::author:
return messageAtIndex->getAuthor();
case MessageRoles::authorId:
return messageAtIndex->getAuthorId();
case MessageRoles::date:
return messageAtIndex->getFormattedDate();
case MessageRoles::time:
return messageAtIndex->getFormattedTime();
case MessageRoles::ownMessage:
return messageAtIndex->getOwnMessage();
case MessageRoles::width:
if ( !messageAtIndex->getAttachments().empty() ) {
return messageAtIndex->getAttachments().first()->getWidth();
} else {
qWarning() << "width not found";
}
break;
case MessageRoles::height:
if ( !messageAtIndex->getAttachments().empty() ) {
return messageAtIndex->getAttachments().first()->getHeight();
} else {
qWarning() << "height not found";
}
break;
case MessageRoles::formattedDate:
return messageAtIndex->getFormattedDate();
case MessageRoles::formattedTime:
return messageAtIndex->getFormattedTime();
case MessageRoles::messageType:
return messageAtIndex->getMessageType();
case MessageRoles::blocked:
return mBlockedUsers.contains( messageAtIndex->getAuthorId() );
case MessageRoles::id:
return messageAtIndex->getId();
case MessageRoles::replyMessage: {
QList<QSharedPointer<RocketChatAttachment> > attachments = messageAtIndex->getAttachments();
if ( attachments.size() ) {
QSharedPointer<RocketChatAttachment> first = attachments.first();
QSharedPointer<RocketChatReplyMessage> msg = qSharedPointerCast<RocketChatReplyMessage>( first );
return msg->getMessageString();
}
}
break;
case MessageRoles::replyAutor: {
QList<QSharedPointer<RocketChatAttachment> > attachments = messageAtIndex->getAttachments();
if ( attachments.size() ) {
QSharedPointer<RocketChatAttachment> first = attachments.first();
QSharedPointer<RocketChatReplyMessage> msg = qSharedPointerCast<RocketChatReplyMessage>( first );
return msg->getAuthor();
}
}
break;
case MessageRoles::replyUrl: {
QString server = messageAtIndex->getServer();
auto currentChannel = mChannelMap[current];
QString type = currentChannel->getType();
QString name = currentChannel->getName();
if ( type == "p" ) {
type = "group";
} else if ( type == "c" ) {
type = "channel";
} else if ( type == "d" ) {
type = "direct";
name = currentChannel->getUsername();
}
return server + "/" + type + "/" + name + "?msg=" + messageAtIndex->getId();
}
case MessageRoles::replyDate:
//TODO: implement or remove!
break;
}
qWarning() << "MessagesModel data not found for row";
return QVariant();
}
QString MessagesModel::getCurrent() const
{
return current;
}
void MessagesModel::setCurrent( const QString &value )
{
QMutexLocker( &this->mutex );
current = value;
beginResetModel();
if ( mChannelMap.contains( value ) ) {
messagesOfCurrentChannel = mChannelMap[value]->getMessageRepo()->timestampIndex().values().toVector();
duplicateCheck.clear();
for ( auto currentMessage : messagesOfCurrentChannel ) {
duplicateCheck.insert( currentMessage->getId() );
}
} else {
duplicateCheck.clear();
messagesOfCurrentChannel.clear();
/* QSharedPointer<RocketChatChannel> dummyChannel (new RocketChatChannel());
dummyChannel->setRoomId(value);
addChannel(dummyChannel); */
}
endResetModel();
emit countChanged();
}
int MessagesModel::rowCount( const QModelIndex &parent ) const
{
Q_UNUSED( parent );
qDebug() << "number of messages in model" << messagesOfCurrentChannel.count();
int count = 0;
if ( messagesOfCurrentChannel.isEmpty() ) {
return 0;
}
count = messagesOfCurrentChannel.count();
return count;
}
int MessagesModel::getPositionOfMessage( const QString &pId )
{
int pos = -1;
for ( int i = 0; i < messagesOfCurrentChannel.size(); i++ ) {
auto element = messagesOfCurrentChannel.at( i );
if ( element->getId() == pId ) {
pos = i;
break;
}
}
return pos;
}
bool MessagesModel::addChannel( const QSharedPointer<RocketChatChannel> &channel )
{
QString id = channel->getRoomId();
if ( mChannelMap.contains( id ) ) {
return false;
}
mChannelMap.insert( id, channel );
connect( channel.data(), &RocketChatChannel::messageAdded, this, [ = ]( const QString & id, qint64 timestamp ) {
Q_UNUSED( id )
onNewMessage( channel, timestamp );
} );
return true;
}
void MessagesModel::addBlockedUser( const QString &pUserId )
{
beginResetModel();
mBlockedUsers.insert( pUserId );
endResetModel();
}
QHash<int, QByteArray> MessagesModel::roleNames() const
{
QHash<int, QByteArray> roles;
roles[static_cast<int>( MessageRoles::text )] = QByteArrayLiteral( "msg" );
roles[static_cast<int>( MessageRoles::author )] = QByteArrayLiteral( "author" );
roles[static_cast<int>( MessageRoles::authorId )] = QByteArrayLiteral( "authorId" );
roles[static_cast<int>( MessageRoles::linkurl )] = QByteArrayLiteral( "linkurl" );
roles[static_cast<int>( MessageRoles::type )] = QByteArrayLiteral( "type" );
roles[static_cast<int>( MessageRoles::date )] = QByteArrayLiteral( "date" );
roles[static_cast<int>( MessageRoles::time )] = QByteArrayLiteral( "time" );
roles[static_cast<int>( MessageRoles::ownMessage )] = QByteArrayLiteral( "ownMessage" );
roles[static_cast<int>( MessageRoles::height )] = QByteArrayLiteral( "height" );
roles[static_cast<int>( MessageRoles::width )] = QByteArrayLiteral( "width" );
roles[static_cast<int>( MessageRoles::formattedDate )] = QByteArrayLiteral( "formattedDate" );
roles[static_cast<int>( MessageRoles::formattedTime )] = QByteArrayLiteral( "formattedTime" );
roles[static_cast<int>( MessageRoles::messageType )] = QByteArrayLiteral( "messageType" );
roles[static_cast<int>( MessageRoles::blocked )] = QByteArrayLiteral( "blocked" );
roles[static_cast<int>( MessageRoles::id )] = QByteArrayLiteral( "id" );
roles[static_cast<int>( MessageRoles::replyMessage )] = QByteArrayLiteral( "replyMessage" );
roles[static_cast<int>( MessageRoles::replyAutor )] = QByteArrayLiteral( "replyAutor" );
roles[static_cast<int>( MessageRoles::replyDate )] = QByteArrayLiteral( "replyDate" );
roles[static_cast<int>( MessageRoles::replyUrl )] = QByteArrayLiteral( "replyUrl" );
return roles;
}
void MessagesModel::onNewMessage( const QSharedPointer<RocketChatChannel> &channel, qint64 timestamp )
{
QMutexLocker( &this->mutex );
if ( timestamp == 0 ) {
setCurrent( current );
}
if ( channel->getRoomId() == current ) {
auto message = channel->getMessageRepo()->timestampIndex()[timestamp];
if ( message.isNull() ) {
return;
}
int row = messagesOfCurrentChannel.findPosition( message );
if ( !duplicateCheck.contains( message->getId() ) ) {
beginInsertRows( QModelIndex(), row, row );
messagesOfCurrentChannel.insert( row, message );
mInsertCount++;
endInsertRows();
duplicateCheck.insert( message->getId() );
}
if ( !buffered ) {
mInsertCount = 0;
emit countChanged();
}
}
}
void MessagesModel::onBeginInsertList( const QString &pChannelId )
{
if ( pChannelId == current ) {
buffered = true;
mInsertCount = 0;
}
}
void MessagesModel::onEndInsertList( const QString &pChannelId )
{
if ( pChannelId == current ) {
buffered = false;
if ( mInsertCount ) {
mInsertCount = 0;
emit countChanged();
}
}
}
void MessagesModel::addChannelSlot( const QSharedPointer<RocketChatChannel> &channel )
{
addChannel( channel );
}