[SCM] ktp-common-internals packaging branch, master, updated. debian/15.12.1-2-1839-gf0635e9

[Maximiliano Curia]

Gitweb-URL: http://git.debian.org/?p=pkg-kde/applications/ktp-common-internals.git;a=commitdiff;h=cb1835a

The following commit has been merged in the master branch:
commit cb1835a47364b2f6542aa3ffab786807f4d0095b
Author: Martin Klapetek <mklapetek at kde.org>
Date:   Wed Mar 4 18:56:31 2015 +0100

    Add simple accounts migration
    
    This will be run after the kded module loads the plugin. After
    connecting for the first time, the user will be asked for password and
    if he chooses to remember the password, it will become stored in
    KAccounts.
    
    If an account of unknown type (unknown to KAccounts) is found, it will
    use a generic fallback provider and service.
---
 kaccounts/kaccounts-ktp-plugin.cpp | 79 +++++++++++++++++++++++++++++++++++++-
 kaccounts/kaccounts-ktp-plugin.h   |  1 +
 2 files changed, 79 insertions(+), 1 deletion(-)

diff --git a/kaccounts/kaccounts-ktp-plugin.cpp b/kaccounts/kaccounts-ktp-plugin.cpp
index d47c0a9..75dff1b 100644
--- a/kaccounts/kaccounts-ktp-plugin.cpp
+++ b/kaccounts/kaccounts-ktp-plugin.cpp
@@ -24,6 +24,7 @@
 #include <TelepathyQt/PendingOperation>
 #include <TelepathyQt/PendingAccount>
 #include <TelepathyQt/PendingReady>
+#include <TelepathyQt/AccountSet>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
@@ -34,18 +35,29 @@
 
 #include <Accounts/Service>
 #include <Accounts/Manager>
+#include <Accounts/Account>
 
 #include <KAccounts/getcredentialsjob.h>
 #include <KAccounts/core.h>
 
+static QStringList s_knownProviders{QStringLiteral("haze-icq"),
+                                    QStringLiteral("jabber"),
+                                    QStringLiteral("kde-talk"),
+                                    QStringLiteral("haze-sametime"),
+                                    QStringLiteral("haze-yahoo"),
+                                    QStringLiteral("haze-gadugadu")};
+
 class KAccountsKTpPlugin::Private {
 public:
+    Private(KAccountsKTpPlugin *qq) { q = qq; };
     Tp::AccountPtr tpAccountForAccountId(const Accounts::AccountId accountId);
+    void migrateTelepathyAccounts();
 
     Tp::AccountManagerPtr accountManager;
     Tp::ConnectionManagerPtr connectionManager;
     Tp::ProfilePtr profile;
     KSharedConfigPtr kaccountsConfig;
+    KAccountsKTpPlugin *q;
 };
 
 Tp::AccountPtr KAccountsKTpPlugin::Private::tpAccountForAccountId(const Accounts::AccountId accountId)
@@ -57,11 +69,74 @@ Tp::AccountPtr KAccountsKTpPlugin::Private::tpAccountForAccountId(const Accounts
     return accountManager->accountForObjectPath(accountUid);
 }
 
+void KAccountsKTpPlugin::Private::migrateTelepathyAccounts()
+{
+    Accounts::Manager *manager = KAccounts::accountsManager();
+    Accounts::Account *account;
+
+    kaccountsConfig->reparseConfiguration();
+    KConfigGroup ktpKaccountsGroup = kaccountsConfig->group(QStringLiteral("ktp-kaccounts"));
+
+    qDebug() << "Going to migrate Tp accounts";
+
+    Q_FOREACH (const Tp::AccountPtr &tpAccount, accountManager->validAccounts()->accounts()) {
+        if (ktpKaccountsGroup.hasKey(tpAccount->objectPath())) {
+            // we already have this account
+            continue;
+        }
+
+        QString providerName = QStringLiteral("ktp-");
+
+        if (s_knownProviders.contains(tpAccount->serviceName())) {
+            providerName.append(tpAccount->serviceName());
+        } else {
+            providerName.append(QStringLiteral("generic"));
+        }
+
+        qDebug() << "Creating account with providerName" << providerName;
+
+        account = manager->createAccount(providerName);
+        account->setDisplayName(tpAccount->displayName());
+        account->setValue(QStringLiteral("uid"), tpAccount->objectPath());
+        account->setValue(QStringLiteral("username"), tpAccount->nickname());
+        account->setValue(QStringLiteral("auth/mechanism"), QStringLiteral("password"));
+        account->setValue(QStringLiteral("auth/method"), QStringLiteral("password"));
+
+        account->setEnabled(true);
+
+        Accounts::ServiceList services = account->services();
+        Q_FOREACH(const Accounts::Service &service, services) {
+            account->selectService(service);
+            account->setEnabled(tpAccount->isEnabled());
+        }
+
+        qDebug() << tpAccount->nickname() << account->id();
+
+        account->sync();
+        QObject::connect(account, &Accounts::Account::synced, q, &KAccountsKTpPlugin::onAccountSynced);
+    }
+}
+
+void KAccountsKTpPlugin::onAccountSynced()
+{
+    Accounts::Account *account = qobject_cast<Accounts::Account*>(sender());
+    if (!account) {
+        return;
+    }
+    KConfigGroup ktpKaccountsGroup = d->kaccountsConfig->group(QStringLiteral("kaccounts-ktp"));
+    ktpKaccountsGroup.writeEntry(QString::number(account->id()), account->value(QStringLiteral("uid")).toString());
+
+    KConfigGroup kaccountsKtpGroup = d->kaccountsConfig->group(QStringLiteral("ktp-kaccounts"));
+    kaccountsKtpGroup.writeEntry(account->value(QStringLiteral("uid")).toString(), QString::number(account->id()));
+
+    d->kaccountsConfig->sync();
+}
+
 //---------------------------------------------------------------------------------------
 
 KAccountsKTpPlugin::KAccountsKTpPlugin(QObject *parent)
     : KAccountsDPlugin(parent),
-      d(new Private)
+      d(new Private(this))
 {
     d->kaccountsConfig = KSharedConfig::openConfig(QStringLiteral("kaccounts-ktprc"));
 
@@ -99,6 +174,8 @@ void KAccountsKTpPlugin::onAccountManagerReady(Tp::PendingOperation *op)
             onAccountRemoved(kaccountId.toUInt());
         }
     }
+
+    d->migrateTelepathyAccounts();
 }
 
 void KAccountsKTpPlugin::onAccountCreated(const Accounts::AccountId accountId, const Accounts::ServiceList &serviceList)
diff --git a/kaccounts/kaccounts-ktp-plugin.h b/kaccounts/kaccounts-ktp-plugin.h
index 6f54441..4994355 100644
--- a/kaccounts/kaccounts-ktp-plugin.h
+++ b/kaccounts/kaccounts-ktp-plugin.h
@@ -48,6 +48,7 @@ public Q_SLOTS:
 private Q_SLOTS:
     void onConnectionManagerReady(Tp::PendingOperation *op);
     void onAccountManagerReady(Tp::PendingOperation *op);
+    void onAccountSynced();
 
 private:
     class Private;

-- 
ktp-common-internals packaging