File indexing completed on 2024-05-05 05:40:26

 /***************************************************************************
  *  Copyright (C) 2020 by Renaud Guezennec                               *
  *   http://www.rolisteam.org/contact                                      *
  *                                                                         *
  *   This software 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 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  *   This program 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 this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 #include "data/chatroom.h"
 
 #include <QtConcurrent>
 #include <set>
 
 #include "model/playermodel.h"
 #include "worker/utilshelper.h"
 #include <diceparser_qobject/diceroller.h>
 
 namespace InstantMessaging
 {
 namespace
 {
 InstantMessaging::MessageInterface::MessageType textToType(const QString& text)
 {
     auto type= InstantMessaging::MessageInterface::Text;
     if(text.startsWith("!"))
         type= InstantMessaging::MessageInterface::Dice;
     else if(text.startsWith("/"))
         type= InstantMessaging::MessageInterface::Command;
 
     return type;
 }
 } // namespace
 ChatRoom::ChatRoom(PlayerModel* model, ChatRoomType type, const QStringList& recipiants, const QString& id,
                    QObject* parent)
     : QObject(parent)
     , m_recipiants(new FilteredPlayerModel(recipiants))
     , m_messageModel(new MessageModel(model))
     , m_type(type)
     , m_uuid(id)
 {
     connect(m_messageModel.get(), &MessageModel::localIdChanged, this, &ChatRoom::localIdChanged);
     connect(m_messageModel.get(), &MessageModel::unreadMessageChanged, this, [this]() { setUnreadMessage(true); });
 }
 
 ChatRoom::~ChatRoom()= default;
 
 MessageModel* ChatRoom::messageModel() const
 {
     return m_messageModel.get();
 }
 
 bool ChatRoom::unreadMessage() const
 {
     return m_unreadMessage;
 }
 
 QString ChatRoom::uuid() const
 {
     return m_uuid;
 }
 
 QString ChatRoom::localId() const
 {
     return m_messageModel->localId();
 }
 
 FilteredPlayerModel* ChatRoom::recipiants() const
 {
     return m_recipiants.get();
 }
 
 QString ChatRoom::title() const
 {
     return m_title;
 }
 
 ChatRoom::ChatRoomType ChatRoom::type() const
 {
     return m_type;
 }
 
 int ChatRoom::recipiantCount() const
 {
     return m_recipiants->rowCount();
 }
 
 void ChatRoom::setUuid(const QString& id)
 {
     if(id == m_uuid)
         return;
     m_uuid= id;
     emit uuidChanged(m_uuid);
 }
 
 void ChatRoom::setTitle(const QString& title)
 {
     if(m_title == title)
         return;
     m_title= title;
     emit titleChanged(m_title);
 }
 
 void ChatRoom::setUnreadMessage(bool b)
 {
     if(b == m_unreadMessage)
         return;
     m_unreadMessage= b;
     emit unreadMessageChanged(m_unreadMessage);
 }
 
 void ChatRoom::addMessage(const QString& text, const QUrl& url, const QString& personId, const QString& personName)
 {
     auto type= textToType(text);
     using IM= InstantMessaging::MessageInterface;
     bool valid= false;
     if(type == IM::Dice)
     { // dice
         auto command= text;
         valid= rollDice(command.remove(0, 1), personId);
     }
     else if(type == IM::Command)
     {
         auto command= text;
         valid= runCommand(command.remove(0, 1), personId, personName);
     }
 
     if(type == IM::Text || !valid)
     {
         m_messageModel->addMessage(text, url, QDateTime::currentDateTime(), localId(),
                                    personId.isEmpty() ? localId() : personId, type);
     }
 }
 
 bool ChatRoom::rollDice(const QString& command, const QString& personId)
 {
     using IM= InstantMessaging::MessageInterface;
     auto id= personId.isEmpty() ? localId() : personId;
 
     helper::utils::setContinuation<std::pair<bool, QString>>(
         QtConcurrent::run(
             [this, command, id]() -> std::pair<bool, QString>
             {
                 if(!m_diceParser)
                     return {false, tr("No Diceparser Object")};
 
                 auto diceParser= m_diceParser->parser();
 
                 if(!diceParser->parseLine(command))
                 {
                     auto error= diceParser->humanReadableError();
                     return {false, error};
                 }
 
                 diceParser->start();
                 auto error= diceParser->humanReadableError();
                 if(!error.isEmpty())
                     return {false, error};
 
                 auto result= diceParser->resultAsJSon(
                     [](const QString& value, const QString& color, bool highlight)
                     {
                         QString resultTmp= value;
                         bool hasColor= !color.isEmpty();
                         QString style;
                         if(hasColor)
                         {
                             style+= QStringLiteral("color:%1;").arg(color);
                         }
                         if(highlight)
                         {
                             if(style.isEmpty())
                                 style+= QStringLiteral("color:%1;")
                                             .arg("red"); // default color must get the value from the setting object
                             style+= QStringLiteral("font-weight:bold;");
                         }
                         if(!style.isEmpty())
                             resultTmp= QString("<span style=\"%2\">%1</span>").arg(value).arg(style);
                         return resultTmp;
                     });
                 return {true, result};
             }),
         this,
         [this, id](const std::pair<bool, QString>& result)
         {
             m_messageModel->addMessage(result.second, {}, QDateTime::currentDateTime(), localId(), id,
                                        result.first ? IM::Dice : IM::Error);
         });
 
     return true;
 }
 
 bool ChatRoom::runCommand(const QString& command, const QString& personId, const QString& personName)
 {
     QStringList meCommand({"emote ", "me ", "em ", "e "});
     auto text= command;
     for(auto const& e : qAsConst(meCommand))
     {
         if(text.startsWith(e))
         {
             text.remove(0, e.size());
             text= QString("<i>%2 %1<\\i>").arg(text).arg(personName);
             m_messageModel->addMessage(text, {}, QDateTime::currentDateTime(), localId(),
                                        personId.isEmpty() ? localId() : personId,
                                        InstantMessaging::MessageInterface::Command);
             return true;
         }
     }
 
     return false;
 }
 
 void ChatRoom::addMessageInterface(MessageInterface* message)
 {
     m_messageModel->addMessageInterface(message);
 }
 
 void ChatRoom::setLocalId(const QString& id)
 {
     m_messageModel->setLocalId(id);
 }
 bool ChatRoom::hasRecipiant(const QString& id)
 {
     return m_recipiants->hasRecipiant(id);
 }
 
 void ChatRoom::setDiceParser(DiceRoller* diceParser)
 {
     m_diceParser= diceParser;
 }
 } // namespace InstantMessaging