kopete/protocols/groupwise/gwaccount.h

   1 /*
   2     gwaccount.h - Kopete GroupWise Protocol
   3
   4     Copyright (c) 2006,2007 Novell, Inc                  http://www.opensuse.org
   5     Copyright (c) 2004      SUSE Linux AG                http://www.suse.com
   6
   7     Based on Testbed
   8     Copyright (c) 2003-2007 by Will Stephenson           <wstephenson@kde.org>
   9
  10     Kopete    (c) 2002-2007 by the Kopete developers <kopete-devel@kde.org>
  11
  12     *************************************************************************
  13     *                                                                       *
  14     * This library is free software; you can redistribute it and/or         *
  15     * modify it under the terms of the GNU General Public                   *
  16     * License as published by the Free Software Foundation; either          *
  17     * version 2 of the License, or (at your option) any later version.      *
  18     *                                                                       *
  19     *************************************************************************
  20 */
  21
  22 #ifndef GW_ACCOUNT_H
  23 #define GW_ACCOUNT_H
  24
  25 #include <QtCore/QList>
  26 #include <QtCrypto>
  27
  28 #include <kaction.h>
  29
  30 #include <kopetechatsessionmanager.h>
  31 #include <kopetecontact.h>
  32
  33 #include "gwerror.h"
  34
  35 #include <kopetepasswordedaccount.h>
  36
  37 class KActionMenu;
  38
  39 namespace Kopete {
  40         class Group;
  41         class MetaContact;
  42 }
  43
  44 class GroupWiseContact;
  45 class GroupWiseChatSession;
  46 class GroupWiseProtocol;
  47 class KNetworkConnector;
  48 namespace QCA {
  49         class TLS;
  50 }
  51 class QCATLSHandler;
  52 class ClientStream;
  53 class Client;
  54 class GWContactList;
  55
  56 using namespace GroupWise;
  57
  58 /**
  59  * This represents an account on a Novell GroupWise Messenger Server
  60  */
  61 class GroupWiseAccount : public Kopete::PasswordedAccount
  62 {
  63         Q_OBJECT
  64 public:
  65         GroupWiseAccount( GroupWiseProtocol *parent, const QString& accountID, const char *name = 0 );
  66         ~GroupWiseAccount();
  67
  68         /**
  69          * Construct the context menu used for the status bar icon
  70          */
  71         virtual void fillActionMenu( KActionMenu *actionMenu );
  72
  73         // DEBUG ONLY
  74         void dumpManagers();
  75         // DEBUG ONLY
  76         /**
  77          * Creates a protocol specific Kopete::Contact subclass and adds it to the supplied
  78          * Kopete::MetaContact
  79          */
  80         virtual bool createContact(const QString& contactId, Kopete::MetaContact* parentContact);
  81         /**
  82          * Delete a contact on the server
  83          */
  84         void deleteContact( GroupWiseContact * contact );
  85         /**
  86          * Called when Kopete is set globally away
  87          */
  88         virtual void setAway(bool away, const QString& reason);
  89         /**
  90          * Utility access to the port given by the user
  91          */
  92         int port() const;
  93         /**
  94          * Utility access to the server given by the user
  95          */
  96         const QString server() const;
  97         /**
  98          * Utility access to our protocol
  99          */
 100         GroupWiseProtocol * protocol() const;
 101         /**
 102          * Utility access to the @ref Client which is the main interface exposed by libgroupwise.
 103          * Most protocol actions are carried out using the client's member functions but the possibility exists
 104          * to start Tasks directly on the client and respond directly to their signals.
 105          */
 106         Client * client() const;
 107         /**
 108          * Utility to create or access a message manager instance for a given GUID and set of contacts
 109          */
 110         GroupWiseChatSession * chatSession( Kopete::ContactPtrList others, const ConferenceGuid & guid, Kopete::Contact::CanCreateFlags canCreate );
 111         /**
 112          * Look up a contact given a DN
 113          * Returns 0 if none found
 114          */
 115         GroupWiseContact * contactForDN( const QString & dn );
 116         /**
 117          * Create a conference (start a chat) on the server
 118          */
 119         void createConference( const int clientId, const QStringList& invitees );
 120
 121         /**
 122          * Send a message
 123          */
 124         void sendMessage( const ConferenceGuid & guid, const Kopete::Message & message );
 125
 126         /**
 127          * Invite someone to join a conference
 128          */
 129         void sendInvitation( const ConferenceGuid & guid, const QString & dn, const QString & message );
 130
 131         /**
 132          * Check a contact's blocking status
 133          * Only works when connected - otherwise always returns false
 134          */
 135         bool isContactBlocked( const QString & m_dn );
 136         /**
 137          * Set up a temporary contact (not on our contact list but is messaging us or involved in a conversation that we have been invited to.
 138          */
 139         GroupWiseContact * createTemporaryContact( const QString & dn );
 140
 141         /**
 142          * Check whether sync is not currently needed
 143          */
 144         bool dontSync();
 145
 146         void syncContact( GroupWiseContact * contact );
 147
 148 public slots:
 149
 150         void slotTestRTFize();
 151
 152         /* Connects to the server. */
 153         void connectWithPassword ( const QString &password );
 154
 155         /* Disconnects from the server. */
 156         virtual void disconnect();
 157         virtual void disconnect( Kopete::Account::DisconnectReason reason );
 158
 159         /** Set the online status for the account. Reimplemented from Kopete::Account */
 160         void setOnlineStatus( const Kopete::OnlineStatus& status , const Kopete::StatusMessage &reason = Kopete::StatusMessage(),
 161                               const OnlineStatusOptions& options = None );
 162         /**
 163          * Set the status message for the account. Reimplemented from Kopete::Account
 164          */
 165         void setStatusMessage( const Kopete::StatusMessage &statusMessage );
 166
 167 signals:
 168         void conferenceCreated( const int mmId, const GroupWise::ConferenceGuid & guid );
 169         void conferenceCreationFailed( const int mmId, const int statusCode );
 170         void contactTyping( const ConferenceEvent & );
 171         void contactNotTyping( const ConferenceEvent & );
 172         void privacyChanged( const QString & dn, bool allowed );
 173
 174
 175 protected slots:
 176     void slotMessageSendingFailed();
 177         /**
 178          * Set an auto reply message for use when the account is away
 179          * TODO: Extend Kopete::AwayAction so you can set multiple ones there.
 180          */
 181         void slotSetAutoReply();
 182         /**
 183          * Manage the user's privacy settings
 184          */
 185         void slotPrivacy();
 186
 187         /**
 188          * Show a dialog to join a chatroom without first adding it to the contact list
 189          */
 190         void slotJoinChatRoom();
 191
 192         /**
 193          * Slot informing GroupWise when a group is renamed
 194          */
 195         void slotKopeteGroupRenamed( Kopete::Group * );
 196         /**
 197          * Slot informing GroupWise when a group is removed
 198          */
 199         void slotKopeteGroupRemoved( Kopete::Group * );
 200
 201         // SERVER SIDE CONTACT LIST PROCESSING
 202         /**
 203          * Called when we receive a FOLDER from the server side contact list
 204          * Adds to the Kopete contact list if not already present.
 205          */
 206         void receiveFolder( const FolderItem & folder );
 207         /**
 208          * Called when we receive a CONTACT from the server side contact list
 209          * Adds to a folder in the Kopete contact list.
 210          */
 211         void receiveContact( const ContactItem & );
 212         /**
 213          * Called when we receive a CONTACT'S METADATA (including initial status) from the server side contact list,
 214          * or in response to an explicitly query.  This is necessary to handle some events from the server.
 215          * These events are queued in the account until the data arrives and then we handle the event.
 216          */
 217         void receiveContactUserDetails( const GroupWise::ContactDetails & );
 218         /**
 219          * Called after we create a contact on the server
 220          */
 221         void receiveContactCreated();
 222         /**
 223          * Handles the response to deleting a contact on the server
 224          */
 225         void receiveContactDeleted( const ContactItem & instance );
 226
 227         // SLOTS HANDLING PROTOCOL EVENTS
 228         /**
 229         * Received a message from the server.
 230         * Find the conversation that this message belongs to, and display it there.
 231         * @param event contains event type, sender, content, flags.  Type is used to handle autoreplies, normal messages, and [system] broadcasts.
 232         */
 233         void handleIncomingMessage( const ConferenceEvent & );
 234         /**
 235          * A contact changed status
 236          */
 237         void receiveStatus( const QString &, quint16, const QString & );
 238         /**
 239          * Our status changed on the server
 240          */
 241         void changeOurStatus( GroupWise::Status, const QString &, const QString & );
 242         /**
 243          * Called when we've been disconnected for logging in as this user somewhere else
 244          */
 245         void slotConnectedElsewhere();
 246         /**
 247          * Called when we've logged in successfully
 248          */
 249         void slotLoggedIn();
 250         /**
 251          * Called when a login attempt failed
 252          */
 253         void slotLoginFailed();
 254         /**
 255          * We joined a conference having accepted an invitation, create a message manager
 256          */
 257         void receiveConferenceJoin( const GroupWise::ConferenceGuid & guid, const QStringList & participants, const QStringList & invitees );
 258         /**
 259          * Someone joined a conference, add them to the appropriate message manager
 260          */
 261         void receiveConferenceJoinNotify( const ConferenceEvent & );
 262         /**
 263          * Someone left a conference, remove them from the message manager
 264          */
 265         void receiveConferenceLeft( const ConferenceEvent & );
 266         /**
 267          * The user was invited to join a conference
 268          */
 269         void receiveInvitation( const ConferenceEvent & );
 270         /**
 271          * Notification that a third party was invited to join conference
 272          */
 273         void receiveInviteNotify( const ConferenceEvent & );
 274         /**
 275          * Notification that a third party declined an invitation
 276          */
 277         void receiveInviteDeclined( const ConferenceEvent & );
 278         /**
 279          * A conference was closed by the server because everyone has left or declined invitations
 280          * Prevents any further messages to this conference
 281          */
 282 //      void closeConference();
 283         // SLOTS HANDLING NETWORK EVENTS
 284         /**
 285          * Update the local user's metadata
 286          */
 287         void receiveAccountDetails( const GroupWise::ContactDetails & details );
 288         /**
 289          * The TLS handshake has happened, check the result
 290          */
 291         void slotTLSHandshaken();
 292         /** The connection is ready for a login */
 293         void slotTLSReady( int secLayerCode );
 294         /**
 295          * Called when the clientstream is connected, debug only
 296          */
 297         void slotCSConnected();
 298         /**
 299          * Performs necessary actions when the client stream has been disconnected
 300          */
 301         void slotCSDisconnected();
 302         void slotCSError( int error );
 303         void slotCSWarning( int warning );
 304
 305         // HOUSEKEEPING
 306         /**
 307          * We listen for the destroyed() signal and leave any conferences we
 308          * might have been in, and remove it from our map.
 309          */
 310         void slotLeavingConference( GroupWiseChatSession * );
 311
 312         /** Debug slots */
 313         void slotConnError();
 314         void slotConnConnected();
 315 protected:
 316         /**
 317          * Sends a status message to the server - called by the status specific slotGoAway etc
 318          */
 319         //void setStatus( GroupWise::Status status, const QString & reason = QString() );
 320
 321         int handleTLSWarning (QCA::TLS::IdentityResult identityResult,
 322                 QCA::Validity validityResult, QString server, QString accountId);
 323
 324         GroupWiseChatSession * findChatSessionByGuid( const GroupWise::ConferenceGuid & guid );
 325         /**
 326          * reconcile any changes to the contact list which happened offline
 327          */
 328         void reconcileOfflineChanges();
 329         /**
 330          * Memory management
 331          */
 332         void cleanup();
 333 private:
 334         // action menu and its actions
 335         KAction * m_actionAutoReply;
 336         KAction * m_actionManagePrivacy;
 337         KAction * m_actionJoinChatRoom;
 338         // Network code
 339         KNetworkConnector * m_connector;
 340         QCA::Initializer m_qcaInit;
 341         QCA::TLS * m_QCATLS;
 342         QCATLSHandler * m_tlsHandler;
 343         ClientStream * m_clientStream;
 344         // Client, entry point of libgroupwise
 345         Client * m_client;
 346
 347         QString m_password;
 348         QString m_initialReason;
 349         QList<GroupWiseChatSession*> m_chatSessions;
 350         bool m_dontSync;
 351         GWContactList * m_serverListModel;
 352 };
 353
 354 /**
 355  * @internal
 356  * An action that selects an OnlineStatus and provides a status message, but not using Kopete::Away, because the status message relates only to this status.
 357  */
 358 /*class OnlineStatusMessageAction : public KAction
 359 {
 360         Q_OBJECT
 361   public:
 362         OnlineStatusMessageAction ( const Kopete::OnlineStatus& status, const QString &text, const QString &message, const QIcon &pix, QObject *parent=0, const char *name=0);
 363   signals:
 364         void activated( const Kopete::OnlineStatus& status, const QString & );
 365   private slots:
 366         void slotActivated();
 367   private:
 368         Kopete::OnlineStatus m_status;
 369         QString m_message;
 370 };
 371 */
 372 #endif