Blokkal

an Extendable KDE Blogging Client

• Download
• Screenshots
• LiveJournal Community
• API Documentation
• Contact

• Class Hierarchy
• Class List
• File List
• Class Members

blokkalaccount.cpp

/***************************************************************************
 *   Copyright (C) 2006 - 2008 by Martin Mueller                           *
 *   orvio@orvio.de                                                        *
 *                                                                         *
 *   This program 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 "blokkalaccount.h"
#include "blokkalaccount.moc"

#include "blokkalaccountconfig.h"
#include "blokkalprotocol.h"
#include "blokkalblog.h"
#include "blokkalblogconfig.h"
#include "blokkalwalletmanager.h"

#include "blokkalio/categorymanager.h"

#include "blokkalui/globalsettings.h"

#include <kstandarddirs.h>
#include <kaction.h>
#include <kactioncollection.h>
#include <klocale.h>
#include <kdebug.h>
#include <kwallet.h>
#include <kpassworddialog.h>
#include <knotification.h>

#include <QDir>
#include <QTimer>
#include <QDomElement>

class Blokkal::Account::Private {
public:
        Private( void ):
        removeAccount( FALSE ),
        blogMap( QMap< QString, Blokkal::Blog * >() ),
        unregisteredBlogs( QMap< QString, QDomElement >() ),
        categoryManager( 0 ),
        autoReconnectCounter( 0 ){}

        Protocol * protocol;

        AccountConfig * accountConfig;

        Blokkal::Account::ConnectionStatus connectionStatus;

        bool removeAccount;
        QMap< QString, Blokkal::Blog * > blogMap;
        QMap< QString, QDomElement > unregisteredBlogs;
        
        Io::CategoryManager * categoryManager;
        unsigned int autoReconnectCounter;
};

Blokkal::Account::Account( Blokkal::Protocol * protocol, const QString & id ) :
QObject( protocol ),
d( new Private() )
{
        d->protocol = protocol;
        d->accountConfig = new AccountConfig( id, protocol );
        d->connectionStatus = Disconnected;

        d->categoryManager = new Io::CategoryManager( this );
}

Blokkal::Account::~Account( void )
{
        emit accountDestroyed( this );
        //never delete the protocol!
        delete d->accountConfig;
        d->accountConfig = 0;
        delete d;
}

Blokkal::AccountConfig * Blokkal::Account::config( void ) const
{
        return d->accountConfig;
}

Blokkal::Protocol * Blokkal::Account::protocol( void ) const
{
        return d->protocol;
}

QString Blokkal::Account::serverName( void ) const
{
        return config()->readEntry( "servername" );
}

KUrl Blokkal::Account::connectAddress( void ) const
{
        return config()->readEntry( "connectaddress" );
}

QString Blokkal::Account::id( void ) const
{
        return config()->id();
}

QString Blokkal::Account::userName( void ) const
{
        return config()->readEntry( "username" );
}

KIcon Blokkal::Account::icon( void ) const
{
        return protocol()->icon();
}

void Blokkal::Account::removeAccount( void )
{
        d->removeAccount = TRUE;
        disconnectAccount( UserDisconnect );
}

bool Blokkal::Account::usesDefaultConnectAddress( void ) const
{
        return config()->readBoolEntry( "defaultconnectaddress" );
}

Blokkal::Account::ConnectionStatus Blokkal::Account::connectionStatus( void ) const
{
        return d->connectionStatus;
}

void Blokkal::Account::setConnectionStatus( Blokkal::Account::ConnectionStatus status )
{
        d->connectionStatus = status;
        if( status == Connected ) {
                d->autoReconnectCounter = 0;
        }
        emit connectionStatusChanged( this );
}

void Blokkal::Account::disconnectAccount( Blokkal::Account::DisconnectReason reason, const QString & reasonString )
{
        if( reason != UserDisconnect ) {
                QString message;
                if( !reasonString.isEmpty() || reason == AuthenticationDisconnect ) {
                        message = i18n( "<b>%1</b> disconnected : %2" ,
                                        id(),
                                        reasonString.isEmpty() ? i18n( "authentication failed" ) : reasonString );
                }
                else {
                        message = i18n( "<b>%1</b> disconnected" , id() );
                }
                KNotification * notification = new KNotification( "account_disconnected", Ui::GlobalSettings::self()->mainWidget() );
                notification->setText( message );
                notification->sendEvent();
        }

        QList<Blog*> bloglist = blogs();
        for( QList<Blog*>::ConstIterator it = bloglist.begin();
             it != bloglist.end();
             ++it )
        {
                (*it)->saveProperties();
        }
        
        setConnectionStatus( Disconnected );

        if( d->removeAccount ) {
                config()->remove();
                deleteLater();
        }
        else if( reason == AuthenticationDisconnect ) {
                QTimer::singleShot( 0, this, SLOT( connectAccount() ) );
        }
        else if( reason != UserDisconnect && d->autoReconnectCounter < 3 ){
                d->autoReconnectCounter++;
                kDebug() << "auto reconnect: " << d->autoReconnectCounter << endl;
                QTimer::singleShot( 30 * 1000, this, SLOT( connectAccount() ) );
        }
}

QList< Blokkal::Blog * > Blokkal::Account::blogs( void ) const
{
        return d->blogMap.values();
}

Blokkal::Blog *  Blokkal::Account::registerBlog( Blokkal::Blog * blog )
{
        if( d->blogMap.contains( blog->id() ) ) {
                if( d->blogMap[blog->id()] == blog ) {
                        return blog;
                }
                else {
                        blog->deleteLater();
                        return 0;
                }
        }

        //this blog is actually new
        d->blogMap.insert( blog->id(), blog );
        if( d->unregisteredBlogs.contains( blog->id() ) ) {
                config()->node().appendChild( d->unregisteredBlogs[blog->id()] );
                d->unregisteredBlogs.remove( blog->id() );
        }
        connect( blog, SIGNAL( blogDestroyed( Blokkal::Blog * ) ),
                 this, SLOT( unregisterBlog( Blokkal::Blog * ) ) );
        emit blogRegistered( blog );
        return blog;
}

void Blokkal::Account::unregisterBlog( Blokkal::Blog * blog )
{
        if( !d->blogMap.contains( blog->id() ) ) {
                d->blogMap.remove( blog->id() );
                emit blogUnregistered( blog );
        }
}

Blokkal::Blog * Blokkal::Account::blog( const QString & id ) const
{
        if( d->blogMap.contains( id ) ) {
                return d->blogMap[ id ];
        }

        return 0;
}

QString Blokkal::Account::dataDirectory( void ) const
{
        QString dataDirName = KStandardDirs::locateLocal( "appdata",
                QString::fromLatin1( "accounts/%1/" ).arg( id() ),
                TRUE );
        
        /*QDir oldAccountDir( KStandardDirs::locateLocal( "appdata", QString::fromLatin1( "%1/" ).arg( id() ), FALSE ) );
        if( oldAccountDir.exists() ) {
                kDebug() << "found old style account directory: " << oldAccountDir.absolutePath() << endl;
                kDebug() << "moving it to new location: " << dataDirName << endl;
                if( !oldAccountDir.rename( oldAccountDir.absolutePath(), dataDirName ) ) {
                        kError() << "failed to move directory " << oldAccountDir.absolutePath() << " to " << dataDirName << endl;
                }
                else {
                        kDebug() << "successfully moved directory " << oldAccountDir.absolutePath() << " to " << dataDirName << endl;
                }
        }*/

        return dataDirName;
}

