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         /**
 162          * Set the status message for the account. Reimplemented from Kopete::Account
 163          */
 164         void setStatusMessage( const Kopete::StatusMessage &statusMessage );
 165
 166 signals:
 167         void conferenceCreated( const int mmId, const GroupWise::ConferenceGuid & guid );
 168         void conferenceCreationFailed( const int mmId, const int statusCode );
 169         void contactTyping( const ConferenceEvent & );
 170         void contactNotTyping( const ConferenceEvent & );
 171         void privacyChanged( const QString & dn, bool allowed );
 172
 173
 174 protected slots:
 175     void slotMessageSendingFailed();
 176         /**
 177          * Set an auto reply message for use when the account is away
 178          * TODO: Extend Kopete::AwayAction so you can set multiple ones there.
 179          */
 180         void slotSetAutoReply();
 181         /**
 182          * Manage the user's privacy settings
 183          */
 184         void slotPrivacy();
 185
 186         /**
 187          * Show a dialog to join a chatroom without first adding it to the contact list
 188          */
 189         void slotJoinChatRoom();
 190
 191         /**
 192          * Slot informing GroupWise when a group is renamed
 193          */
 194         void slotKopeteGroupRenamed( Kopete::Group * );
 195         /**
 196          * Slot informing GroupWise when a group is removed
 197          */
 198         void slotKopeteGroupRemoved( Kopete::Group * );
 199
 200         // SERVER SIDE CONTACT LIST PROCESSING
 201         /**
 202          * Called when we receive a FOLDER from the server side contact list
 203          * Adds to the Kopete contact list if not already present.
 204          */
 205         void receiveFolder( const FolderItem & folder );
 206         /**
 207          * Called when we receive a CONTACT from the server side contact list
 208          * Adds to a folder in the Kopete contact list.
 209          */
 210         void receiveContact( const ContactItem & );
 211         /**
 212          * Called when we receive a CONTACT'S METADATA (including initial status) from the server side contact list,
 213          * or in response to an explicitly query.  This is necessary to handle some events from the server.
 214          * These events are queued in the account until the data arrives and then we handle the event.
 215          */
 216         void receiveContactUserDetails( const GroupWise::ContactDetails & );
 217         /**
 218          * Called after we create a contact on the server
 219          */
 220         void receiveContactCreated();
 221         /**
 222          * Handles the response to deleting a contact on the server
 223          */
 224         void receiveContactDeleted( const ContactItem & instance );
 225
 226         // SLOTS HANDLING PROTOCOL EVENTS
 227         /**
 228         * Received a message from the server.
 229         * Find the conversation that this message belongs to, and display it there.
 230         * @param event contains event type, sender, content, flags.  Type is used to handle autoreplies, normal messages, and [system] broadcasts.
 231         */
 232         void handleIncomingMessage( const ConferenceEvent & );
 233         /**
 234          * A contact changed status
 235          */
 236         void receiveStatus( const QString &, quint16, const QString & );
 237         /**
 238          * Our status changed on the server
 239          */
 240         void changeOurStatus( GroupWise::Status, const QString &, const QString & );
 241         /**
 242          * Called when we've been disconnected for logging in as this user somewhere else
 243          */
 244         void slotConnectedElsewhere();
 245         /**
 246          * Called when we've logged in successfully
 247          */
 248         void slotLoggedIn();
 249         /**
 250          * Called when a login attempt failed
 251          */
 252         void slotLoginFailed();
 253         /**
 254          * We joined a conference having accepted an invitation, create a message manager
 255          */
 256         void receiveConferenceJoin( const GroupWise::ConferenceGuid & guid, const QStringList & participants, const QStringList & invitees );
 257         /**
 258          * Someone joined a conference, add them to the appropriate message manager
 259          */
 260         void receiveConferenceJoinNotify( const ConferenceEvent & );
 261         /**
 262          * Someone left a conference, remove them from the message manager
 263          */
 264         void receiveConferenceLeft( const ConferenceEvent & );
 265         /**
 266          * The user was invited to join a conference
 267          */
 268         void receiveInvitation( const ConferenceEvent & );
 269         /**
 270          * Notification that a third party was invited to join conference
 271          */
 272         void receiveInviteNotify( const ConferenceEvent & );
 273         /**
 274          * Notification that a third party declined an invitation
 275          */
 276         void receiveInviteDeclined( const ConferenceEvent & );
 277         /**
 278          * A conference was closed by the server because everyone has left or declined invitations
 279          * Prevents any further messages to this conference
 280          */
 281 //      void closeConference();
 282         // SLOTS HANDLING NETWORK EVENTS
 283         /**
 284          * Update the local user's metadata
 285          */
 286         void receiveAccountDetails( const GroupWise::ContactDetails & details );
 287         /**
 288          * The TLS handshake has happened, check the result
 289          */
 290         void slotTLSHandshaken();
 291         /** The connection is ready for a login */
 292         void slotTLSReady( int secLayerCode );
 293         /**
 294          * Called when the clientstream is connected, debug only
 295          */
 296         void slotCSConnected();
 297         /**
 298          * Performs necessary actions when the client stream has been disconnected
 299          */
 300         void slotCSDisconnected();
 301         void slotCSError( int error );
 302         void slotCSWarning( int warning );
 303
 304         // HOUSEKEEPING
 305         /**
 306          * We listen for the destroyed() signal and leave any conferences we
 307          * might have been in, and remove it from our map.
 308          */
 309         void slotLeavingConference( GroupWiseChatSession * );
 310
 311         /** Debug slots */
 312         void slotConnError();
 313         void slotConnConnected();
 314 protected:
 315         /**
 316          * Sends a status message to the server - called by the status specific slotGoAway etc
 317          */
 318         //void setStatus( GroupWise::Status status, const QString & reason = QString() );
 319
 320         int handleTLSWarning (QCA::TLS::IdentityResult identityResult,
 321                 QCA::Validity validityResult, QString server, QString accountId);
 322
 323         GroupWiseChatSession * findChatSessionByGuid( const GroupWise::ConferenceGuid & guid );
 324         /**
 325          * reconcile any changes to the contact list which happened offline
 326          */
 327         void reconcileOfflineChanges();
 328         /**
 329          * Memory management
 330          */
 331         void cleanup();
 332 private:
 333         // action menu and its actions
 334         KAction * m_actionAutoReply;
 335         KAction * m_actionManagePrivacy;
 336         KAction * m_actionJoinChatRoom;
 337         // Network code
 338         KNetworkConnector * m_connector;
 339         QCA::Initializer m_qcaInit;
 340         QCA::TLS * m_QCATLS;
 341         QCATLSHandler * m_tlsHandler;
 342         ClientStream * m_clientStream;
 343         // Client, entry point of libgroupwise
 344         Client * m_client;
 345
 346         QString m_password;
 347         QString m_initialReason;
 348         QList<GroupWiseChatSession*> m_chatSessions;
 349         bool m_dontSync;
 350         GWContactList * m_serverListModel;
 351 };
 352
 353 /**
 354  * @internal
 355  * 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.
 356  */
 357 /*class OnlineStatusMessageAction : public KAction
 358 {
 359         Q_OBJECT
 360   public:
 361         OnlineStatusMessageAction ( const Kopete::OnlineStatus& status, const QString &text, const QString &message, const QIcon &pix, QObject *parent=0, const char *name=0);
 362   signals:
 363         void activated( const Kopete::OnlineStatus& status, const QString & );
 364   private slots:
 365         void slotActivated();
 366   private:
 367         Kopete::OnlineStatus m_status;
 368         QString m_message;
 369 };
 370 */
 371 #endif