Blokkal

an Extendable KDE Blogging Client

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

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

blokkalaccountmanager.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 "blokkalaccountmanager.h"
#include "blokkalaccountmanager.moc"

#include "blokkalaccount.h"

#include "blokkalprotocol.h"
#include "blokkalpluginmanager.h"

#include <kstandarddirs.h>
#include <kdebug.h>

#include <QFile>
#include <QMap>
#include <QDomDocument>

namespace Blokkal {
class AccountManagerPrivate {
public:
        AccountManagerPrivate( void ) :
        accountsDocument( QDomDocument( "BlokkalAccounts" ) ),
        registeredAccounts( QMap< QString, Blokkal::Account * >() ),
        freeAccounts( QMap< QString, QDomElement >() )
        {
                accountsDocument.appendChild( accountsDocument.createElement( "accountlist" ) );
        }

        ~AccountManagerPrivate( void ) {
                saveAccounts();
        }

        void saveAccounts( void ) {
                QFile accountsFile( KStandardDirs::locateLocal( "appdata", QString::fromLatin1( "accounts.xml" ) ) );
                if( !accountsFile.open( QIODevice::WriteOnly ) ) {
                        kError() << "error opening account file " << accountsFile.fileName() << endl;
                }
                QTextStream fileStream( &accountsFile );
                accountsDocument.save( fileStream, 3 );
                accountsFile.close();
        }


        QDomDocument accountsDocument;

        QMap< QString, Blokkal::Account * > registeredAccounts;

        QMap< QString, QDomElement > freeAccounts;

        Blokkal::AccountManager instance;
        
};
}

K_GLOBAL_STATIC( Blokkal::AccountManagerPrivate, _bamp );

Blokkal::AccountManager::AccountManager( void ):
QObject( 0 )
{}


void Blokkal::AccountManager::loadAccounts( void )
{
        //loading and parsing accounts file
        QFile accountsFile( KStandardDirs::locateLocal( "appdata", QString::fromLatin1( "accounts.xml" ) ) );
        if( accountsFile.open( QIODevice::ReadOnly ) ) {
                if( !_bamp->accountsDocument.setContent( &accountsFile ) ) {
                        kError() << "error parsing account file " << accountsFile.fileName() << endl;
                }
                accountsFile.close();
        }

        //creating accounts
        QDomElement currentElement;
        QString protocolName;
        QString accountId;
        Protocol * protocol = 0;
        for( QDomNode currentNode = _bamp->accountsDocument.firstChild().firstChild();
             !currentNode.isNull();
             currentNode = currentNode.nextSibling() )
        {
                if( currentNode.nodeName() == "account" && currentNode.isElement() ) {
                        currentElement = currentNode.toElement();
                        protocolName = currentElement.attribute( "protocol" );
                        if( currentElement.hasAttribute( "id" ) ) {
                                accountId = currentElement.attribute( "id" );
                        }
                        else {
                                accountId = currentElement.attribute( "name" );
                        }
                        
                        if( !protocolName.isEmpty() && !accountId.isEmpty() ) {
                                protocol = PluginManager::self()->protocol( protocolName );
                                if( protocol ) {
                                        registerAccount( protocol->createAccount( accountId ) );
                                }
                        }
                }
        }
}

void Blokkal::AccountManager::saveAccounts( void )
{
        _bamp->saveAccounts();
}

Blokkal::AccountManager::~AccountManager( void )
{}

Blokkal::AccountManager * Blokkal::AccountManager::self( void )
{
        return &_bamp->instance;
}

Blokkal::AccountList Blokkal::AccountManager::accounts( void )
{
        return _bamp->registeredAccounts.values();
}


Blokkal::Account * Blokkal::AccountManager::registerAccount( Blokkal::Account * account )
{
        if( _bamp->registeredAccounts.contains( account->id() ) ) {
                if( _bamp->registeredAccounts[account->id()] == account ) {
                        return account;
                }
                else {
                        account->deleteLater();
                        return 0;
                }
        }

        //this account is actually new
        _bamp->registeredAccounts.insert( account->id(), account);
        if( _bamp->freeAccounts.contains( account->id() ) ) {
                _bamp->accountsDocument.firstChild().appendChild( _bamp->freeAccounts[account->id()] );
                _bamp->freeAccounts.remove( account->id() );
                saveAccounts();
        }
        connect( account, SIGNAL( accountDestroyed( Blokkal::Account * ) ),
                 this, SLOT( unregisterAccount( Blokkal::Account * ) ) );

        emit accountRegistered( account );
        return account;
}


void Blokkal::AccountManager::unregisterAccount( Blokkal::Account * account )
{
        if( _bamp->registeredAccounts.contains( account->id() ) ) {
                _bamp->registeredAccounts.remove( account->id() );
                saveAccounts();
        }
        emit accountUnregistered( account );
}



Blokkal::Account * Blokkal::AccountManager::account( const QString & id )
{
        if( _bamp->registeredAccounts.contains( id ) ) {
                return _bamp->registeredAccounts[id];
        }

        return 0;
}

QDomElement Blokkal::AccountManager::accountNode( const QString & id )
{
        //search the document first
        QDomElement currentElement;
        for( QDomNode currentNode = _bamp->accountsDocument.firstChild().firstChild();
             !currentNode.isNull();
             currentNode = currentNode.nextSibling() )
        {
                if( currentNode.nodeName() == "account" && currentNode.isElement() ) {
                        currentElement = currentNode.toElement();
                        if( ( currentElement.attribute( "id" ) == id
                              || currentElement.attribute( "name" ) == id )
                            && !currentElement.attribute( "protocol" ).isEmpty() )
                        {
                                return currentElement;
                        }
                }
        }

        //try free accounts next
        if( _bamp->freeAccounts.contains( id ) ) {
                return _bamp->freeAccounts[id];
        }

        //create new free account
        currentElement = _bamp->accountsDocument.createElement( "account" );
        currentElement.setAttribute( "id", id );
        _bamp->freeAccounts.insert( id, currentElement );
        return currentElement;
}