void Blokkal::Account::setServerName( const QString & serverName )
{
        config()->writeEntry( "servername", serverName );
}

void Blokkal::Account::setConnectAddress( const QString & address )
{
        config()->writeEntry( "connectaddress", address );
}

void Blokkal::Account::setUsesDefaultConnectAddress( bool useDefault )
{
        config()->writeEntry( "defaultconnectaddress", useDefault );
}

void Blokkal::Account::setUserName( const QString & user )
{
        config()->writeEntry( "username", user );
}

bool Blokkal::Account::isConnected( void ) const
{
        return connectionStatus() == Connected;
}

bool Blokkal::Account::isDisconnected( void ) const
{
        return connectionStatus() == Disconnected;
}

QDomElement Blokkal::Account::blogNode( const QString & id )
{
        //search the document first
        QDomElement currentElement;
        for( QDomNode currentNode = config()->node().namedItem( "blog" );
             !currentNode.isNull();
             currentNode = currentNode.nextSibling() )
        {
                if( currentNode.nodeName() == "blog" && currentNode.isElement() ) {
                        currentElement = currentNode.toElement();
                        if( currentElement.attribute( "id" ) == id
                            || currentElement.attribute( "name" ) == id )
                        {
                                return currentElement;
                        }
                }
        }

        //try free unregistered blogs next
        if( d->unregisteredBlogs.contains( id ) ) {
                return d->unregisteredBlogs[id];
        }

        //create new unregistered blog node
        currentElement = config()->node().ownerDocument().createElement( "blog" );
        currentElement.setAttribute( "id", id );
        d->unregisteredBlogs.insert( id, currentElement );
        return currentElement;
}

