mucroom.h

/*
  Copyright (c) 2006-2023 by Jakob Schröter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox
 
  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.
 
  This software is distributed without any warranty.
*/
 
 
 
#ifndef MUCROOM_H__
#define MUCROOM_H__
 
#include "discohandler.h"
#include "disconodehandler.h"
#include "dataform.h"
#include "presencehandler.h"
#include "iqhandler.h"
#include "messagehandler.h"
#include "mucroomhandler.h"
#include "mucroomconfighandler.h"
#include "jid.h"
#include "stanzaextension.h"
 
#include <string>
 
namespace gloox
{
 
  class ClientBase;
  class MUCMessageSession;
  class Message;
 
  class GLOOX_API MUCRoom : private DiscoHandler, private PresenceHandler,
                            public IqHandler, private MessageHandler, private DiscoNodeHandler
  {
    public:
      enum HistoryRequestType
      {
        HistoryMaxChars,            
        HistoryMaxStanzas,          
        HistorySeconds,             
        HistorySince,               
        HistoryUnknown              
      };
 
      enum MUCUserOperation
      {
        OpNone,                 
        OpInviteTo,             
        OpInviteFrom,           
        OpDeclineTo,            
        OpDeclineFrom           
      };
 
      class MUC : public StanzaExtension
      {
        public:
          MUC( const std::string& password, HistoryRequestType historyType = HistoryUnknown,
               const std::string& historySince = EmptyString, int historyValue = 0 );
 
          MUC( const Tag* tag = 0 );
 
          virtual ~MUC();
 
          const std::string* password() const { return m_password; }
 
          const std::string* historySince() const { return m_historySince; }
 
          // reimplemented from StanzaExtension
          virtual const std::string& filterString() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* newInstance( const Tag* tag ) const
          {
            return new MUC( tag );
          }
 
          // reimplemented from StanzaExtension
          virtual Tag* tag() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* clone() const
          {
            MUC* m = new MUC();
            m->m_password = m_password ? new std::string( *m_password ) : 0;
            m->m_historySince = m_historySince ? new std::string( *m_historySince ) : 0;
            m->m_historyType = m_historyType;
            m->m_historyValue = m_historyValue;
            return m;
          }
 
        private:
          std::string* m_password;
          std::string* m_historySince;
          HistoryRequestType m_historyType;
          int m_historyValue;
      };
 
      class MUCUser : public StanzaExtension
      {
        public:
          MUCUser( MUCUserOperation operation, const std::string& to, const std::string& reason,
                   const std::string& thread = EmptyString );
 
          MUCUser( const Tag* tag = 0 );
 
          virtual ~MUCUser();
 
          int flags() const { return m_flags; }
 
          MUCRoomAffiliation affiliation() const { return m_affiliation; }
 
          MUCRoomRole role() const { return m_role; }
 
          const std::string* jid() const { return m_jid; }
 
          const std::string* actor() const { return m_actor; }
 
          const std::string* password() const { return m_password; }
 
          const std::string* thread() const { return m_thread; }
 
          const std::string* reason() const { return m_reason; }
 
          const std::string* newNick() const { return m_newNick; }
 
          const std::string* alternate() const { return m_alternate; }
 
          bool continued() const { return m_continue; }
 
          MUCUserOperation operation() const { return m_operation; }
 
          // reimplemented from StanzaExtension
          virtual const std::string& filterString() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* newInstance( const Tag* tag ) const
          {
            return new MUCUser( tag );
          }
 
          // reimplemented from StanzaExtension
          virtual Tag* tag() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* clone() const
          {
            MUCUser* m = new MUCUser();
            m->m_affiliation = m_affiliation;
            m->m_role = m_role;
            m->m_jid = m_jid ? new std::string( *m_jid ) : 0;
            m->m_actor = m_actor ? new std::string( *m_actor ) : 0;
            m->m_thread = m_thread ? new std::string( *m_thread ) : 0;
            m->m_reason = m_reason ? new std::string( *m_reason ) : 0;
            m->m_newNick = m_newNick ? new std::string( *m_newNick ) : 0;
            m->m_password = m_password ? new std::string( *m_password ) : 0;
            m->m_alternate = m_alternate ? new std::string( *m_alternate ) : 0;
            m->m_operation = m_operation;
            m->m_flags = m_flags;
            m->m_del = m_del;
            m->m_continue = m_continue;
            return m;
          }
 
        private:
          static MUCRoomAffiliation getEnumAffiliation( const std::string& affiliation );
          static MUCRoomRole getEnumRole( const std::string& role );
 
 
          MUCRoomAffiliation m_affiliation;
          MUCRoomRole m_role;
          std::string* m_jid;
          std::string* m_actor;
          std::string* m_thread;
          std::string* m_reason;
          std::string* m_newNick;
          std::string* m_password;
          std::string* m_alternate;
          MUCUserOperation m_operation;
          int m_flags;
          bool m_del;
          bool m_continue;
      };
 
      MUCRoom( ClientBase* parent, const JID& nick, MUCRoomHandler* mrh, MUCRoomConfigHandler* mrch = 0 );
 
      virtual ~MUCRoom();
 
      void setPassword( const std::string& password ) { m_password = password; }
 
      const std::string name() const { return m_nick.username(); }
 
      const std::string service() const { return m_nick.server(); }
 
      const std::string nick() const { return m_nick.resource(); }
 
      virtual void join( Presence::PresenceType type = Presence::Available,
                         const std::string& status = EmptyString,
                         int priority = 0 );
 
      void leave( const std::string& msg = EmptyString );
 
      void send( const std::string& message );
 
      void send( const std::string& message, const std::string& subject, const StanzaExtensionList& sel = StanzaExtensionList() );
 
      void setSubject( const std::string& subject );
 
      MUCRoomAffiliation affiliation() const { return m_affiliation; }
 
      MUCRoomRole role() const { return m_role; }
 
      void setNick( const std::string& nick );
 
      void setPresence( Presence::PresenceType presence, const std::string& msg = EmptyString );
 
      void invite( const JID& invitee, const std::string& reason, const std::string& thread = EmptyString );
 
      void getRoomInfo();
 
      void getRoomItems();
 
      void setPublish( bool publish, bool publishNick );
 
      void registerMUCRoomHandler( MUCRoomHandler* mrl ) { m_roomHandler = mrl; }
 
      void removeMUCRoomHandler() { m_roomHandler = 0; }
 
      void registerMUCRoomConfigHandler( MUCRoomConfigHandler* mrch ) { m_roomConfigHandler = mrch; }
 
      void removeMUCRoomConfigHandler() { m_roomConfigHandler = 0; }
 
      void addHistory( const std::string& message, const JID& from, const std::string& stamp );
 
      void setRequestHistory( int value, HistoryRequestType type );
 
      void setRequestHistory( const std::string& since );
 
      static Message* declineInvitation( const JID& room, const JID& invitor,
                                     const std::string& reason = EmptyString);
 
      void requestVoice();
 
      void kick( const std::string& nick, const std::string& reason = EmptyString )
        { setRole( nick, RoleNone, reason ); }
 
      void ban( const std::string& nick, const std::string& reason )
        { setAffiliation( nick, AffiliationOutcast, reason ); }
 
      void grantVoice( const std::string& nick, const std::string& reason )
        { setRole( nick, RoleParticipant, reason ); }
 
      static Message* createDataForm( const JID& room, const DataForm* df );
 
      void revokeVoice( const std::string& nick, const std::string& reason )
        { setRole( nick, RoleVisitor, reason ); }
 
      void setRole( const std::string& nick, MUCRoomRole role, const std::string& reason = EmptyString );
 
      void setAffiliation( const std::string& nick, MUCRoomAffiliation affiliation,
                           const std::string& reason );
 
      void requestRoomConfig();
 
      void setRoomConfig( DataForm* form );
 
      void acknowledgeInstantRoom()
        { instantRoom( CreateInstantRoom ); }
 
      void cancelRoomCreation()
        { instantRoom( CancelRoomCreation ); }
 
      void destroy( const std::string& reason = EmptyString,
                    const JID& alternate = JID(), const std::string& password = EmptyString );
 
      void requestList( MUCOperation operation );
 
      void storeList( const MUCListItemList items, MUCOperation operation );
 
      int flags() const { return m_flags; }
 
      // reimplemented from DiscoHandler
      virtual void handleDiscoInfo( const JID& from, const Disco::Info& info, int context );
 
      // reimplemented from DiscoHandler
      // reimplemented from DiscoHandler
      virtual void handleDiscoItems( const JID& from, const Disco::Items& items, int context );
 
      // reimplemented from DiscoHandler
      virtual void handleDiscoError( const JID& from, const Error* error, int context );
 
      // reimplemented from PresenceHandler
      virtual void handlePresence( const Presence& presence );
 
      // reimplemented from MessageHandler
      virtual void handleMessage( const Message& msg, MessageSession* session = 0 );
 
      // reimplemented from IqHandler
      virtual bool handleIq( const IQ& iq ) { (void)iq; return false; }
 
      // reimplemented from IqHandler
      virtual void handleIqID( const IQ& iq, int context );
 
      // reimplemented from DiscoNodeHandler
      virtual StringList handleDiscoNodeFeatures( const JID& from, const std::string& node );
 
      // reimplemented from DiscoNodeHandler
      virtual Disco::IdentityList handleDiscoNodeIdentities( const JID& from,
                                                             const std::string& node );
 
      // reimplemented from DiscoNodeHandler
      virtual Disco::ItemList handleDiscoNodeItems( const JID& from, const JID& to,
                                                    const std::string& node = EmptyString );
 
    protected:
      void setName( const std::string& name ) { m_nick.setUsername( name ); }
 
      virtual bool instantRoomHook() const { return false; }
 
      ClientBase* m_parent;
      JID m_nick;
 
      bool m_joined;
 
    private:
#ifdef MUCROOM_TEST
    public:
#endif
      class MUCOwner : public StanzaExtension
      {
        public:
 
          enum QueryType
          {
            TypeCreate,             
            TypeRequestConfig,      
            TypeSendConfig,         
            TypeCancelConfig,       
            TypeInstantRoom,        
            TypeDestroy,            
            TypeIncomingTag         
          };
 
          MUCOwner( QueryType type, DataForm* form = 0 );
 
          MUCOwner( const JID& alternate = JID(), const std::string& reason = EmptyString,
                    const std::string& password = EmptyString);
 
          MUCOwner( const Tag* tag );
 
          virtual ~MUCOwner();
 
          const DataForm* form() const { return m_form; }
 
          // reimplemented from StanzaExtension
          const std::string& filterString() const;
 
          // reimplemented from StanzaExtension
          StanzaExtension* newInstance( const Tag* tag ) const
          {
            return new MUCOwner( tag );
          }
 
          // reimplemented from StanzaExtension
          Tag* tag() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* clone() const
          {
            MUCOwner* m = new MUCOwner();
            m->m_type = m_type;
            m->m_jid = m_jid;
            m->m_reason = m_reason;
            m->m_pwd = m_pwd;
            m->m_form = m_form ? new DataForm( *m_form ) : 0;
            return m;
          }
 
        private:
          QueryType m_type;
          JID m_jid;
          std::string m_reason;
          std::string m_pwd;
          DataForm* m_form;
      };
 
      class MUCAdmin : public StanzaExtension
      {
        public:
          MUCAdmin( MUCRoomRole role, const std::string& nick,
                    const std::string& reason = EmptyString );
 
          MUCAdmin( MUCRoomAffiliation affiliation, const std::string& nick,
                    const std::string& reason = EmptyString );
 
          MUCAdmin( MUCOperation operation, const MUCListItemList& jids = MUCListItemList() );
 
          MUCAdmin( const Tag* tag = 0 );
 
          virtual ~MUCAdmin();
 
          const MUCListItemList& list() const { return m_list; }
 
          // reimplemented from StanzaExtension
          const std::string& filterString() const;
 
          // reimplemented from StanzaExtension
          StanzaExtension* newInstance( const Tag* tag ) const
          {
            return new MUCAdmin( tag );
          }
 
          // reimplemented from StanzaExtension
          Tag* tag() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* clone() const
          {
            return new MUCAdmin( *this );
          }
 
        private:
          MUCListItemList m_list;
          MUCRoomAffiliation m_affiliation;
          MUCRoomRole m_role;
      };
 
      void handleIqResult( const IQ& iq, int context );
      void handleIqError( const IQ& iq, int context );
      void setNonAnonymous();
      void setSemiAnonymous();
      void setFullyAnonymous();
      void acknowledgeRoomCreation();
      void instantRoom( int context );
 
      MUCRoomHandler* m_roomHandler;
      MUCRoomConfigHandler* m_roomConfigHandler;
      MUCMessageSession* m_session;
 
      typedef std::list<MUCRoomParticipant> ParticipantList;
      ParticipantList m_participants;
 
      std::string m_password;
      std::string m_newNick;
 
      MUCRoomAffiliation m_affiliation;
      MUCRoomRole m_role;
 
      HistoryRequestType m_historyType;
 
      std::string m_historySince;
      int m_historyValue;
      int m_flags;
      bool m_creationInProgress;
      bool m_configChanged;
      bool m_publishNick;
      bool m_publish;
      bool m_unique;
 
  };
 
}
 
#endif // MUCROOM_H__