adhoc.h

/*
  Copyright (c) 2004-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 ADHOC_H__
#define ADHOC_H__
 
#include "adhocplugin.h"
#include "disco.h"
#include "disconodehandler.h"
#include "discohandler.h"
#include "iqhandler.h"
#include "stanzaextension.h"
#include "mutex.h"
 
#include <string>
#include <list>
#include <map>
 
namespace gloox
{
 
  class ClientBase;
  class Stanza;
  class AdhocHandler;
  class AdhocCommandProvider;

  class GLOOX_API Adhoc : public DiscoNodeHandler, public DiscoHandler, public IqHandler
  {
    public:
      class GLOOX_API Command : public StanzaExtension
      {
        friend class Adhoc;
 
        public:

          enum Action
          {
            Execute       =  1,     
            Cancel        =  2,     
            Previous      =  4,     
            Next          =  8,     
            Complete      = 16,     
            InvalidAction = 32      
          };

          enum Status
          {
            Executing,              
            Completed,              
            Canceled,               
            InvalidStatus           
          };

          class GLOOX_API Note
          {
 
            friend class Command;
 
            public:
              enum Severity
              {
                Info,               
                Warning,            
                Error,              
                InvalidSeverity     
              };

              Note( Severity sev, const std::string& note )
                : m_severity( sev ), m_note( note ) {}

              ~Note() {}

              Severity severity() const { return m_severity; }

              const std::string& content() const { return m_note; }

              Tag* tag() const;
 
            private:
#ifdef ADHOC_COMMANDS_TEST
            public:
#endif
              Note( const Tag* tag );
 
              Severity m_severity;      
              std::string m_note;       
          };

          typedef std::list<const Note*> NoteList;

          Command( const std::string& node, const std::string& sessionid, Action action,
                   AdhocPlugin* plugin = 0 );

          Command( const std::string& node, const std::string& sessionid, Status status,
                   AdhocPlugin* plugin = 0 );

          Command( const std::string& node, const std::string& sessionid, Status status,
                   Action executeAction, int allowedActions = Complete,
                   AdhocPlugin* plugin = 0 );

          Command( const std::string& node, Action action,
                   AdhocPlugin* plugin = 0 );

          Command( const Tag* tag = 0 );

          virtual ~Command();

          const std::string& node() const { return m_node; }

          const std::string& sessionID() const { return m_sessionid; }

          Status status() const { return m_status; }

          Action action() const { return m_action; }

          int actions() const { return m_actions; }

          const NoteList& notes() const { return m_notes; }

          void addNote( const Note* note ) { m_notes.push_back( note ); }

          GLOOX_DEPRECATED const AdhocPlugin* form() const { return m_plugin; }

          const AdhocPlugin* plugin() const { return m_plugin; }
 
          // reimplemented from StanzaExtension
          virtual const std::string& filterString() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* newInstance( const Tag* tag ) const
          {
            return new Command( tag );
          }
 
          // reimplemented from StanzaExtension
          virtual Tag* tag() const;
 
          // reimplemented from StanzaExtension
          virtual StanzaExtension* clone() const
          {
            Command* c = new Command();
 
            NoteList::const_iterator it = m_notes.begin();
            for( ; it != m_notes.end(); ++it )
              c->m_notes.push_back( new Note( *(*it) ) );
 
            c->m_node = m_node;
            c->m_sessionid = m_sessionid;
            c->m_plugin = m_plugin ? static_cast<AdhocPlugin*>( m_plugin->clone() ) : 0;
            c->m_action = m_action;
            c->m_status = m_status;
            c->m_actions = m_actions;
 
            return c;
          }
 
        private:
#ifdef ADHOC_COMMANDS_TEST
        public:
#endif
          NoteList m_notes;
 
          std::string m_node;
          std::string m_sessionid;
          AdhocPlugin* m_plugin;
          Action m_action;
          Status m_status;
          int m_actions;
      };

      Adhoc( ClientBase* parent );

      virtual ~Adhoc();

      void checkSupport( const JID& remote, AdhocHandler* ah, int context = 0 );

      void getCommands( const JID& remote, AdhocHandler* ah, int context = 0 );

      void execute( const JID& remote, const Adhoc::Command* command, AdhocHandler* ah, int context = 0 );

      void respond( const JID& remote, const Adhoc::Command* command, const Error* error = 0 );

      void registerAdhocCommandProvider( AdhocCommandProvider* acp, const std::string& command,
                                         const std::string& name );

      void removeAdhocCommandProvider( const std::string& command );
 
      // 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 );
 
      // reimplemented from IqHandler
      virtual bool handleIq( const IQ& iq );
 
      // reimplemented from IqHandler
      virtual void handleIqID( const IQ& iq, int context );
 
      // reimplemented from DiscoHandler
      virtual void handleDiscoInfo( const JID& from, const Disco::Info& info, int context );
 
      // 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 );
 
    private:
#ifdef ADHOC_TEST
    public:
#endif
      typedef std::map<const std::string, AdhocCommandProvider*> AdhocCommandProviderMap;
      AdhocCommandProviderMap m_adhocCommandProviders;
 
      enum AdhocContext
      {
        CheckAdhocSupport,
        FetchAdhocCommands,
        ExecuteAdhocCommand
      };
 
      struct TrackStruct
      {
        JID remote;
        AdhocContext context;
        std::string session;
        AdhocHandler* ah;
        int handlerContext;
      };
      typedef std::map<std::string, TrackStruct> AdhocTrackMap;
      AdhocTrackMap m_adhocTrackMap;
      util::Mutex m_adhocTrackMapMutex;
 
      ClientBase* m_parent;
 
      StringMap m_items;
      StringMap m_activeSessions;
 
  };
 
}
 
#endif // ADHOC_H__