Page MenuHomePhorge
Files F117888485

No OneTemporary
Actions

Authored By
Unknown
Size
11 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/migrationutility/sourceaccount.cpp b/migrationutility/sourceaccount.cpp
index 1769406..bd984d7 100644
--- a/migrationutility/sourceaccount.cpp
+++ b/migrationutility/sourceaccount.cpp
@@ -1,331 +1,331 @@
/*
* Copyright (C) 2012 Christian Mollekopf <mollekopf@kolabsys.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "sourceaccount.h"
#include "uiproxy.h"
#include <jobs/fetchmessagesjob.h>
#include <jobs/probekolabserverjob.h>
#include <kimap/session.h>
#include <kimap/listjob.h>
#include <kimap/logoutjob.h>
#include <kimap/capabilitiesjob.h>
#include <kimap/namespacejob.h>
#include <errorhandler.h>
#include <kolabobject.h>
#include <kabc/vcardconverter.h>
#include <kcalcore/memorycalendar.h>
#include <kcalcore/icalformat.h>
SourceAccount::SourceAccount(QObject* parent)
: QObject(parent)
{
}
QStringList SourceAccount::lookupFolderList()
{
return QStringList();
}
QList<Object> SourceAccount::getObjects(const QString& /* folder */)
{
return QList<Object>();
}
void SourceAccount::logout()
{
}
QPair<Kolab::FolderType, QString> SourceAccount::translateFolder(const QString& folder)
{
return QPair<Kolab::FolderType, QString>(Kolab::MailType, folder);
}
TestAccount::TestAccount(QObject* parent)
: SourceAccount(parent)
{
mFolderList << QLatin1String("folder1");
mFolderList << QLatin1String("folder2");
mFolderList << QLatin1String("folder3");
}
QStringList TestAccount::lookupFolderList()
{
return mFolderList;
}
QList<Object> TestAccount::getObjects(const QString& folder)
{
Debug() << folder;
Q_ASSERT(mFolderList.removeAll(folder) == 1);
return QList<Object>();
}
//--------------------------------------------------------------
KolabSourceAccount::KolabSourceAccount(KIMAP::Session *session, QObject* parent)
: SourceAccount(parent),
mSession(session)
{
}
void KolabSourceAccount::init()
{
Q_ASSERT(mSession);
ProbeKolabServerJob *probeJob = new ProbeKolabServerJob(mSession, this);
probeJob->exec();
mKolabFolders = probeJob->kolabFolders();
mPersonalNamespaces = probeJob->personalNamespace();
}
Kolab::FolderType KolabSourceAccount::getFolderType(const QString &folder)
{
if (mKolabFolders.values().contains(folder)) {
return Kolab::folderTypeFromString(mKolabFolders.key(folder).toStdString());
}
return Kolab::MailType;
}
QPair<Kolab::FolderType, QString> KolabSourceAccount::translateFolder(const QString& folder)
{
return QPair<Kolab::FolderType, QString>(getFolderType(folder), folder);
}
QStringList KolabSourceAccount::lookupFolderList()
{
// Debug() << "lookupFolderList" << mHost << mPort << mUsername << mPw;
init();
mMailboxes.clear();
KIMAP::ListJob *listJob = new KIMAP::ListJob(mSession);
listJob->setOption(KIMAP::ListJob::IncludeUnsubscribed);
listJob->setQueriedNamespaces(mPersonalNamespaces);
QObject::connect( listJob, SIGNAL(mailBoxesReceived(QList<KIMAP::MailBoxDescriptor>,QList<QList<QByteArray> >)),
this, SLOT(mailBoxesReceived(QList<KIMAP::MailBoxDescriptor>,QList<QList<QByteArray> >)));
listJob->exec();
Debug() << "found " << mMailboxes.size();
QStringList mailboxes;
foreach (const KIMAP::MailBoxDescriptor &descriptor, mMailboxes) {
mailboxes.append(descriptor.name);
}
return mailboxes;
}
void KolabSourceAccount::mailBoxesReceived(const QList<KIMAP::MailBoxDescriptor> &descriptors, const QList< QList< QByteArray > > &/* flags */)
{
mMailboxes.append(descriptors);
//TODO store folder type from metadata
// for (int i = 0; i < descriptors.size(); i++) {
// Debug() << descriptors.at(i).name;
// foreach (const QByteArray &arr, flags.at(i)) {
// Debug() << arr;
// }
// }
}
QVariant upgradeMessage(KMime::Message::Ptr msg)
{
//TODO deduplicate with upgradetool, check for errors during reading.
Kolab::KolabObjectReader reader;
switch (reader.parseMimeMessage(msg)) {
case Kolab::EventObject:
case Kolab::TodoObject:
case Kolab::JournalObject:
return QVariant::fromValue(reader.getIncidence());
case Kolab::ContactObject:
return QVariant::fromValue(reader.getContact());
case Kolab::DistlistObject:
return QVariant::fromValue(reader.getDistlist());
case Kolab::NoteObject: {
Note note;
note.msg = reader.getNote();
return QVariant::fromValue(note);
}
case Kolab::DictionaryConfigurationObject: {
Dictionary dictionary;
dictionary.dict = reader.getDictionary(dictionary.lang);
return QVariant::fromValue(dictionary);
}
case Kolab::InvalidObject:
default:
//TODO handle configuration objects
Error() << "failed to read mime file";
}
return QVariant();
}
QList<Object> KolabSourceAccount::getObjects(const QString& folder)
{
bool isKolabType = false;
if (mKolabFolders.values().contains(folder)) {
isKolabType = true;
}
// Debug() << folder;
FetchMessagesJob *fetchJob = new FetchMessagesJob(folder, mSession, this);
fetchJob->exec();
Debug() << fetchJob->getMessages().size();
QList<Object> messages;
foreach (const KMime::Message::Ptr &msg, fetchJob->getMessages()) {
Object obj;
if (isKolabType) {
obj.object = upgradeMessage(msg);
} else {
obj.object = QVariant::fromValue(msg);
}
obj.flags = fetchJob->getFlags(msg);
if (!obj.object.isValid()) {
Error() << "got empty message";
continue;
}
messages.append(obj);
}
return messages;
}
void KolabSourceAccount::logout()
{
KIMAP::LogoutJob *logoutJob = new KIMAP::LogoutJob(mSession);
logoutJob->exec();
mSession->close();
mSession->deleteLater();
mSession = 0;
Debug() << "logout done";
}
//--------------------------------------------------------
ExchangeIMAPSourceAccount::ExchangeIMAPSourceAccount(KIMAP::Session* session, QObject* parent)
: KolabSourceAccount(session, parent)
{
}
QPair<Kolab::ObjectType, KMime::Content*> ExchangeIMAPSourceAccount::getObjectType(const KMime::Message::Ptr &msg)
{
const QByteArray calendarType("text/calendar");
const QByteArray vcardType("text/vcard");
Q_FOREACH(KMime::Content *c, msg->contents()) {
Debug() << c->contentType()->mimeType();
if (c->contentType()->mimeType() == calendarType) {
KCalCore::ICalFormat format;
KCalCore::MemoryCalendar::Ptr calendar(new KCalCore::MemoryCalendar(KDateTime::Spec::UTC()));
format.fromRawString(calendar, c->decodedContent());
if (!calendar->events().isEmpty()) {
return QPair<Kolab::ObjectType, KMime::Content*>(Kolab::EventObject, c);
} else if (!calendar->todos().isEmpty()) {
return QPair<Kolab::ObjectType, KMime::Content*>(Kolab::TodoObject, c);
} else if (!calendar->journals().isEmpty()) {
return QPair<Kolab::ObjectType, KMime::Content*>(Kolab::JournalObject, c);
}
}
if (c->contentType()->mimeType() == vcardType) {
return QPair<Kolab::ObjectType, KMime::Content*>(Kolab::ContactObject, c);
}
}
return QPair<Kolab::ObjectType, KMime::Content*>(Kolab::InvalidObject, 0);
}
Kolab::FolderType ExchangeIMAPSourceAccount::getFolderType(const QString &folder)
{
FetchMessagesJob *fetchJob = new FetchMessagesJob(folder, mSession, this);
fetchJob->exec();
Debug() << fetchJob->getMessages().size();
QList<Object> messages;
foreach (const KMime::Message::Ptr &msg, fetchJob->getMessages()) {
Kolab::ObjectType type = getObjectType(msg).first;
if (type == Kolab::EventObject) {
return Kolab::EventType;
}
if (type == Kolab::TodoObject) {
return Kolab::TaskType;
}
if (type == Kolab::JournalObject) {
return Kolab::JournalType;
}
if (type == Kolab::ContactObject) {
return Kolab::ContactType;
}
}
return Kolab::MailType;
}
QPair<Kolab::FolderType, QString> ExchangeIMAPSourceAccount::translateFolder(const QString& folder)
{
return QPair<Kolab::FolderType, QString>(getFolderType(folder), folder);
}
QList<Object> ExchangeIMAPSourceAccount::getObjects(const QString& folder)
{
Debug() << folder;
FetchMessagesJob *fetchJob = new FetchMessagesJob(folder, mSession, this);
fetchJob->exec();
Debug() << fetchJob->getMessages().size();
QList<Object> messages;
foreach (const KMime::Message::Ptr &msg, fetchJob->getMessages()) {
QPair<Kolab::ObjectType, KMime::Content*> type = getObjectType(msg);
Debug() << type.first;
- if (type.first == Kolab::MailType) {
+ if (type.first == Kolab::InvalidObject) {
Object obj;
obj.object = QVariant::fromValue(msg);
obj.flags = fetchJob->getFlags(msg);
messages.append(obj);
} else if (type.first == Kolab::EventObject || type.first == Kolab::TodoObject || type.first == Kolab::JournalObject) {
const QByteArray content = type.second->decodedContent();
Debug() << "Found event object: " << content;
KCalCore::ICalFormat format;
KCalCore::MemoryCalendar::Ptr calendar(new KCalCore::MemoryCalendar(KDateTime::Spec::UTC()));
format.fromRawString(calendar, content);
//We're simply assuming here that we never have different incidence types mixed in a folder
foreach (const KCalCore::Incidence::Ptr &inc, calendar->incidences()) {
Object obj;
obj.object = QVariant::fromValue(inc);
obj.flags = fetchJob->getFlags(msg);
if (!obj.object.isValid()) {
Error() << "got empty message";
continue;
}
messages.append(obj);
}
} else if (type.first == Kolab::ContactObject) {
const QByteArray content = type.second->decodedContent();
Debug() << "Found contact object: " << content;
KABC::VCardConverter format;
const KABC::Addressee addressee = format.parseVCard(content);
Object obj;
obj.object = QVariant::fromValue(addressee);
obj.flags = fetchJob->getFlags(msg);
if (!obj.object.isValid()) {
Error() << "got empty message";
continue;
}
messages.append(obj);
}
}
return messages;
}
\ No newline at end of file

File Metadata

Mime Type
text/x-diff
Expires
Mon, Apr 6, 3:21 AM (3 w, 3 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
18832181
Default Alt Text
(11 KB)

Event Timeline