meegim/meegimsettings.cpp

#include "meegimsettings.h"

#include "MyXmppClient.h"

MeegIMSettings::MeegIMSettings() : MySettings(0)
{

    jid_indx0 = "";
    pass_indx0 = "";
    dflt_indx0 = "";

    alm = new AccountsListModel( this );

    this->initListOfAccounts();
}

QXmppConfiguration MeegIMSettings::getDefaultAccount()
{
    QXmppConfiguration xmppConfig;

    //QString passwd("");

    QStringList listAcc = getListAccounts();
    QStringList::const_iterator itr = listAcc.begin();
    while ( itr != listAcc.end() )
    {
        QString jid = *itr;
        itr++;

        QString passwd = getPasswd( jid );
        QString host = getHost( jid );
        int port = getPort( jid );
        QString resource = getResource( jid );

        bool isDefault = isAccDefault( jid );
        if( isDefault ) {
            //MyXmppClient::myPass = passwd;
            //MyXmppClient::myJid = jid;

            xmppConfig.setJid( jid );
            xmppConfig.setPassword( passwd );

            if( !resource.isEmpty() ) {
                xmppConfig.setResource( resource );
            }

            if( !host.isEmpty() ) {
                xmppConfig.setHost( host );
            }

            if( port > 0 ) {
                xmppConfig.setPort( port );
            }

            return xmppConfig;
        }
    }
    return xmppConfig;
}


void MeegIMSettings::initListOfAccounts() //Q_INVOKABLE
{
    QStringList listAcc = getListAccounts();

    alm->removeRows( 0, alm->count() );

    QStringList::const_iterator itr = listAcc.begin();
    int i = 0;
    while ( itr != listAcc.end() )
    {
        QString jid = *itr;
        itr++;

        QString passwd = getPasswd( jid );
        QString icon = "qrc:/qml/images/accXMPP.png";

        bool isDefault = isAccDefault( jid );

        QString type = "xmpp";
        QString host = getHost( jid );
        int port = getPort( jid );
        QString resource = getResource( jid );
        bool isManuallyHostPort = isHostPortManually( jid );

        AccountsItemModel *aim = new AccountsItemModel( jid, passwd, icon, type, resource, host, port, isDefault, isManuallyHostPort, this );
        alm->append(aim);

        if(i==0) {
            jid_indx0 = jid;
            pass_indx0 = passwd;
            dflt_indx0 = isDefault;
        }
        i++;
    }

    emit accountsListChanged();
}


void MeegIMSettings::setAccount(
        QString _jid,
        QString _pass,
        bool _isDflt,
        QString _resource,
        QString _host,
        QString _port,
        bool manuallyHostPort) //Q_INVOKABLE
{
    this->addAccount( _jid );
    this->setPasswd( _jid, _pass );
    this->setAccDefault( _jid, _isDflt );

    this->setResource( _jid, _resource );
    this->setHost( _jid, _host );
    this->setHostPortManually( _jid, manuallyHostPort );

    bool ok = false;
    int p = _port.toInt(&ok);
    if( ok ) {
        this->setPort( _jid, p );
    }

    this->getDefaultAccount();
}


void MeegIMSettings::removeAccount( QString _jid ) //Q_INVOKABLE
{
    this->remAccount( _jid );
    this->remove( _jid );
}


bool MeegIMSettings::accIsDefault(int index)
{
    bool val = false;
    if( (index>=0) and (index<alm->count()) ) {
        AccountsItemModel *aim = reinterpret_cast<AccountsItemModel*>( alm->value( index ) );
        val = aim->isDefault();
    }
    return val;
}

QString MeegIMSettings::accGetJid(int index)
{
    QString val = "";
    if( (index>=0) and (index<alm->count()) ) {
        AccountsItemModel *aim = reinterpret_cast<AccountsItemModel*>( alm->value( index ) );
        val = aim->jid();
    }
    return val;
}

QString MeegIMSettings::accGetPassword(int index)
{
    QString val = "";
    if( (index>=0) and (index<alm->count()) ) {
        AccountsItemModel *aim = reinterpret_cast<AccountsItemModel*>( alm->value( index ) );
        val = aim->passwd();
    }
    return val;
}

QString MeegIMSettings::accGetResource(int index)
{
    QString val = "";
    if( (index>=0) and (index<alm->count()) ) {
        AccountsItemModel *aim = reinterpret_cast<AccountsItemModel*>( alm->value( index ) );
        val = aim->resource();
    }
    return val;
}

QString MeegIMSettings::accGetHost(int index)
{
    QString val = "";
    if( (index>=0) and (index<alm->count()) ) {
        AccountsItemModel *aim = reinterpret_cast<AccountsItemModel*>( alm->value( index ) );
        val = aim->host();
    }
    return val;
}