void Blokkal::Account::restoreBlogs( void )
{
        QDomElement currentElement;
        Blog * currentBlog;
        BlogConfig * config;
        
        for( QDomNode currentNode = this->config()->node().namedItem( "blog" );
             !currentNode.isNull();
             currentNode = currentNode.nextSibling() )
        {
                if( currentNode.nodeName() == "blog" && currentNode.isElement() ) {
                        currentElement = currentNode.toElement();
                        const QString id = currentElement.attribute( "name" ).isEmpty()
                                ? currentElement.attribute( "id")
                                : currentElement.attribute( "name" );
                        if( id.isEmpty() ) {
                                this->config()->node().removeChild( currentElement );
                                continue;
                        }
                        
                        config = new BlogConfig( id, this );
                        currentBlog = restoreBlog( config );
                        if( currentBlog ) {
                                registerBlog( currentBlog );
                        }

                        delete config;
                }
        }
}

bool Blokkal::Account::autoConnect( void ) const
{
        return config()->readBoolEntry( "autoconnect", TRUE );
}

void Blokkal::Account::setAutoConnect( bool enable ) const
{
        config()->writeEntry( "autoconnect", enable );
}

Blokkal::Io::CategoryManager * Blokkal::Account::categoryManager( void ) const
{
        return d->categoryManager;
}

//-----------------
//PasswordedAccount
//-----------------
class Blokkal::PasswordedAccount::Private {
public:
        Private( void ) :
        passwordWrong( FALSE ) {}

        bool passwordWrong;
        QString password;
};
Blokkal::PasswordedAccount::PasswordedAccount( Blokkal::Protocol * protocol, const QString & id ):
Account( protocol, id ),
d( new Private() )
{
}

Blokkal::PasswordedAccount::~PasswordedAccount( void )
{
        delete d;
}

void Blokkal::PasswordedAccount::removeAccount( void )
{
        new Blokkal::PasswordDeleter( id() );
        Account::removeAccount( );
}

void Blokkal::PasswordedAccount::connectAccount( void )
{
        setConnectionStatus( Connecting );
        if( d->password.isNull() || d->passwordWrong ) {
                WalletManager::self()->openWallet( this, SLOT( slotWalletOpened( KWallet::Wallet * ) ) );
        }
        else {
                connectInner();
        }
}

void Blokkal::PasswordedAccount::disconnectAccount( Blokkal::Account::DisconnectReason reason, const QString & reasonString )
{
        if( reason == AuthenticationDisconnect ) {
                d->password == QString::null;
                d->passwordWrong = TRUE;
        }

        Account::disconnectAccount( reason, reasonString );
}

const QString & Blokkal::PasswordedAccount::password( void ) const
{
        return d->password;
}

void Blokkal::PasswordedAccount::slotWalletOpened( KWallet::Wallet * wallet )
{
        bool isValid = TRUE;
        if( wallet ) {
                if( d->passwordWrong ) {
                        d->password = promptUser( isValid, wallet );
                }
                else if( wallet->hasEntry( id() ) ) {
                        wallet->readPassword( id(), d->password );
                }
                else {
                        d->password = promptUser( isValid, wallet );
                }               
        }
        else {
                d->password = promptUser( isValid, wallet );
        }

        if( isValid ) {
                d->passwordWrong = FALSE;
                connectInner();
        }
        else {
                disconnectAccount( UserDisconnect );
        }
}

QString Blokkal::PasswordedAccount::promptUser( bool & success, KWallet::Wallet * wallet )
{
        const QString passwordPrompt = i18n( "Password required for account: \"%1\"", id() );
        QString password;

        KPasswordDialog * passwordDialog = new KPasswordDialog( Blokkal::Ui::GlobalSettings::self()->mainWidget(),
                wallet ?  KPasswordDialog::ShowKeepPassword : KPasswordDialog::NoFlags ); //enable keep button only when the wallet is present
        
        passwordDialog->setPrompt( passwordPrompt );

        
        if( passwordDialog->exec() ) {
                password = passwordDialog->password();
                if( passwordDialog->keepPassword() && wallet ) {
                        wallet->writePassword( id(), password );
                }
                success = TRUE;
        }
        else {
                success = FALSE;
                password = QString::null;
        }

        delete passwordDialog;
        passwordDialog = 0;
        return password;
}

QList< QAction * > Blokkal::Account::actionList( void )
{
        return QList<QAction*>();
}