kolabobject.cpp
No OneTemporary
Actions

Authored By

Unknown

Size

19 KB

Referenced Files

None

Subscribers

None

kolabobject.cpp
View Options

	/*
	* Copyright (C) 2011 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 "kolabobject.h"
	#include <kolabbase.h>
	#include <kolabformatV2/journal.h>
	#include <kolabformatV2/task.h>
	#include <kolabformatV2/event.h>
	#include <kolabformatV2/contact.h>
	#include <kolabformatV2/distributionlist.h>
	#include <kolabformatV2/note.h>
	#include <mime/mimeutils.h>
	#include <conversion/kcalconversion.h>
	#include <conversion/kabcconversion.h>
	#include <qdom.h>
	#include <kdebug.h>
	#include <qbuffer.h>
	#include <akonadi/notes/noteutils.h>
	#include <kolab/kolabformat.h>


	namespace Kolab {

	static QString eventKolabType() { return QString::fromLatin1("application/x-vnd.kolab.event"); };
	static QString todoKolabType() { return QString::fromLatin1("application/x-vnd.kolab.task"); };
	static QString journalKolabType() { return QString::fromLatin1("application/x-vnd.kolab.journal"); };
	static QString contactKolabType() { return QString::fromLatin1("application/x-vnd.kolab.contact"); };
	static QString distlistKolabType() { return QString::fromLatin1("application/x-vnd.kolab.contact.distlist"); }
	static QString noteKolabType() { return QString::fromLatin1("application/x-vnd.kolab.note"); }

	static QString xCalMimeType() { return QString::fromLatin1("application/calendar+xml"); };
	static QString xCardMimeType() { return QString::fromLatin1("application/vcard+xml"); };
	// static QString noteMimeType() { return QString::fromLatin1("application/x-vnd.kolab.*"); };

	/*
	* Parse XML, create KCalCore container and extract attachments
	*/
	//TODO V2 specific
	template <typename KCalPtr, typename Container>
	static KCalPtr fromXML(const QByteArray &xmlData, QStringList &attachments)
	{
	const QDomDocument xmlDoc = KolabV2::KolabBase::loadDocument( QString::fromUtf8(xmlData) ); //TODO extract function from V2 format
	Q_ASSERT ( !xmlDoc.isNull() );
	const KCalPtr i = Container::fromXml( xmlDoc, QString() ); //For parsing we don't need the timezone, so we don't set one
	Q_ASSERT ( i );
	QDomNodeList nodes = xmlDoc.elementsByTagName("inline-attachment");
	for (int i = 0; i < nodes.size(); i++ ) {
	attachments.append(nodes.at(i).toElement().text());
	}
	return i;
	}

	//TODO V2 specific
	template <typename IncidencePtr, typename Converter>
	static inline IncidencePtr incidenceFromKolabImpl( const KMime::Message::Ptr &data, const QByteArray &mimetype, const QString &timezoneId )
	{
	KMime::Content *xmlContent = Mime::findContentByType( data, mimetype );
	if ( !xmlContent ) {
	qWarning() << "couldn't find part";
	return IncidencePtr();
	}
	const QByteArray &xmlData = xmlContent->decodedContent();

	QStringList attachments;
	IncidencePtr ptr = fromXML<IncidencePtr, Converter>(xmlData, attachments); //TODO do we care about timezone?
	Mime::getAttachments(ptr, attachments, data);

	return ptr;
	}


	KABC::Addressee addresseFromKolab( const QByteArray &xmlData, const KMime::Message::Ptr &data)
	{
	KABC::Addressee addressee;
	// kDebug() << "xmlData " << xmlData;
	KolabV2::Contact contact(QString::fromUtf8(xmlData));
	const QString pictureAttachmentName = contact.pictureAttachmentName();
	if (!pictureAttachmentName.isEmpty()) {
	QByteArray type;
	KMime::Content *imgContent = Mime::findContentByName(data, "kolab-picture.png", type);
	if (imgContent) {
	QByteArray imgData = imgContent->decodedContent();
	QBuffer buffer(&imgData);
	buffer.open(QIODevice::ReadOnly);
	QImage image;
	image.load(&buffer, "PNG");
	contact.setPicture(image);
	}
	}

	QString logoAttachmentName = contact.logoAttachmentName();
	if (!logoAttachmentName.isEmpty()) {
	QByteArray type;
	KMime::Content *imgContent = Mime::findContentByName(data, "kolab-logo.png", type);
	if (imgContent) {
	QByteArray imgData = imgContent->decodedContent();
	QBuffer buffer(&imgData);
	buffer.open(QIODevice::ReadOnly);
	QImage image;
	image.load(&buffer, "PNG");
	contact.setLogo(image);
	}
	}

	QString soundAttachmentName = contact.soundAttachmentName();
	if (!soundAttachmentName.isEmpty()) {
	QByteArray type;
	KMime::Content *content = Mime::findContentByName(data, "sound", type);
	if (content) {
	QByteArray sData = content->decodedContent();
	contact.setSound(sData);
	}
	}
	contact.saveTo(&addressee);
	return addressee;
	}

	KABC::ContactGroup contactGroupFromKolab(const QByteArray &xmlData)
	{
	KABC::ContactGroup contactGroup;
	// kDebug() << "xmlData " << xmlData;
	KolabV2::DistributionList distList(QString::fromUtf8(xmlData));
	distList.saveTo(&contactGroup);
	return contactGroup;
	}



	KMime::Message::Ptr noteFromKolab(const QByteArray &xmlData, const KMime::Message::Ptr &data)
	{
	KolabV2::Note j;
	if ( !j.load( xmlData ) ) {
	kWarning() << "failed to read note";
	return KMime::Message::Ptr();
	}

	Akonadi::NoteUtils::NoteMessageWrapper note;
	note.setTitle(j.summary());
	note.setText(j.body().toUtf8());
	note.setFrom("kolab@kde4");
	note.setCreationDate(data->date()->dateTime());
	return note.message();
	}

	KMime::Message::Ptr noteToKolab(const KMime::Message::Ptr& msg)
	{
	Akonadi::NoteUtils::NoteMessageWrapper note(msg);
	KolabV2::Note j;
	j.setSummary( note.title() );
	j.setBody( note.text() );

	KMime::Message::Ptr message = Mime::createMessage( noteKolabType(), false );
	message->subject()->fromUnicodeString( j.summary(), "utf-8" );
	KMime::Content* content = Mime::createMainPart( noteKolabType(), j.saveXML().toUtf8() );
	message->addContent( content );

	message->assemble();
	return message;
	}

	KMime::Message::Ptr contactToKolabFormat(const KolabV2::Contact& contact)
	{
	KMime::Message::Ptr message = Mime::createMessage( contactKolabType(), false ); //TODO v3 mimetype
	message->subject()->fromUnicodeString( contact.uid(), "utf-8" );
	message->from()->fromUnicodeString( contact.fullEmail(), "utf-8" );

	KMime::Content* content = Mime::createMainPart( contactKolabType(), contact.saveXML().toUtf8() ); //TODO v3 mimetype
	message->addContent( content );

	if ( !contact.picture().isNull() ) {
	QByteArray pic;
	QBuffer buffer(&pic);
	buffer.open(QIODevice::WriteOnly);
	contact.picture().save(&buffer, "PNG");
	buffer.close();

	content = Mime::createAttachmentPart(QByteArray(), "image/png", "kolab-picture.png", pic );
	message->addContent(content);
	}

	if ( !contact.logo().isNull() ) {
	QByteArray pic;
	QBuffer buffer(&pic);
	buffer.open(QIODevice::WriteOnly);
	contact.logo().save(&buffer, "PNG");
	buffer.close();

	content = Mime::createAttachmentPart(QByteArray(), "image/png", "kolab-logo.png", pic );
	message->addContent(content);
	}


	if ( !contact.sound().isEmpty() ) {
	content = Mime::createAttachmentPart(QByteArray(), "audio/unknown", "sound", contact.sound() );
	message->addContent(content);
	}

	message->assemble();
	return message;
	}

	//Normalize incidences before serializing them
	void normalizeIncidence(KCalCore::Incidence::Ptr i)
	{
	Q_FOREACH (KCalCore::Attendee::Ptr a, i->attendees()) {
	a->setUid(QString()); //KCalCore sets the pointer as uid, we don't want that (if we wanted one, we'd want a real, globally unique one), so we clear the uid
	}
	//TODO Do we really not need the attachment uri for something else?
	Q_FOREACH (KCalCore::Attachment::Ptr attachment, i->attachments()) {
	attachment->setUri(QString::fromLatin1("cid:")+QString::fromLatin1(KMime::uniqueString() + '@' + "kolab.resource.akonadi")); //Serialize the attachment as attachment with uri, referencing the created mime-part
	}
	}


	KCalCore::Event::Ptr readV2EventXML(const QByteArray& xmlData, QStringList& attachments)
	{
	return fromXML<KCalCore::Event::Ptr, KolabV2::Event>(xmlData, attachments);
	}


	//@cond PRIVATE
	class KolabObjectReader::Private
	{
	public:
	Private()
	: mObjectType( InvalidObject ),
	mVersion( KolabV3 )
	{}

	KCalCore::Incidence::Ptr mIncidence;
	KABC::Addressee mAddressee;
	KABC::ContactGroup mContactGroup;
	KMime::Message::Ptr mNote;
	ObjectType mObjectType;
	Version mVersion;
	};
	//@endcond

	KolabObjectReader::KolabObjectReader()
	: d( new KolabObjectReader::Private )
	{

	}

	KolabObjectReader::KolabObjectReader(const KMime::Message::Ptr& msg)
	: d( new KolabObjectReader::Private )
	{
	parseMimeMessage(msg);
	}

	KolabObjectReader::~KolabObjectReader()
	{
	delete d;
	}

	ObjectType KolabObjectReader::parseMimeMessage(const KMime::Message::Ptr &msg)
	{
	d->mObjectType = InvalidObject;
	KMime::Headers::Base *xKolabHeader = msg->getHeaderByType("X-Kolab-Type");
	if (!xKolabHeader) {
	kWarning() << "could not find xKolabHeader";
	return InvalidObject;
	}
	const QString &kolabType = xKolabHeader->asUnicodeString(); //TODO we probably shouldn't use unicodeString

	KMime::Headers::Base *xKolabVersion = msg->getHeaderByType("X-Kolab-Version"); //TODO make sure v3 is written out
	if (!xKolabVersion) {
	d->mVersion = KolabV2;
	} else {
	if (xKolabVersion->asUnicodeString() == "v3") {
	d->mVersion = KolabV3;
	}
	}

	if (d->mVersion == KolabV2) {
	KMime::Content *xmlContent = Mime::findContentByType( msg, kolabType.toLocal8Bit() );
	if ( !xmlContent ) {
	qWarning() << "no part found";
	return InvalidObject;
	}
	const QByteArray &xmlData = xmlContent->decodedContent();
	QStringList attachments;
	kDebug() << kolabType;
	if (kolabType == eventKolabType()) { //Event
	kDebug() << "v2event";
	d->mIncidence = fromXML<KCalCore::Event::Ptr, KolabV2::Event>(xmlData, attachments);
	d->mObjectType = EventObject;
	} else if (kolabType == todoKolabType()) { //Todo
	kDebug() << "v2todo";
	d->mIncidence = fromXML<KCalCore::Todo::Ptr, KolabV2::Task>(xmlData, attachments);
	d->mObjectType = TodoObject;
	} else if (kolabType == journalKolabType()) { //Journal
	kDebug() << "v2journal";
	d->mIncidence = fromXML<KCalCore::Journal::Ptr, KolabV2::Journal>(xmlData, attachments);
	d->mObjectType = JournalObject;
	} else if (kolabType == contactKolabType()) { //Contact
	kDebug() << "v2contact";
	d->mAddressee = addresseFromKolab(xmlData, msg);
	d->mObjectType = ContactObject;
	} else if (kolabType == distlistKolabType()) { //Distlist
	kDebug() << "v2distlist";
	d->mContactGroup = contactGroupFromKolab(xmlData);
	d->mObjectType = DistlistObject;
	} else if (kolabType == noteKolabType()) { //Note
	kDebug() << "v2notes";
	d->mNote = noteFromKolab(xmlData, msg);
	d->mObjectType = NoteObject;
	} else {
	kWarning() << "no kolab object found " << kolabType;
	}
	if (d->mIncidence) {
	Mime::getAttachments(d->mIncidence, attachments, msg);
	}
	} else { //V3

	QStringList attachments;

	if (kolabType == eventKolabType()) { //Event
	kDebug() << "event";
	KMime::Content *xmlContent = Mime::findContentByType( msg, xCalMimeType().toLocal8Bit() );
	if ( !xmlContent ) {
	qWarning() << "no part found";
	return InvalidObject;
	}
	const Kolab::Event & event = Kolab::readEvent(std::string(xmlContent->decodedContent().data(), xmlContent->decodedContent().size()), false);
	foreach (const Kolab::Attachment &a, event.attachments()) {
	attachments.append(QString::fromStdString(a.uri()));
	}
	d->mIncidence = Kolab::Conversion::toKCalCore(event);
	d->mObjectType = EventObject;
	} else if (kolabType == todoKolabType()) { //Todo
	kDebug() << "todo";
	KMime::Content *xmlContent = Mime::findContentByType( msg, xCalMimeType().toLocal8Bit() );
	if ( !xmlContent ) {
	qWarning() << "no part found";
	return InvalidObject;
	}
	const Kolab::Todo & event = Kolab::readTodo(std::string(xmlContent->decodedContent().data(), xmlContent->decodedContent().size()), false);
	foreach (const Kolab::Attachment &a, event.attachments()) {
	attachments.append(QString::fromStdString(a.uri()));
	}
	d->mIncidence = Kolab::Conversion::toKCalCore(event);
	d->mObjectType = TodoObject;
	} else if (kolabType == journalKolabType()) { //Journal
	kDebug() << "journal";
	KMime::Content *xmlContent = Mime::findContentByType( msg, xCalMimeType().toLocal8Bit() );
	if ( !xmlContent ) {
	qWarning() << "no part found";
	return InvalidObject;
	}
	const Kolab::Journal & event = Kolab::readJournal(std::string(xmlContent->decodedContent().data(), xmlContent->decodedContent().size()), false);
	foreach (const Kolab::Attachment &a, event.attachments()) {
	attachments.append(QString::fromStdString(a.uri()));
	}
	d->mIncidence = Kolab::Conversion::toKCalCore(event);
	d->mObjectType = JournalObject;
	} else if (kolabType == contactKolabType()) { //Contact
	kDebug() << "contact";
	KMime::Content *xmlContent = Mime::findContentByType( msg, xCardMimeType().toLocal8Bit() );
	if ( !xmlContent ) {
	qWarning() << "no part found";
	return InvalidObject;
	}
	const Kolab::Contact &contact = Kolab::readContact(std::string(xmlContent->decodedContent().data(), xmlContent->decodedContent().size()), false);
	d->mAddressee = Kolab::Conversion::toKABC(contact); //TODO extract attachments
	d->mObjectType = ContactObject;
	} else if (kolabType == distlistKolabType()) { //Distlist
	kDebug() << "distlist";
	d->mObjectType = DistlistObject;
	} else if (kolabType == noteKolabType()) { //Note
	kDebug() << "notes";
	d->mObjectType = NoteObject;
	} else {
	kWarning() << "no kolab object found " << kolabType;
	}
	if (d->mIncidence) {
	kDebug() << "getting attachments";
	d->mIncidence->clearAttachments(); //We are going to readd them with content
	Mime::getAttachmentsById(d->mIncidence, attachments, msg);
	}
	}
	return d->mObjectType;
	}

	Version KolabObjectReader::getVersion() const
	{
	return d->mVersion;
	}

	ObjectType KolabObjectReader::getType() const
	{
	return d->mObjectType;
	}

	KCalCore::Event::Ptr KolabObjectReader::getEvent() const
	{
	return d->mIncidence.dynamicCast<KCalCore::Event>();
	}

	KCalCore::Todo::Ptr KolabObjectReader::getTodo() const
	{
	return d->mIncidence.dynamicCast<KCalCore::Todo>();
	}

	KCalCore::Journal::Ptr KolabObjectReader::getJournal() const
	{
	return d->mIncidence.dynamicCast<KCalCore::Journal>();
	}

	KCalCore::Incidence::Ptr KolabObjectReader::getIncidence() const
	{
	return d->mIncidence;
	}

	KABC::Addressee KolabObjectReader::getContact() const
	{
	return d->mAddressee;
	}

	KABC::ContactGroup KolabObjectReader::getDistlist() const
	{
	return d->mContactGroup;
	}

	KMime::Message::Ptr KolabObjectReader::getNote() const
	{
	return d->mNote;
	}



	KMime::Message::Ptr KolabObjectWriter::writeEvent(const KCalCore::Event::Ptr &i, Version v, const QString &tz)
	{
	Q_ASSERT(!i.isNull());
	if (v == KolabV3) {
	normalizeIncidence(i);
	const Kolab::Event &incidence = Kolab::Conversion::fromKCalCore(*i);
	const std::string &v3String = Kolab::writeEvent(incidence);
	return Mime::createMessage(i, xCalMimeType(), eventKolabType(), QString::fromStdString(v3String).toLocal8Bit(), true);
	}
	const QString &xml = KolabV2::Event::eventToXML(i, tz);
	return Mime::createMessage(i, eventKolabType(), eventKolabType(), xml.toLocal8Bit(), false);
	}

	KMime::Message::Ptr KolabObjectWriter::writeTodo(const KCalCore::Todo::Ptr &i, Version v, const QString &tz)
	{
	Q_ASSERT(!i.isNull());
	if (v == KolabV3) {
	normalizeIncidence(i);
	const Kolab::Todo &incidence = Kolab::Conversion::fromKCalCore(*i);
	const std::string &v3String = Kolab::writeTodo(incidence);
	return Mime::createMessage(i, xCalMimeType(), todoKolabType(), QString::fromStdString(v3String).toLocal8Bit(), true);
	}
	const QString &xml = KolabV2::Task::taskToXML(i, tz);
	return Mime::createMessage(i, todoKolabType(), todoKolabType(), xml.toLocal8Bit(), false);
	}

	KMime::Message::Ptr KolabObjectWriter::writeJournal(const KCalCore::Journal::Ptr &i, Version v, const QString &tz)
	{
	Q_ASSERT(!i.isNull());
	if (v == KolabV3) {
	normalizeIncidence(i);
	const Kolab::Journal &incidence = Kolab::Conversion::fromKCalCore(*i);
	const std::string &v3String = Kolab::writeJournal(incidence);
	return Mime::createMessage(i, xCalMimeType(), journalKolabType(), QString::fromStdString(v3String).toLocal8Bit(), true);
	}
	const QString &xml = KolabV2::Journal::journalToXML(i, tz);
	return Mime::createMessage(i, journalKolabType(), journalKolabType(), xml.toLocal8Bit(), false);
	}

	KMime::Message::Ptr KolabObjectWriter::writeContact(const KABC::Addressee &addressee, Version v)
	{
	if (v == KolabV3) {
	const Kolab::Contact &contact = Kolab::Conversion::fromKABC(addressee);
	const std::string &v3String = Kolab::writeContact(contact);
	return Mime::createMessage(addressee, xCardMimeType(), contactKolabType(), QString::fromStdString(v3String).toLocal8Bit(), true);
	}
	KolabV2::Contact contact(&addressee);
	return contactToKolabFormat(contact);
	}

	KMime::Message::Ptr distListToKolabFormat(const KolabV2::DistributionList& distList)
	{
	KMime::Message::Ptr message = Mime::createMessage( distlistKolabType(), false );
	message->subject()->fromUnicodeString( distList.uid(), "utf-8" );
	message->from()->fromUnicodeString( distList.uid(), "utf-8" );

	KMime::Content* content = Mime::createMainPart( distlistKolabType(), distList.saveXML().toUtf8() );
	message->addContent( content );

	message->assemble();
	return message;
	}

	KMime::Message::Ptr KolabObjectWriter::writeDistlist(const KABC::ContactGroup &distlist, Version v)
	{
	if (v == KolabV3) {
	//TODO
	}
	KolabV2::DistributionList d(&distlist);
	return distListToKolabFormat(d);
	}

	KMime::Message::Ptr KolabObjectWriter::writeNote(const KMime::Message::Ptr &note, Version v)
	{
	Q_ASSERT(note.get());
	if (v == KolabV3) {
	//TODO
	}
	return noteToKolab(note);
	}



	}; //Namespace

File Metadata

Mime Type: text/x-c++
Expires: Fri, Apr 24, 11:10 AM (1 w, 5 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 18896563
Default Alt Text: kolabobject.cpp (19 KB)

kolabobject.cppNo OneTemporaryActions

kolabobject.cppView Options

File Metadata

Event Timeline

kolabobject.cpp
No OneTemporary
Actions

kolabobject.cpp
View Options