int MeegIMSettings::accGetPort(int index)
{
    int val = 0;
    if( (index>=0) and (index<alm->count()) ) {
        AccountsItemModel *aim = reinterpret_cast<AccountsItemModel*>( alm->value( index ) );
        val = aim->port();
    }
    return val;
}

bool MeegIMSettings::accIsManuallyHostPort(int index)
{
    bool val = false;
    if( (index>=0) and (index<alm->count()) ) {
        AccountsItemModel *aim = reinterpret_cast<AccountsItemModel*>( alm->value( index ) );
        val = aim->isManuallyHostPort();
    }
    return val;
}


void MeegIMSettings::saveStatusText(QString statusText)
{
    if( statusText != this->getStatusText() )
    {
        this->setStatusText( statusText );
    }
}


void MeegIMSettings::setSoundIncomingMessage( const QString &filePath )
{
    if( filePath != this->getSndIncomingMsg() )
    {
        this->setSndIncomingMsg( filePath );
        emit soundIncomingMessageChanged();
    }
}


void MeegIMSettings::setSoundOutcomingMessage( const QString &filePath )
{
    if( filePath != this->getSndOutcomingMsg() )
    {
        this->setSndOutcomingMsg( filePath );
        emit soundOutcomingMessageChanged();
    }
}


void MeegIMSettings::_setNotifyConnection(bool isSet)
{
    if( isSet != this->notifyConnection() )
    {
        this->setNotifyConnection(isSet);
        emit notifyConnectionChanged();
    }
}


void MeegIMSettings::_setNotifyOnline(bool isSet)
{
    if( isSet != this->notifyOnline() )
    {
        this->setNotifyOnline(isSet);
        emit notifyOnlineChanged();
    }
}

void MeegIMSettings::_setNotifyOffline(bool isSet)
{
    if( isSet != this->notifyOffline() )
    {
        this->setNotifyOffline(isSet);
        emit notifyOfflineChanged();
    }
}


void MeegIMSettings::_setNotifyMessage(bool isSet)
{
    if( isSet != this->notifyMessage() )
    {
        this->setNotifyMessage(isSet);
        emit notifyMessageChanged();
    }
}


void MeegIMSettings::_setNotifyTyping(bool isSet)
{
    if( isSet != this->notifyTyping() )
    {
        this->setNotifyTyping(isSet);
        emit notifyTypingChanged();
    }
}


void MeegIMSettings::setSoundBuddyLogsIn( const QString &filePath )
{
    if( filePath != this->getSndBuddyLogsIn() )
    {
        this->setSndBuddyLogsIn( filePath );
        emit soundBuddyLogsInChanged();
    }
}

void MeegIMSettings::setSoundBuddyLogsOut( const QString &filePath )
{
    if( filePath != this->getSndBuddyLogsOut() )
    {
        this->setSndBuddyLogsOut( filePath );
        emit soundBuddyLogsOutChanged();
    }
}


void MeegIMSettings::_setReconnectWhenError(bool arg)
{
    if (this->reconnectWhenError() != arg) {
        this->setReconnectWhenError( arg );
        emit reconnectWhenErrorChanged();
    }
}

void MeegIMSettings::_setKeepAliveInterval(int arg)
{
    if (this->keepAliveInterval() != arg) {
        this->setKeepAliveInterval( arg );
        emit keepAliveIntervalChanged();
    }
}


void MeegIMSettings::setChatSomeoneSaysMyName( const QString &filePath )
{
    if( filePath != this->getSndChatSaysMyName() )
    {
        this->setSndChatSaysMyName( filePath );
        emit soundChatSomeoneSaysMyNameChanged();
    }
}


void MeegIMSettings::setChatPersonEnters( const QString &filePath )
{
    if( filePath != this->getSndChatPersonEnters() )
    {
        this->setSndChatPersonEnters( filePath );
        emit soundChatPersonEntersChanged();
    }
}


void MeegIMSettings::setChatPersonLeaves( const QString &filePath )
{
    if( filePath != this->getSndChatPersonLeaves() )
    {
        this->setSndChatPersonLeaves( filePath );
        emit soundChatPersonLeavesChanged();
    }
}

void MeegIMSettings::setChatITalk( const QString &filePath )
{
    if( filePath != this->getSndChatITalk() )
    {
        this->setSndChatITalk( filePath );
        emit soundChatITalkChanged();
    }
}


void MeegIMSettings::setChatOthersTalk( const QString &filePath )
{
    if( filePath != this->getSndChatOthersTalk() )
    {
        this->setSndChatOthersTalk( filePath );
        emit soundChatOthersTalkChanged();
    }
}