qtorganizer5-eds-0.1.1+14.04.20140415.1/ 0000755 0000153 0177776 00000000000 12323306646 017456 5 ustar pbuser nogroup 0000000 0000000 qtorganizer5-eds-0.1.1+14.04.20140415.1/cmake/ 0000755 0000153 0177776 00000000000 12323306646 020536 5 ustar pbuser nogroup 0000000 0000000 qtorganizer5-eds-0.1.1+14.04.20140415.1/cmake/lcov.cmake 0000644 0000153 0177776 00000005020 12323305647 022500 0 ustar pbuser nogroup 0000000 0000000 # - This module creates a new 'lcov' target which generates
# a coverage analysis html output.
# LCOV is a graphical front-end for GCC's coverage testing tool gcov. Please see
# http://ltp.sourceforge.net/coverage/lcov.php
#
# Usage: you must add an option to your CMakeLists.txt to build your application
# with coverage support. Then you need to include this file to the lcov target.
#
# Example:
# IF(BUILD_WITH_COVERAGE)
# SET(CMAKE_C_FLAGS "-g -O0 -Wall -fprofile-arcs -ftest-coverage")
# SET(CMAKE_CXX_FLAGS "-g -O0 -Wall -fprofile-arcs -ftest-coverage")
# SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage -lgcov")
# include(${CMAKE_SOURCE_DIR}/cmake/lcov.cmake)
# ENDIF(BUILD_WITH_COVERAGE)
#=============================================================================
# Copyright 2010 ascolab GmbH
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distributed this file outside of CMake, substitute the full
# License text for the above reference.)
set(REMOVE_PATTERN
q*.h
*.moc
moc_*.cpp
locale_facets.h
new
move.h)
## lcov target
ADD_CUSTOM_TARGET(lcov)
ADD_CUSTOM_COMMAND(TARGET lcov
COMMAND mkdir -p coverage
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
ADD_CUSTOM_COMMAND(TARGET lcov
COMMAND lcov --directory . --zerocounters
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
ADD_CUSTOM_COMMAND(TARGET lcov
COMMAND make test
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
ADD_CUSTOM_COMMAND(TARGET lcov
COMMAND lcov --directory . --capture --output-file ./coverage/stap_all.info --no-checksum --compat-libtool
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
ADD_CUSTOM_COMMAND(TARGET lcov
COMMAND lcov --directory . -r ./coverage/stap_all.info ${REMOVE_PATTERN} --output-file ./coverage/stap.info
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
ADD_CUSTOM_COMMAND(TARGET lcov
COMMAND genhtml -o ./coverage --title "Code Coverage" --legend --show-details --demangle-cpp ./coverage/stap.info
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
ADD_CUSTOM_COMMAND(TARGET lcov
COMMAND echo "Open ${CMAKE_BINARY_DIR}/coverage/index.html to view the coverage analysis results."
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
)
qtorganizer5-eds-0.1.1+14.04.20140415.1/cmake/chewieplugin.cmake 0000644 0000153 0177776 00000001777 12323305647 024237 0 ustar pbuser nogroup 0000000 0000000 # -*- cmake -*-
# Generates a rule to create chewie plugin
#
# Typical use -
#
# SET(SRC_FILES head1.h head2.h head3.h)
# SET(LIBRARIES foolib barlib)
# SET(QT_MODULES Core Qml)
# SET(EXTRA_INCLUDE ${GLIB_INCLUDE_DIRS})
# CREATE_CHEWIE_PLUGIN(fooplugin LIBRARIES QT_MODULES EXTRA_INCLUDE SRC_FILES)
macro(CREATE_CHEWIE_PLUGIN PLUGIN_NAME PLUGIN_LINK_LIBRARIES PLUGIN_QT_MODULES PLUGIN_EXTRA_INCLUDE PLUGIN_SOURCE)
add_library(${PLUGIN_NAME} MODULE
${${PLUGIN_SOURCE}})
set_target_properties(${PLUGIN_NAME}
PROPERTIES PREFIX ""
LIBRARY_OUTPUT_DIRECTORY ${chewieplugins_BINARY_DIR})
target_link_libraries(${PLUGIN_NAME}
${${PLUGIN_LINK_LIBRARIES}})
qt5_use_modules(${PLUGIN_NAME} ${${PLUGIN_QT_MODULES}})
include_directories(
${libchewieui_SOURCE_DIR}
${${PLUGIN_EXTRA_INCLUDE}})
install(TARGETS ${PLUGIN_NAME}
LIBRARY DESTINATION ${CHEWIE_PLUGINS_DIR})
endmacro()
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/ 0000755 0000153 0177776 00000000000 12323306646 021637 5 ustar pbuser nogroup 0000000 0000000 qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-enginedata.h 0000644 0000153 0177776 00000003340 12323305647 027037 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of canonical-pim-service
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_ENGINEDATA_H__
#define __QORGANIZER_EDS_ENGINEDATA_H__
#include
#include
#include
#include
#include
#include
class SourceRegistry;
class ViewWatcher;
class RequestData;
class QOrganizerEDSEngineData : public QSharedData
{
public:
QOrganizerEDSEngineData();
QOrganizerEDSEngineData(const QOrganizerEDSEngineData& other);
~QOrganizerEDSEngineData();
template
void emitSharedSignals(K* cs)
{
Q_FOREACH(QtOrganizer::QOrganizerManagerEngine* engine, m_sharedEngines) {
cs->emitSignals(engine);
}
}
ViewWatcher* watch(const QString &collectionId);
void unWatch(const QString &collectionId);
QAtomicInt m_refCount;
SourceRegistry *m_sourceRegistry;
QSet m_sharedEngines;
private:
QMap m_viewWatchers;
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-factory.cpp 0000644 0000153 0177776 00000001722 12323305711 026734 0 ustar pbuser nogroup 0000000 0000000 #include "qorganizer-eds-factory.h"
#include "qorganizer-eds-collection-engineid.h"
#include "qorganizer-eds-engineid.h"
#include "qorganizer-eds-engine.h"
#include
using namespace QtOrganizer;
QOrganizerManagerEngine* QOrganizerEDSFactory::engine(const QMap& parameters, QOrganizerManager::Error* error)
{
Q_UNUSED(error);
return QOrganizerEDSEngine::createEDSEngine(parameters);
}
QOrganizerItemEngineId* QOrganizerEDSFactory::createItemEngineId(const QMap& parameters, const QString& idString) const
{
Q_UNUSED(parameters);
return new QOrganizerEDSEngineId(idString);
}
QOrganizerCollectionEngineId* QOrganizerEDSFactory::createCollectionEngineId(const QMap& parameters, const QString& idString) const
{
Q_UNUSED(parameters);
return new QOrganizerEDSCollectionEngineId(idString);
}
QString QOrganizerEDSFactory::managerName() const
{
return QString::fromLatin1("eds");
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-engine.cpp 0000644 0000153 0177776 00000252206 12323305711 026537 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of canonical-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-engine.h"
#include "qorganizer-eds-engineid.h"
#include "qorganizer-eds-collection-engineid.h"
#include "qorganizer-eds-fetchrequestdata.h"
#include "qorganizer-eds-fetchbyidrequestdata.h"
#include "qorganizer-eds-fetchocurrencedata.h"
#include "qorganizer-eds-saverequestdata.h"
#include "qorganizer-eds-removerequestdata.h"
#include "qorganizer-eds-removebyidrequestdata.h"
#include "qorganizer-eds-savecollectionrequestdata.h"
#include "qorganizer-eds-removecollectionrequestdata.h"
#include "qorganizer-eds-viewwatcher.h"
#include "qorganizer-eds-enginedata.h"
#include "qorganizer-eds-source-registry.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace QtOrganizer;
QOrganizerEDSEngineData *QOrganizerEDSEngine::m_globalData = 0;
QOrganizerEDSEngine* QOrganizerEDSEngine::createEDSEngine(const QMap& parameters)
{
Q_UNUSED(parameters);
if (!m_globalData) {
m_globalData = new QOrganizerEDSEngineData();
m_globalData->m_sourceRegistry = new SourceRegistry;
}
m_globalData->m_refCount.ref();
return new QOrganizerEDSEngine(m_globalData);
}
QOrganizerEDSEngine::QOrganizerEDSEngine(QOrganizerEDSEngineData *data)
: d(data)
{
d->m_sharedEngines << this;
Q_FOREACH(const QString &collectionId, d->m_sourceRegistry->collectionsIds()){
onSourceAdded(collectionId);
}
connect(d->m_sourceRegistry, SIGNAL(sourceAdded(QString)), SLOT(onSourceAdded(QString)));
connect(d->m_sourceRegistry, SIGNAL(sourceRemoved(QString)), SLOT(onSourceRemoved(QString)));
d->m_sourceRegistry->load();
}
QOrganizerEDSEngine::~QOrganizerEDSEngine()
{
Q_FOREACH(QOrganizerAbstractRequest *req, m_runningRequests.keys()) {
req->cancel();
}
Q_ASSERT(m_runningRequests.count() == 0);
d->m_sharedEngines.remove(this);
if (!d->m_refCount.deref()) {
delete d;
m_globalData = 0;
}
}
QString QOrganizerEDSEngine::managerName() const
{
return QOrganizerEDSEngineId::managerNameStatic();
}
/*! \reimp
*/
QMap QOrganizerEDSEngine::managerParameters() const
{
QMap params;
return params;
}
void QOrganizerEDSEngine::itemsAsync(QOrganizerItemFetchRequest *req)
{
FetchRequestData *data = new FetchRequestData(this,
d->m_sourceRegistry->collectionsIds(),
req);
itemsAsyncStart(data);
}
void QOrganizerEDSEngine::itemsAsyncStart(FetchRequestData *data)
{
QString collection = data->nextCollection();
if (!collection.isEmpty()) {
EClient *client = data->parent()->d->m_sourceRegistry->client(collection);
data->setClient(client);
g_object_unref(client);
if (data->hasDateInterval()) {
e_cal_client_generate_instances(data->client(),
data->startDate(),
data->endDate(),
data->cancellable(),
(ECalRecurInstanceFn) QOrganizerEDSEngine::itemsAsyncListed,
data,
(GDestroyNotify) QOrganizerEDSEngine::itemsAsyncDone);
} else {
// if no date interval was set we return only the main events without recurrence
e_cal_client_get_object_list_as_comps(E_CAL_CLIENT(client),
data->dateFilter().toUtf8().data(),
data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::itemsAsyncListedAsComps,
data);
}
} else {
data->finish();
delete data;
}
}
void QOrganizerEDSEngine::itemsAsyncDone(FetchRequestData *data)
{
itemsAsyncStart(data);
}
void QOrganizerEDSEngine::itemsAsyncListed(ECalComponent *comp,
time_t instanceStart,
time_t instanceEnd,
FetchRequestData *data)
{
Q_UNUSED(instanceStart);
Q_UNUSED(instanceEnd);
icalcomponent *icalComp = icalcomponent_new_clone(e_cal_component_get_icalcomponent(comp));
if (icalComp) {
data->appendResult(icalComp);
}
}
void QOrganizerEDSEngine::itemsAsyncListedAsComps(GObject *source,
GAsyncResult *res,
FetchRequestData *data)
{
Q_UNUSED(source);
GError *gError = 0;
GSList *events = 0;
e_cal_client_get_object_list_as_comps_finish(E_CAL_CLIENT(data->client()),
res,
&events,
&gError);
if (gError) {
qWarning() << "Fail to list events in calendar" << gError->message;
g_error_free(gError);
gError = 0;
data->finish(QOrganizerManager::InvalidCollectionError);
delete data;
return;
} else {
data->appendResults(data->parent()->parseEvents(data->collection(), events, false));
}
itemsAsyncStart(data);
}
void QOrganizerEDSEngine::itemsByIdAsync(QOrganizerItemFetchByIdRequest *req)
{
FetchByIdRequestData *data = new FetchByIdRequestData(this, req);
itemsByIdAsyncStart(data);
}
void QOrganizerEDSEngine::itemsByIdAsyncStart(FetchByIdRequestData *data)
{
QString id = data->nextId();
if (!id.isEmpty()) {
QStringList ids = id.split("/");
if (ids.length() == 2) {
Q_ASSERT(ids.length() == 2);
QString collectionId = ids[0];
QString rId;
QString itemId = QOrganizerEDSEngineId::toComponentId(ids[1], &rId);
EClient *client = data->parent()->d->m_sourceRegistry->client(collectionId);
if (client) {
data->setClient(client);
e_cal_client_get_object(data->client(),
itemId.toUtf8().data(),
rId.toUtf8().data(),
data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::itemsByIdAsyncListed,
data);
g_object_unref(client);
return;
}
}
} else if (data->end()) {
data->finish();
delete data;
return;
}
qWarning() << "Invalid item id" << id;
data->appendResult(QOrganizerItem());
itemsByIdAsyncStart(data);
}
void QOrganizerEDSEngine::itemsByIdAsyncListed(GObject *client,
GAsyncResult *res,
FetchByIdRequestData *data)
{
Q_UNUSED(client);
GError *gError = 0;
icalcomponent *icalComp = 0;
e_cal_client_get_object_finish(data->client(), res, &icalComp, &gError);
if (gError) {
qWarning() << "Fail to list events in calendar" << gError->message;
g_error_free(gError);
gError = 0;
data->appendResult(QOrganizerItem());
} else if (icalComp) {
GSList *events = g_slist_append(0, icalComp);
QList items = data->parent()->parseEvents(data->currentCollectionId(), events, true);
Q_ASSERT(items.size() == 1);
data->appendResult(items[0]);
g_slist_free_full(events, (GDestroyNotify) icalcomponent_free);
}
itemsByIdAsyncStart(data);
}
void QOrganizerEDSEngine::itemOcurrenceAsync(QOrganizerItemOccurrenceFetchRequest *req)
{
FetchOcurrenceData *data = new FetchOcurrenceData(this, req);
QString rId;
QString cId = QOrganizerEDSEngineId::toComponentId(req->parentItem().id(), &rId);
EClient *client = data->parent()->d->m_sourceRegistry->client(req->parentItem().collectionId().toString());
if (client) {
data->setClient(client);
e_cal_client_get_object(data->client(),
cId.toUtf8(), rId.toUtf8(),
data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::itemOcurrenceAsyncGetObjectDone,
data);
g_object_unref(client);
} else {
qWarning() << "Fail to find collection:" << req->parentItem().collectionId();
data->finish(QOrganizerManager::DoesNotExistError);
delete data;
return;
}
}
void QOrganizerEDSEngine::itemOcurrenceAsyncGetObjectDone(GObject *source,
GAsyncResult *res,
FetchOcurrenceData *data)
{
Q_UNUSED(source);
GError *error = 0;
icalcomponent *comp = 0;
e_cal_client_get_object_finish(data->client(), res, &comp, &error);
if (error) {
qWarning() << "Fail to get object for id:" << data->request()->parentItem();
g_error_free(error);
data->finish(QOrganizerManager::DoesNotExistError);
delete data;
return;
}
e_cal_client_generate_instances_for_object(data->client(),
comp,
data->startDate(),
data->endDate(),
data->cancellable(),
(ECalRecurInstanceFn) QOrganizerEDSEngine::itemOcurrenceAsyncListed,
data,
(GDestroyNotify) QOrganizerEDSEngine::itemOcurrenceAsyncDone);
}
void QOrganizerEDSEngine::itemOcurrenceAsyncListed(ECalComponent *comp,
time_t instanceStart,
time_t instanceEnd,
FetchOcurrenceData *data)
{
Q_UNUSED(instanceStart);
Q_UNUSED(instanceEnd);
icalcomponent *icalComp = icalcomponent_new_clone(e_cal_component_get_icalcomponent(comp));
if (icalComp) {
data->appendResult(icalComp);
}
}
void QOrganizerEDSEngine::itemOcurrenceAsyncDone(FetchOcurrenceData *data)
{
data->finish();
delete data;
}
QList QOrganizerEDSEngine::items(const QList &itemIds,
const QOrganizerItemFetchHint &fetchHint,
QMap *errorMap,
QOrganizerManager::Error *error)
{
QOrganizerItemFetchByIdRequest *req = new QOrganizerItemFetchByIdRequest(this);
req->setIds(itemIds);
req->setFetchHint(fetchHint);
startRequest(req);
waitForRequestFinished(req, 0);
if (error) {
*error = req->error();
}
if (errorMap) {
*errorMap = req->errorMap();
}
req->deleteLater();
return req->items();
}
QList QOrganizerEDSEngine::items(const QOrganizerItemFilter &filter,
const QDateTime &startDateTime,
const QDateTime &endDateTime,
int maxCount,
const QList &sortOrders,
const QOrganizerItemFetchHint &fetchHint,
QOrganizerManager::Error *error)
{
QOrganizerItemFetchRequest *req = new QOrganizerItemFetchRequest(this);
req->setFilter(filter);
req->setStartDate(startDateTime);
req->setEndDate(endDateTime);
req->setMaxCount(maxCount);
req->setSorting(sortOrders);
req->setFetchHint(fetchHint);
startRequest(req);
waitForRequestFinished(req, 0);
if (error) {
*error = req->error();
}
req->deleteLater();
return req->items();
}
QList QOrganizerEDSEngine::itemIds(const QOrganizerItemFilter &filter,
const QDateTime &startDateTime,
const QDateTime &endDateTime,
const QList &sortOrders,
QOrganizerManager::Error *error)
{
qWarning() << Q_FUNC_INFO << "Not implemented";
QList items;
if (error) {
*error = QOrganizerManager::NotSupportedError;
}
return items;
}
QList QOrganizerEDSEngine::itemOccurrences(const QOrganizerItem &parentItem,
const QDateTime &startDateTime,
const QDateTime &endDateTime,
int maxCount,
const QOrganizerItemFetchHint &fetchHint,
QOrganizerManager::Error *error)
{
QOrganizerItemOccurrenceFetchRequest *req = new QOrganizerItemOccurrenceFetchRequest(this);
req->setParentItem(parentItem);
req->setStartDate(startDateTime);
req->setEndDate(endDateTime);
req->setMaxOccurrences(maxCount);
req->setFetchHint(fetchHint);
startRequest(req);
waitForRequestFinished(req, 0);
if (error) {
*error = req->error();
}
req->deleteLater();
return req->itemOccurrences();
}
QList QOrganizerEDSEngine::itemsForExport(const QDateTime &startDateTime,
const QDateTime &endDateTime,
const QOrganizerItemFilter &filter,
const QList &sortOrders,
const QOrganizerItemFetchHint &fetchHint,
QOrganizerManager::Error *error)
{
qWarning() << Q_FUNC_INFO << "Not implemented";
if (error) {
*error = QOrganizerManager::NotSupportedError;
}
return QList();
}
void QOrganizerEDSEngine::saveItemsAsync(QOrganizerItemSaveRequest *req)
{
if (req->items().count() == 0) {
QOrganizerManagerEngine::updateItemSaveRequest(req,
QList(),
QOrganizerManager::NoError,
QMap(),
QOrganizerAbstractRequest::FinishedState);
return;
}
SaveRequestData *data = new SaveRequestData(this, req);
saveItemsAsyncStart(data);
}
void QOrganizerEDSEngine::saveItemsAsyncStart(SaveRequestData *data)
{
QString collectionId = data->nextCollection();
if (collectionId.isNull() && data->end()) {
data->finish();
delete data;
return;
} else {
bool createItems = true;
QList items = data->takeItemsToCreate();
if (items.isEmpty()) {
createItems = false;
items = data->takeItemsToUpdate();
}
if (items.isEmpty()) {
saveItemsAsyncStart(data);
return;
}
if (collectionId.isEmpty() && createItems) {
collectionId = data->parent()->d->m_sourceRegistry->defaultCollection().id().toString();
}
EClient *client = data->parent()->d->m_sourceRegistry->client(collectionId);
if (!client) {
Q_FOREACH(const QOrganizerItem &i, items) {
data->appendResult(i, QOrganizerManager::InvalidCollectionError);
}
saveItemsAsyncStart(data);
return;
}
Q_ASSERT(client);
data->setClient(client);
g_object_unref(client);
bool hasRecurrence = false;
GSList *comps = parseItems(data->client(),
items,
&hasRecurrence);
if (comps) {
data->setWorkingItems(items);
if (createItems) {
e_cal_client_create_objects(data->client(),
comps,
data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::saveItemsAsyncCreated,
data);
} else {
//WORKAROUND: There is no api to say what kind of update we want in case of update recurrence
// items (E_CAL_OBJ_MOD_ALL, E_CAL_OBJ_MOD_THIS, E_CAL_OBJ_MOD_THISNADPRIOR, E_CAL_OBJ_MOD_THIS_AND_FUTURE)
// as temporary solution the user can use "update-mode" property in QOrganizerItemSaveRequest object,
// if not was specified, we will try to guess based on the event list.
// If the event list does not cotain any recurrence event we will use E_CAL_OBJ_MOD_ALL
// If the event list cotains any recurrence event we will use E_CAL_OBJ_MOD_THIS
// all other cases should be explicitly specified using "update-mode" property
int updateMode = data->updateMode();
if (updateMode == -1) {
updateMode = hasRecurrence ? E_CAL_OBJ_MOD_THIS : E_CAL_OBJ_MOD_ALL;
}
e_cal_client_modify_objects(data->client(),
comps,
static_cast(updateMode),
data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::saveItemsAsyncModified,
data);
}
g_slist_free_full(comps, (GDestroyNotify) icalcomponent_free);
} else {
qWarning() << "Fail to translate items";
}
}
}
void QOrganizerEDSEngine::saveItemsAsyncModified(GObject *source_object,
GAsyncResult *res,
SaveRequestData *data)
{
Q_UNUSED(source_object);
GError *gError = 0;
gboolean result = e_cal_client_modify_objects_finish(E_CAL_CLIENT(data->client()),
res,
&gError);
QCoreApplication::processEvents();
if (gError) {
qWarning() << "Fail to modify items" << gError->message;
g_error_free(gError);
gError = 0;
Q_FOREACH(const QOrganizerItem &i, data->workingItems()) {
data->appendResult(i, QOrganizerManager::UnspecifiedError);
}
} else {
data->appendResults(data->workingItems());
}
saveItemsAsyncStart(data);
}
void QOrganizerEDSEngine::saveItemsAsyncCreated(GObject *source_object,
GAsyncResult *res,
SaveRequestData *data)
{
Q_UNUSED(source_object);
GError *gError = 0;
GSList *uids = 0;
e_cal_client_create_objects_finish(E_CAL_CLIENT(data->client()),
res,
&uids,
&gError);
QCoreApplication::processEvents();
if (gError) {
qWarning() << "Fail to create items:" << gError->message;
g_error_free(gError);
gError = 0;
Q_FOREACH(const QOrganizerItem &i, data->workingItems()) {
data->appendResult(i, QOrganizerManager::UnspecifiedError);
}
} else {
QString currentCollectionId = data->currentCollection();
if (currentCollectionId.isEmpty()) {
currentCollectionId = data->parent()->defaultCollection(0).id().toString();
}
QList items = data->workingItems();
for(uint i=0, iMax=g_slist_length(uids); i < iMax; i++) {
QOrganizerItem &item = items[i];
const gchar *uid = static_cast(g_slist_nth_data(uids, i));
QOrganizerEDSEngineId *eid = new QOrganizerEDSEngineId(currentCollectionId,
QString::fromUtf8(uid));
item.setId(QOrganizerItemId(eid));
item.setGuid(QString::fromUtf8(uid));
QOrganizerEDSCollectionEngineId *edsCollectionId = new QOrganizerEDSCollectionEngineId(currentCollectionId);
item.setCollectionId(QOrganizerCollectionId(edsCollectionId));
}
g_slist_free_full(uids, g_free);
data->appendResults(items);
}
saveItemsAsyncStart(data);
}
bool QOrganizerEDSEngine::saveItems(QList *items,
const QList &detailMask,
QMap *errorMap,
QtOrganizer::QOrganizerManager::Error *error)
{
QOrganizerItemSaveRequest *req = new QOrganizerItemSaveRequest(this);
req->setItems(*items);
req->setDetailMask(detailMask);
startRequest(req);
waitForRequestFinished(req, 0);
*errorMap = req->errorMap();
*error = req->error();
*items = req->items();
return (*error == QOrganizerManager::NoError);
}
void QOrganizerEDSEngine::removeItemsByIdAsync(QOrganizerItemRemoveByIdRequest *req)
{
if (req->itemIds().count() == 0) {
QOrganizerManagerEngine::updateItemRemoveByIdRequest(req,
QOrganizerManager::NoError,
QMap(),
QOrganizerAbstractRequest::FinishedState);
return;
}
RemoveByIdRequestData *data = new RemoveByIdRequestData(this, req);
removeItemsByIdAsyncStart(data);
}
void QOrganizerEDSEngine::removeItemsByIdAsyncStart(RemoveByIdRequestData *data)
{
QString collectionId = data->next();
for(; !collectionId.isNull(); collectionId = data->next()) {
EClient *client = data->parent()->d->m_sourceRegistry->client(collectionId);
data->setClient(client);
g_object_unref(client);
GSList *ids = data->compIds();
GError *gError = 0;
e_cal_client_remove_objects_sync(data->client(), ids, E_CAL_OBJ_MOD_THIS, 0, 0);
QCoreApplication::processEvents();
if (gError) {
qWarning() << "Fail to remove Items" << gError->message;
g_error_free(gError);
gError = 0;
}
data->commit();
}
data->finish();
delete data;
}
void QOrganizerEDSEngine::removeItemsAsync(QOrganizerItemRemoveRequest *req)
{
if (req->items().count() == 0) {
QOrganizerManagerEngine::updateItemRemoveRequest(req,
QOrganizerManager::NoError,
QMap(),
QOrganizerAbstractRequest::FinishedState);
return;
}
RemoveRequestData *data = new RemoveRequestData(this, req);
removeItemsAsyncStart(data);
}
void QOrganizerEDSEngine::removeItemsAsyncStart(RemoveRequestData *data)
{
QOrganizerCollectionId collection = data->next();
for(; !collection.isNull(); collection = data->next()) {
EClient *client = data->parent()->d->m_sourceRegistry->client(collection.toString());
data->setClient(client);
g_object_unref(client);
GSList *ids = data->compIds();
GError *gError = 0;
e_cal_client_remove_objects_sync(data->client(), ids, E_CAL_OBJ_MOD_THIS, 0, 0);
QCoreApplication::processEvents();
if (gError) {
qWarning() << "Fail to remove Items" << gError->message;
g_error_free(gError);
gError = 0;
}
data->commit();
}
data->finish();
delete data;
}
bool QOrganizerEDSEngine::removeItems(const QList &itemIds,
QMap *errorMap,
QOrganizerManager::Error *error)
{
QOrganizerItemRemoveByIdRequest *req = new QOrganizerItemRemoveByIdRequest(this);
req->setItemIds(itemIds);
startRequest(req);
waitForRequestFinished(req, 0);
if (errorMap) {
*errorMap = req->errorMap();
}
if (error) {
*error = req->error();
}
return (*error == QOrganizerManager::NoError);
}
QOrganizerCollection QOrganizerEDSEngine::defaultCollection(QOrganizerManager::Error* error)
{
qWarning() << Q_FUNC_INFO << "Not implemented";
if (error) {
*error = QOrganizerManager::NoError;
}
return d->m_sourceRegistry->defaultCollection();
}
QOrganizerCollection QOrganizerEDSEngine::collection(const QOrganizerCollectionId& collectionId,
QOrganizerManager::Error* error)
{
QOrganizerCollection collection = d->m_sourceRegistry->collection(collectionId.toString());
if (collection.id().isNull() && error) {
*error = QOrganizerManager::DoesNotExistError;
}
return collection;
}
QList QOrganizerEDSEngine::collections(QOrganizerManager::Error* error)
{
QOrganizerCollectionFetchRequest *req = new QOrganizerCollectionFetchRequest(this);
startRequest(req);
waitForRequestFinished(req, 0);
*error = req->error();
if (*error == QOrganizerManager::NoError) {
return req->collections();
} else {
return QList();
}
}
bool QOrganizerEDSEngine::saveCollection(QOrganizerCollection* collection, QOrganizerManager::Error* error)
{
QOrganizerCollectionSaveRequest *req = new QOrganizerCollectionSaveRequest(this);
req->setCollection(*collection);
startRequest(req);
waitForRequestFinished(req, 0);
*error = req->error();
if ((*error == QOrganizerManager::NoError) &&
(req->collections().count())) {
*collection = req->collections()[0];
return true;
} else {
return false;
}
}
void QOrganizerEDSEngine::saveCollectionAsync(QOrganizerCollectionSaveRequest *req)
{
if (req->collections().count() == 0) {
QOrganizerManagerEngine::updateCollectionSaveRequest(req,
QList(),
QOrganizerManager::NoError,
QMap(),
QOrganizerAbstractRequest::FinishedState);
return;
}
ESourceRegistry *registry = d->m_sourceRegistry->object();
SaveCollectionRequestData *requestData = new SaveCollectionRequestData(this, req);
requestData->setRegistry(registry);
if (requestData->prepareToCreate()) {
e_source_registry_create_sources(registry,
requestData->sourcesToCreate(),
requestData->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::saveCollectionAsyncCommited,
requestData);
} else {
requestData->prepareToUpdate();
saveCollectionUpdateAsyncStart(requestData);
}
}
void QOrganizerEDSEngine::saveCollectionAsyncCommited(ESourceRegistry *registry,
GAsyncResult *res,
SaveCollectionRequestData *data)
{
GError *gError = 0;
e_source_registry_create_sources_finish(registry, res, &gError);
QCoreApplication::processEvents();
if (gError) {
qWarning() << "Fail to create sources:" << gError->message;
g_error_free(gError);
data->finish(QOrganizerManager::InvalidCollectionError);
delete data;
} else {
data->commitSourceCreated();
data->prepareToUpdate();
saveCollectionUpdateAsyncStart(data);
}
}
void QOrganizerEDSEngine::saveCollectionUpdateAsyncStart(SaveCollectionRequestData *data)
{
ESource *source = data->nextSourceToUpdate();
if (source) {
e_source_registry_commit_source(data->registry(),
source,
data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::saveCollectionUpdateAsynCommited,
data);
} else {
data->finish();
delete data;
}
}
void QOrganizerEDSEngine::saveCollectionUpdateAsynCommited(ESourceRegistry *registry,
GAsyncResult *res,
SaveCollectionRequestData *data)
{
GError *gError = 0;
ESource *currentSource = data->nextSourceToUpdate();
e_source_registry_commit_source_finish(registry, res, &gError);
QCoreApplication::processEvents();
if (gError) {
qWarning() << "Fail to update collection" << gError->message;
g_error_free(gError);
data->commitSourceUpdated(currentSource, QOrganizerManager::InvalidCollectionError);
} else {
data->commitSourceUpdated(currentSource);
}
saveCollectionUpdateAsyncStart(data);
}
bool QOrganizerEDSEngine::removeCollection(const QOrganizerCollectionId& collectionId, QOrganizerManager::Error* error)
{
QOrganizerCollectionRemoveRequest *req = new QOrganizerCollectionRemoveRequest(this);
req->setCollectionId(collectionId);
startRequest(req);
waitForRequestFinished(req, 0);
*error = req->error();
return(*error == QOrganizerManager::NoError);
}
void QOrganizerEDSEngine::removeCollectionAsync(QtOrganizer::QOrganizerCollectionRemoveRequest *req)
{
if (req->collectionIds().count() == 0) {
QOrganizerManagerEngine::updateCollectionRemoveRequest(req,
QOrganizerManager::NoError,
QMap(),
QOrganizerAbstractRequest::FinishedState);
return;
}
RemoveCollectionRequestData *requestData = new RemoveCollectionRequestData(this, req);
removeCollectionAsyncStart(0, 0, requestData);
}
void QOrganizerEDSEngine::removeCollectionAsyncStart(GObject *sourceObject,
GAsyncResult *res,
RemoveCollectionRequestData *data)
{
if (sourceObject && res) {
GError *gError = 0;
if (data->remoteDeletable()) {
e_source_remote_delete_finish(E_SOURCE(sourceObject), res, &gError);
} else {
e_source_remove_finish(E_SOURCE(sourceObject), res, &gError);
}
QCoreApplication::processEvents();
if (gError) {
qWarning() << "Fail to remove collection" << gError->message;
g_error_free(gError);
data->commit(QOrganizerManager::InvalidCollectionError);
} else {
data->commit();
}
}
ESource *source = data->begin();
if (source) {
if (e_source_get_remote_deletable(source)) {
data->setRemoteDeletable(true);
e_source_remote_delete(source, data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::removeCollectionAsyncStart,
data);
} else if (e_source_get_removable(source)) {
e_source_remove(source, data->cancellable(),
(GAsyncReadyCallback) QOrganizerEDSEngine::removeCollectionAsyncStart,
data);
} else {
qWarning() << "Source not removable";
data->commit(QOrganizerManager::InvalidCollectionError);
}
} else {
data->finish();
delete data;
}
}
void QOrganizerEDSEngine::requestDestroyed(QOrganizerAbstractRequest* req)
{
RequestData *data = m_runningRequests.take(req);
if (data) {
delete data;
}
}
bool QOrganizerEDSEngine::startRequest(QOrganizerAbstractRequest* req)
{
if (!req)
return false;
switch (req->type())
{
case QOrganizerAbstractRequest::ItemFetchRequest:
itemsAsync(qobject_cast(req));
break;
case QOrganizerAbstractRequest::ItemFetchByIdRequest:
itemsByIdAsync(qobject_cast(req));
break;
case QOrganizerAbstractRequest::ItemOccurrenceFetchRequest:
itemOcurrenceAsync(qobject_cast(req));
break;
case QOrganizerAbstractRequest::CollectionFetchRequest:
QOrganizerManagerEngine::updateCollectionFetchRequest(qobject_cast(req),
d->m_sourceRegistry->collections(),
QOrganizerManager::NoError,
QOrganizerAbstractRequest::FinishedState);
break;
case QOrganizerAbstractRequest::ItemSaveRequest:
saveItemsAsync(qobject_cast(req));
break;
case QOrganizerAbstractRequest::ItemRemoveRequest:
removeItemsAsync(qobject_cast(req));
break;
case QOrganizerAbstractRequest::ItemRemoveByIdRequest:
removeItemsByIdAsync(qobject_cast(req));
break;
case QOrganizerAbstractRequest::CollectionSaveRequest:
saveCollectionAsync(qobject_cast(req));
break;
case QOrganizerAbstractRequest::CollectionRemoveRequest:
removeCollectionAsync(qobject_cast(req));
break;
default:
updateRequestState(req, QOrganizerAbstractRequest::FinishedState);
qWarning() << "No implemented request" << req->type();
break;
}
return true;
}
bool QOrganizerEDSEngine::cancelRequest(QOrganizerAbstractRequest* req)
{
RequestData *data = m_runningRequests.take(req);
if (data) {
data->cancel();
delete data;
return true;
}
return false;
}
bool QOrganizerEDSEngine::waitForRequestFinished(QOrganizerAbstractRequest* req, int msecs)
{
Q_ASSERT(req);
Q_UNUSED(msecs);
QPointer r(req);
while(r && (r->state() == QOrganizerAbstractRequest::ActiveState)) {
QCoreApplication::processEvents();
}
return true;
}
QList QOrganizerEDSEngine::supportedItemDetails(QOrganizerItemType::ItemType itemType) const
{
QList supportedDetails;
supportedDetails << QOrganizerItemDetail::TypeItemType
<< QOrganizerItemDetail::TypeGuid
<< QOrganizerItemDetail::TypeTimestamp
<< QOrganizerItemDetail::TypeDisplayLabel
<< QOrganizerItemDetail::TypeDescription
<< QOrganizerItemDetail::TypeComment
<< QOrganizerItemDetail::TypeTag
<< QOrganizerItemDetail::TypeClassification
<< QOrganizerItemDetail::TypeExtendedDetail;
if (itemType == QOrganizerItemType::TypeEvent) {
supportedDetails << QOrganizerItemDetail::TypeRecurrence
<< QOrganizerItemDetail::TypeEventTime
<< QOrganizerItemDetail::TypePriority
<< QOrganizerItemDetail::TypeLocation
<< QOrganizerItemDetail::TypeReminder
<< QOrganizerItemDetail::TypeAudibleReminder
<< QOrganizerItemDetail::TypeEmailReminder
<< QOrganizerItemDetail::TypeVisualReminder;
} else if (itemType == QOrganizerItemType::TypeTodo) {
supportedDetails << QOrganizerItemDetail::TypeRecurrence
<< QOrganizerItemDetail::TypeTodoTime
<< QOrganizerItemDetail::TypePriority
<< QOrganizerItemDetail::TypeTodoProgress
<< QOrganizerItemDetail::TypeReminder
<< QOrganizerItemDetail::TypeAudibleReminder
<< QOrganizerItemDetail::TypeEmailReminder
<< QOrganizerItemDetail::TypeVisualReminder;
} else if (itemType == QOrganizerItemType::TypeEventOccurrence) {
supportedDetails << QOrganizerItemDetail::TypeParent
<< QOrganizerItemDetail::TypeEventTime
<< QOrganizerItemDetail::TypePriority
<< QOrganizerItemDetail::TypeLocation
<< QOrganizerItemDetail::TypeReminder
<< QOrganizerItemDetail::TypeAudibleReminder
<< QOrganizerItemDetail::TypeEmailReminder
<< QOrganizerItemDetail::TypeVisualReminder;
} else if (itemType == QOrganizerItemType::TypeTodoOccurrence) {
supportedDetails << QOrganizerItemDetail::TypeParent
<< QOrganizerItemDetail::TypeTodoTime
<< QOrganizerItemDetail::TypePriority
<< QOrganizerItemDetail::TypeTodoProgress
<< QOrganizerItemDetail::TypeReminder
<< QOrganizerItemDetail::TypeAudibleReminder
<< QOrganizerItemDetail::TypeEmailReminder
<< QOrganizerItemDetail::TypeVisualReminder;
} else if (itemType == QOrganizerItemType::TypeJournal) {
supportedDetails << QOrganizerItemDetail::TypeJournalTime;
} else if (itemType == QOrganizerItemType::TypeNote) {
// nothing ;)
} else {
supportedDetails.clear();
}
return supportedDetails;
}
QList QOrganizerEDSEngine::supportedFilters() const
{
QList supported;
supported << QOrganizerItemFilter::InvalidFilter
<< QOrganizerItemFilter::DetailFilter
<< QOrganizerItemFilter::DetailFieldFilter
<< QOrganizerItemFilter::DetailRangeFilter
<< QOrganizerItemFilter::IntersectionFilter
<< QOrganizerItemFilter::UnionFilter
<< QOrganizerItemFilter::IdFilter
<< QOrganizerItemFilter::CollectionFilter
<< QOrganizerItemFilter::DefaultFilter;
return supported;
}
QList QOrganizerEDSEngine::supportedItemTypes() const
{
return QList() << QOrganizerItemType::TypeEvent
<< QOrganizerItemType::TypeEventOccurrence
<< QOrganizerItemType::TypeJournal
<< QOrganizerItemType::TypeNote
<< QOrganizerItemType::TypeTodo
<< QOrganizerItemType::TypeTodoOccurrence;
}
void QOrganizerEDSEngine::onSourceAdded(const QString &collectionId)
{
d->watch(collectionId);
}
void QOrganizerEDSEngine::onSourceRemoved(const QString &collectionId)
{
d->unWatch(collectionId);
}
void QOrganizerEDSEngine::onViewChanged(QOrganizerItemChangeSet *change)
{
change->emitSignals(this);
}
QDateTime QOrganizerEDSEngine::fromIcalTime(struct icaltimetype value, const char *tzId)
{
uint tmTime;
if (tzId) {
QByteArray tzName(tzId);
// keep only the timezone name.
tzName = tzName.replace("/freeassociation.sourceforge.net/Tzfile/", "");
const icaltimezone *timezone = const_cast(icaltimezone_get_builtin_timezone(tzName.constData()));
tmTime = icaltime_as_timet_with_zone(value, timezone);
return QDateTime::fromTime_t(tmTime, QTimeZone(tzId));
} else {
tmTime = icaltime_as_timet(value);
return QDateTime::fromTime_t(tmTime);
}
}
icaltimetype QOrganizerEDSEngine::fromQDateTime(const QDateTime &dateTime,
bool allDay,
QByteArray *tzId)
{
if (dateTime.timeSpec() == Qt::TimeZone) {
const icaltimezone *timezone = 0;
*tzId = dateTime.timeZone().id();
timezone = const_cast(icaltimezone_get_builtin_timezone(tzId->constData()));
return icaltime_from_timet_with_zone(dateTime.toTime_t(), allDay, timezone);
} else {
return icaltime_from_timet(dateTime.toTime_t(), allDay);
}
}
void QOrganizerEDSEngine::parseStartTime(ECalComponent *comp, QOrganizerItem *item)
{
ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
e_cal_component_get_dtstart(comp, dt);
if (dt->value) {
QOrganizerEventTime etr = item->detail(QOrganizerItemDetail::TypeEventTime);
etr.setStartDateTime(fromIcalTime(*dt->value, dt->tzid));
if (icaltime_is_date(*dt->value) != etr.isAllDay()) {
etr.setAllDay(icaltime_is_date(*dt->value));
}
item->saveDetail(&etr);
}
e_cal_component_free_datetime(dt);
}
void QOrganizerEDSEngine::parseTodoStartTime(ECalComponent *comp, QOrganizerItem *item)
{
ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
e_cal_component_get_dtstart(comp, dt);
if (dt->value) {
QOrganizerTodoTime etr = item->detail(QOrganizerItemDetail::TypeTodoTime);
etr.setStartDateTime(fromIcalTime(*dt->value, dt->tzid));
if (icaltime_is_date(*dt->value) != etr.isAllDay()) {
etr.setAllDay(icaltime_is_date(*dt->value));
}
item->saveDetail(&etr);
}
e_cal_component_free_datetime(dt);
}
void QOrganizerEDSEngine::parseEndTime(ECalComponent *comp, QOrganizerItem *item)
{
ECalComponentDateTime *dt = g_new0(ECalComponentDateTime, 1);
e_cal_component_get_dtend(comp, dt);
if (dt->value) {
QOrganizerEventTime etr = item->detail(QOrganizerItemDetail::TypeEventTime);
etr.setEndDateTime(fromIcalTime(*dt->value, dt->tzid));
if (icaltime_is_date(*dt->value) != etr.isAllDay()) {
etr.setAllDay(icaltime_is_date(*dt->value));
}
item->saveDetail(&etr);
}
e_cal_component_free_datetime(dt);
}
void QOrganizerEDSEngine::parseWeekRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule)
{
static QMap daysOfWeekMap;
if (daysOfWeekMap.isEmpty()) {
daysOfWeekMap.insert(ICAL_MONDAY_WEEKDAY, Qt::Monday);
daysOfWeekMap.insert(ICAL_THURSDAY_WEEKDAY, Qt::Thursday);
daysOfWeekMap.insert(ICAL_WEDNESDAY_WEEKDAY, Qt::Wednesday);
daysOfWeekMap.insert(ICAL_TUESDAY_WEEKDAY, Qt::Tuesday);
daysOfWeekMap.insert(ICAL_FRIDAY_WEEKDAY, Qt::Friday);
daysOfWeekMap.insert(ICAL_SATURDAY_WEEKDAY, Qt::Saturday);
daysOfWeekMap.insert(ICAL_SUNDAY_WEEKDAY, Qt::Sunday);
}
qRule->setFrequency(QOrganizerRecurrenceRule::Weekly);
QSet daysOfWeek;
for (int d=0; d <= Qt::Sunday; d++) {
short day = rule->by_day[d];
if (day != ICAL_RECURRENCE_ARRAY_MAX) {
daysOfWeek.insert(daysOfWeekMap[icalrecurrencetype_day_day_of_week(rule->by_day[d])]);
}
}
qRule->setDaysOfWeek(daysOfWeek);
}
void QOrganizerEDSEngine::parseMonthRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule)
{
qRule->setFrequency(QOrganizerRecurrenceRule::Monthly);
QSet daysOfMonth;
for (int d=0; d < ICAL_BY_MONTHDAY_SIZE; d++) {
short day = rule->by_month_day[d];
if (day != ICAL_RECURRENCE_ARRAY_MAX) {
daysOfMonth.insert(day);
}
}
qRule->setDaysOfMonth(daysOfMonth);
}
void QOrganizerEDSEngine::parseYearRecurrence(struct icalrecurrencetype *rule, QtOrganizer::QOrganizerRecurrenceRule *qRule)
{
qRule->setFrequency(QOrganizerRecurrenceRule::Yearly);
QSet daysOfYear;
for (int d=0; d < ICAL_BY_YEARDAY_SIZE; d++) {
short day = rule->by_year_day[d];
if (day != ICAL_RECURRENCE_ARRAY_MAX) {
daysOfYear.insert(day);
}
}
qRule->setDaysOfYear(daysOfYear);
QSet monthOfYear;
for (int d=0; d < ICAL_BY_MONTH_SIZE; d++) {
short month = rule->by_month[d];
if (month != ICAL_RECURRENCE_ARRAY_MAX) {
monthOfYear.insert(static_cast(month));
}
}
qRule->setMonthsOfYear(monthOfYear);
}
void QOrganizerEDSEngine::parseRecurrence(ECalComponent *comp, QOrganizerItem *item)
{
// recurence
if (e_cal_component_has_rdates(comp)) {
QSet dates;
GSList *periodList = 0;
e_cal_component_get_rdate_list(comp, &periodList);
for(GSList *i = periodList; i != 0; i = i->next) {
ECalComponentPeriod *period = (ECalComponentPeriod*) i->data;
//TODO: get timezone info
QDateTime dt = fromIcalTime(period->start, 0);
dates.insert(dt.date());
//TODO: period.end, period.duration
}
e_cal_component_free_period_list(periodList);
QOrganizerItemRecurrence rec = item->detail(QOrganizerItemDetail::TypeRecurrence);
rec.setRecurrenceDates(dates);
item->saveDetail(&rec);
}
if (e_cal_component_has_exdates(comp)) {
QSet dates;
GSList *exdateList = 0;
e_cal_component_get_exdate_list(comp, &exdateList);
for(GSList *i = exdateList; i != 0; i = i->next) {
ECalComponentDateTime* dateTime = (ECalComponentDateTime*) i->data;
QDateTime dt = fromIcalTime(*dateTime->value, dateTime->tzid);
dates.insert(dt.date());
}
e_cal_component_free_exdate_list(exdateList);
QOrganizerItemRecurrence irec = item->detail(QOrganizerItemDetail::TypeRecurrence);
irec.setExceptionDates(dates);
item->saveDetail(&irec);
}
// rules
GSList *ruleList = 0;
e_cal_component_get_rrule_list(comp, &ruleList);
if (ruleList) {
QSet qRules;
for(GSList *i = ruleList; i != 0; i = i->next) {
struct icalrecurrencetype *rule = (struct icalrecurrencetype*) i->data;
QOrganizerRecurrenceRule qRule;
switch (rule->freq) {
case ICAL_SECONDLY_RECURRENCE:
case ICAL_MINUTELY_RECURRENCE:
case ICAL_HOURLY_RECURRENCE:
qWarning() << "Recurrence frequency not supported";
break;
case ICAL_DAILY_RECURRENCE:
qRule.setFrequency(QOrganizerRecurrenceRule::Daily);
break;
case ICAL_WEEKLY_RECURRENCE:
parseWeekRecurrence(rule, &qRule);
break;
case ICAL_MONTHLY_RECURRENCE:
parseMonthRecurrence(rule, &qRule);
break;
case ICAL_YEARLY_RECURRENCE:
parseYearRecurrence(rule, &qRule);
break;
case ICAL_NO_RECURRENCE:
break;
}
if (icaltime_is_date(rule->until)) {
QDate dt = QDate::fromString(icaltime_as_ical_string(rule->until), "yyyyMMdd");
if (dt.isValid()) {
qRule.setLimit(dt);
}
} else {
qRule.setLimit(rule->count);
}
qRule.setInterval(rule->interval);
QSet positions;
for (int d=0; d < ICAL_BY_SETPOS_SIZE; d++) {
short day = rule->by_set_pos[d];
if (day != ICAL_RECURRENCE_ARRAY_MAX) {
positions.insert(day);
}
}
qRule.setPositions(positions);
qRules << qRule;
}
if (!qRules.isEmpty()) {
QOrganizerItemRecurrence irec = item->detail(QOrganizerItemDetail::TypeRecurrence);
irec.setRecurrenceRules(qRules);
item->saveDetail(&irec);
}
e_cal_component_free_recur_list(ruleList);
}
// TODO: exeptions rules
}
void QOrganizerEDSEngine::parsePriority(ECalComponent *comp, QOrganizerItem *item)
{
gint *priority = 0;
e_cal_component_get_priority(comp, &priority);
if (priority) {
QOrganizerItemPriority iPriority = item->detail(QOrganizerItemDetail::TypePriority);
if ((*priority >= QOrganizerItemPriority::UnknownPriority) &&
(*priority <= QOrganizerItemPriority::LowPriority)) {
iPriority.setPriority((QOrganizerItemPriority::Priority) *priority);
} else {
iPriority.setPriority(QOrganizerItemPriority::UnknownPriority);
}
e_cal_component_free_priority(priority);
item->saveDetail(&iPriority);
}
}
void QOrganizerEDSEngine::parseLocation(ECalComponent *comp, QOrganizerItem *item)
{
const gchar *location;
e_cal_component_get_location(comp, &location);
if (location) {
QOrganizerItemLocation ld = item->detail(QOrganizerItemDetail::TypeLocation);
ld.setLabel(QString::fromUtf8(location));
item->saveDetail(&ld);
}
}
void QOrganizerEDSEngine::parseDueDate(ECalComponent *comp, QOrganizerItem *item)
{
ECalComponentDateTime due;
e_cal_component_get_due(comp, &due);
if (due.value) {
QOrganizerTodoTime ttr = item->detail(QOrganizerItemDetail::TypeTodoTime);
ttr.setDueDateTime(fromIcalTime(*due.value, due.tzid));
if (icaltime_is_date(*due.value) != ttr.isAllDay()) {
ttr.setAllDay(icaltime_is_date(*due.value));
}
item->saveDetail(&ttr);
}
e_cal_component_free_datetime(&due);
}
void QOrganizerEDSEngine::parseProgress(ECalComponent *comp, QOrganizerItem *item)
{
gint percentage = e_cal_component_get_percent_as_int(comp);
if (percentage >= 0 && percentage <= 100) {
QOrganizerTodoProgress tp = item->detail(QOrganizerItemDetail::TypeTodoProgress);
tp.setPercentageComplete(percentage);
item->saveDetail(&tp);
}
}
void QOrganizerEDSEngine::parseStatus(ECalComponent *comp, QOrganizerItem *item)
{
icalproperty_status status;
e_cal_component_get_status(comp, &status);
QOrganizerTodoProgress tp;
switch(status) {
case ICAL_STATUS_NONE:
tp.setStatus(QOrganizerTodoProgress::StatusNotStarted);
break;
case ICAL_STATUS_INPROCESS:
tp.setStatus(QOrganizerTodoProgress::StatusInProgress);
break;
case ICAL_STATUS_COMPLETED:
tp.setStatus(QOrganizerTodoProgress::StatusComplete);
break;
case ICAL_STATUS_CANCELLED:
default:
//TODO: not supported
break;
}
item->saveDetail(&tp);
}
void QOrganizerEDSEngine::parseAttendeeList(ECalComponent *comp, QOrganizerItem *item)
{
GSList *attendeeList = 0;
e_cal_component_get_attendee_list(comp, &attendeeList);
for (GSList *attendeeIter=attendeeList; attendeeIter != 0; attendeeIter = attendeeIter->next) {
ECalComponentAttendee *attendee = static_cast(attendeeIter->data);
QOrganizerEventAttendee qAttendee;
qAttendee.setName(QString::fromUtf8(attendee->cn));
qAttendee.setEmailAddress(QString::fromUtf8(attendee->member));
switch(attendee->role) {
case ICAL_ROLE_REQPARTICIPANT:
qAttendee.setParticipationRole(QOrganizerEventAttendee::RoleRequiredParticipant);
break;
case ICAL_ROLE_OPTPARTICIPANT:
qAttendee.setParticipationRole(QOrganizerEventAttendee::RoleOptionalParticipant);
break;
case ICAL_ROLE_CHAIR:
qAttendee.setParticipationRole(QOrganizerEventAttendee::RoleChairperson);
break;
case ICAL_ROLE_NONE:
default:
qAttendee.setParticipationRole(QOrganizerEventAttendee::RoleNonParticipant);
break;
}
switch(attendee->status) {
case ICAL_PARTSTAT_ACCEPTED:
qAttendee.setParticipationStatus(QOrganizerEventAttendee::StatusAccepted);
break;
case ICAL_PARTSTAT_DECLINED:
qAttendee.setParticipationStatus(QOrganizerEventAttendee::StatusDeclined);
break;
case ICAL_PARTSTAT_TENTATIVE:
qAttendee.setParticipationStatus(QOrganizerEventAttendee::StatusTentative);
break;
case ICAL_PARTSTAT_DELEGATED:
qAttendee.setParticipationStatus(QOrganizerEventAttendee::StatusDelegated);
break;
case ICAL_PARTSTAT_COMPLETED:
qAttendee.setParticipationStatus(QOrganizerEventAttendee::StatusCompleted);
break;
case ICAL_PARTSTAT_INPROCESS:
qAttendee.setParticipationStatus(QOrganizerEventAttendee::StatusInProcess);
break;
case ICAL_PARTSTAT_NEEDSACTION:
case ICAL_PARTSTAT_NONE:
default:
qAttendee.setParticipationStatus(QOrganizerEventAttendee::StatusUnknown);
break;
}
item->saveDetail(&qAttendee);
}
e_cal_component_free_attendee_list(attendeeList);
}
QOrganizerItem *QOrganizerEDSEngine::parseEvent(ECalComponent *comp)
{
QOrganizerItem *event;
if (hasRecurrence(comp)) {
event = new QOrganizerEventOccurrence();
} else {
event = new QOrganizerEvent();
}
parseStartTime(comp, event);
parseEndTime(comp, event);
parseRecurrence(comp, event);
parsePriority(comp, event);
parseLocation(comp, event);
return event;
}
QOrganizerItem *QOrganizerEDSEngine::parseToDo(ECalComponent *comp)
{
QOrganizerItem *todo;
if (hasRecurrence(comp)) {
todo = new QOrganizerTodoOccurrence();
} else {
todo = new QOrganizerTodo();
}
parseTodoStartTime(comp, todo);
parseDueDate(comp, todo);
parseRecurrence(comp, todo);
parsePriority(comp, todo);
parseProgress(comp, todo);
parseStatus(comp, todo);
return todo;
}
QOrganizerItem *QOrganizerEDSEngine::parseJournal(ECalComponent *comp)
{
QOrganizerJournal *journal = new QOrganizerJournal();
ECalComponentDateTime dt;
e_cal_component_get_dtstart(comp, &dt);
if (dt.value) {
QOrganizerJournalTime jtime;
jtime.setEntryDateTime(fromIcalTime(*dt.value, dt.tzid));
journal->saveDetail(&jtime);
}
e_cal_component_free_datetime(&dt);
return journal;
}
void QOrganizerEDSEngine::parseSummary(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
{
ECalComponentText summary;
e_cal_component_get_summary(comp, &summary);
if (summary.value) {
item->setDisplayLabel(QString::fromUtf8(summary.value));
}
}
void QOrganizerEDSEngine::parseDescription(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
{
GSList *descriptions = 0;
e_cal_component_get_description_list(comp, &descriptions);
QStringList itemDescription;
for(GSList *descList = descriptions; descList != 0; descList = descList->next) {
ECalComponentText *description = static_cast(descList->data);
if (description && description->value) {
itemDescription.append(QString::fromUtf8(description->value));
}
}
item->setDescription(itemDescription.join("\n"));
e_cal_component_free_text_list(descriptions);
}
void QOrganizerEDSEngine::parseComments(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
{
GSList *comments = 0;
e_cal_component_get_comment_list(comp, &comments);
for(int ci=0, ciMax=g_slist_length(comments); ci < ciMax; ci++) {
ECalComponentText *txt = static_cast(g_slist_nth_data(comments, ci));
item->addComment(QString::fromUtf8(txt->value));
}
e_cal_component_free_text_list(comments);
}
void QOrganizerEDSEngine::parseTags(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
{
GSList *categories = 0;
e_cal_component_get_categories_list(comp, &categories);
for(GSList *tag=categories; tag != 0; tag = tag->next) {
item->addTag(QString::fromUtf8(static_cast(tag->data)));
}
e_cal_component_free_categories_list(categories);
}
QUrl QOrganizerEDSEngine::dencodeAttachment(ECalComponentAlarm *alarm)
{
QUrl attachment;
icalattach *attach = 0;
e_cal_component_alarm_get_attach(alarm, &attach);
if (attach) {
if (icalattach_get_is_url(attach)) {
const gchar *url = icalattach_get_url(attach);
attachment = QUrl(QString::fromUtf8(url));
}
icalattach_unref(attach);
}
return attachment;
}
void QOrganizerEDSEngine::parseVisualReminderAttachment(ECalComponentAlarm *alarm, QOrganizerItemReminder *aDetail)
{
QUrl attach = dencodeAttachment(alarm);
if (attach.isValid()) {
aDetail->setValue(QOrganizerItemVisualReminder::FieldDataUrl, attach);
}
ECalComponentText txt;
e_cal_component_alarm_get_description(alarm, &txt);
aDetail->setValue(QOrganizerItemVisualReminder::FieldMessage, QString::fromUtf8(txt.value));
}
void QOrganizerEDSEngine::parseAudibleReminderAttachment(ECalComponentAlarm *alarm, QOrganizerItemReminder *aDetail)
{
QUrl attach = dencodeAttachment(alarm);
if (attach.isValid()) {
aDetail->setValue(QOrganizerItemAudibleReminder::FieldDataUrl, attach);
}
}
void QOrganizerEDSEngine::parseReminders(ECalComponent *comp, QtOrganizer::QOrganizerItem *item)
{
GList *alarms = e_cal_component_get_alarm_uids(comp);
for(GList *a = alarms; a != 0; a = a->next) {
QOrganizerItemReminder *aDetail = 0;
ECalComponentAlarm *alarm = e_cal_component_get_alarm(comp, static_cast(a->data));
if (!alarm) {
continue;
}
ECalComponentAlarmAction aAction;
e_cal_component_alarm_get_action(alarm, &aAction);
switch(aAction)
{
case E_CAL_COMPONENT_ALARM_DISPLAY:
aDetail = new QOrganizerItemVisualReminder();
parseVisualReminderAttachment(alarm, aDetail);
break;
case E_CAL_COMPONENT_ALARM_AUDIO:
// use audio as fallback
default:
aDetail = new QOrganizerItemAudibleReminder();
parseAudibleReminderAttachment(alarm, aDetail);
break;
}
ECalComponentAlarmTrigger trigger;
e_cal_component_alarm_get_trigger(alarm, &trigger);
if (trigger.type == E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START) {
aDetail->setSecondsBeforeStart(icaldurationtype_as_int(trigger.u.rel_duration) * -1);
}
ECalComponentAlarmRepeat aRepeat;
e_cal_component_alarm_get_repeat(alarm, &aRepeat);
aDetail->setRepetition(aRepeat.repetitions, icaldurationtype_as_int(aRepeat.duration));
item->saveDetail(aDetail);
delete aDetail;
}
}
QList QOrganizerEDSEngine::parseEvents(const QString &collectionId,
GSList *events,
bool isIcalEvents)
{
QOrganizerEDSCollectionEngineId *collection = d->m_sourceRegistry->collectionEngineId(collectionId);
QList items;
for (GSList *l = events; l; l = l->next) {
QOrganizerItem *item;
ECalComponent *comp;
if (isIcalEvents) {
icalcomponent *clone = icalcomponent_new_clone(static_cast(l->data));
comp = e_cal_component_new_from_icalcomponent(clone);
} else {
comp = E_CAL_COMPONENT(l->data);
}
//type
ECalComponentVType vType = e_cal_component_get_vtype(comp);
switch(vType) {
case E_CAL_COMPONENT_EVENT:
item = parseEvent(comp);
break;
case E_CAL_COMPONENT_TODO:
item = parseToDo(comp);
break;
case E_CAL_COMPONENT_JOURNAL:
item = parseJournal(comp);
break;
case E_CAL_COMPONENT_FREEBUSY:
qWarning() << "Component FREEBUSY not supported;";
continue;
case E_CAL_COMPONENT_TIMEZONE:
qWarning() << "Component TIMEZONE not supported;";
case E_CAL_COMPONENT_NO_TYPE:
continue;
}
parseId(comp, item, collection);
parseDescription(comp, item);
parseSummary(comp, item);
parseComments(comp, item);
parseTags(comp, item);
parseReminders(comp, item);
parseAttendeeList(comp, item);
items << *item;
delete item;
if (isIcalEvents) {
g_object_unref(comp);
}
}
return items;
}
void QOrganizerEDSEngine::parseStartTime(const QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerEventTime etr = item.detail(QOrganizerItemDetail::TypeEventTime);
if (!etr.isEmpty()) {
QByteArray tzId;
struct icaltimetype ict = fromQDateTime(etr.startDateTime(), etr.isAllDay(), &tzId);
ECalComponentDateTime dt;
dt.tzid = tzId.isEmpty() ? NULL : tzId.constData();
dt.value = &ict;
e_cal_component_set_dtstart(comp, &dt);
}
}
void QOrganizerEDSEngine::parseEndTime(const QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerEventTime etr = item.detail(QOrganizerItemDetail::TypeEventTime);
if (!etr.isEmpty()) {
QByteArray tzId;
struct icaltimetype ict = fromQDateTime(etr.endDateTime(), etr.isAllDay(), &tzId);
ECalComponentDateTime dt;
dt.tzid = tzId.isEmpty() ? NULL : tzId.constData();
dt.value = &ict;
e_cal_component_set_dtend(comp, &dt);
}
}
void QOrganizerEDSEngine::parseTodoStartTime(const QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerTodoTime etr = item.detail(QOrganizerItemDetail::TypeTodoTime);
if (!etr.isEmpty()) {
QByteArray tzId;
struct icaltimetype ict = fromQDateTime(etr.startDateTime(), etr.isAllDay(), &tzId);
ECalComponentDateTime dt;
dt.tzid = tzId.isEmpty() ? NULL : tzId.constData();
dt.value = &ict;
e_cal_component_set_dtstart(comp, &dt);;
}
}
void QOrganizerEDSEngine::parseWeekRecurrence(const QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule)
{
static QMap daysOfWeekMap;
if (daysOfWeekMap.isEmpty()) {
daysOfWeekMap.insert(Qt::Monday, ICAL_MONDAY_WEEKDAY);
daysOfWeekMap.insert(Qt::Thursday, ICAL_THURSDAY_WEEKDAY);
daysOfWeekMap.insert(Qt::Wednesday, ICAL_WEDNESDAY_WEEKDAY);
daysOfWeekMap.insert(Qt::Tuesday, ICAL_TUESDAY_WEEKDAY);
daysOfWeekMap.insert(Qt::Friday, ICAL_FRIDAY_WEEKDAY);
daysOfWeekMap.insert(Qt::Saturday, ICAL_SATURDAY_WEEKDAY);
daysOfWeekMap.insert(Qt::Sunday, ICAL_SUNDAY_WEEKDAY);
}
QList daysOfWeek = qRule.daysOfWeek().toList();
int c = 0;
rule->freq = ICAL_WEEKLY_RECURRENCE;
for(int d=Qt::Monday; d <= Qt::Sunday; d++) {
if (daysOfWeek.contains(static_cast(d))) {
rule->by_day[c++] = daysOfWeekMap[static_cast(d)];
}
}
for (int d = c; d < ICAL_BY_DAY_SIZE; d++) {
rule->by_day[d] = ICAL_RECURRENCE_ARRAY_MAX;
}
}
void QOrganizerEDSEngine::parseMonthRecurrence(const QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule)
{
rule->freq = ICAL_MONTHLY_RECURRENCE;
QList daysOfMonth = qRule.daysOfMonth().toList();
int c = 0;
for (int d=1; d < ICAL_BY_MONTHDAY_SIZE; d++) {
if (daysOfMonth.contains(d)) {
rule->by_month_day[c++] = d;
}
}
for (int d = c; d < ICAL_BY_MONTHDAY_SIZE; d++) {
rule->by_month_day[d] = ICAL_RECURRENCE_ARRAY_MAX;
}
}
void QOrganizerEDSEngine::parseYearRecurrence(const QOrganizerRecurrenceRule &qRule, struct icalrecurrencetype *rule)
{
rule->freq = ICAL_YEARLY_RECURRENCE;
QList daysOfYear = qRule.daysOfYear().toList();
int c = 0;
for (int d=1; d < ICAL_BY_YEARDAY_SIZE; d++) {
if (daysOfYear.contains(d)) {
rule->by_year_day[c++] = d;
}
}
for (int d = c; d < ICAL_BY_YEARDAY_SIZE; d++) {
rule->by_year_day[d] = ICAL_RECURRENCE_ARRAY_MAX;
}
c = 0;
QList monthOfYear = qRule.monthsOfYear().toList();
for (int d=1; d < ICAL_BY_MONTH_SIZE; d++) {
if (monthOfYear.contains(static_cast(d))) {
rule->by_month[c++] = d;
}
}
for (int d = c; d < ICAL_BY_YEARDAY_SIZE; d++) {
rule->by_month[d] = ICAL_RECURRENCE_ARRAY_MAX;
}
}
void QOrganizerEDSEngine::parseRecurrence(const QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerItemRecurrence rec = item.detail(QOrganizerItemDetail::TypeRecurrence);
if (!rec.isEmpty()) {
GSList *periodList = 0;
Q_FOREACH(const QDate &dt, rec.recurrenceDates()) {
ECalComponentPeriod *period = g_new0(ECalComponentPeriod, 1);
period->start = icaltime_from_timet(QDateTime(dt).toTime_t(), FALSE);
periodList = g_slist_append(periodList, period);
//TODO: period.end, period.duration
}
e_cal_component_set_rdate_list(comp, periodList);
e_cal_component_free_period_list(periodList);
GSList *exdateList = 0;
Q_FOREACH(const QDate &dt, rec.exceptionDates()) {
ECalComponentDateTime *dateTime = g_new0(ECalComponentDateTime, 1);
struct icaltimetype *itt = g_new0(struct icaltimetype, 1);
*itt = icaltime_from_timet(QDateTime(dt).toTime_t(), FALSE);
dateTime->value = itt;
exdateList = g_slist_append(exdateList, dateTime);
}
e_cal_component_set_exdate_list(comp, exdateList);
e_cal_component_free_exdate_list(exdateList);
GSList *ruleList = 0;
Q_FOREACH(const QOrganizerRecurrenceRule &qRule, rec.recurrenceRules()) {
struct icalrecurrencetype *rule = g_new0(struct icalrecurrencetype, 1);
icalrecurrencetype_clear(rule);
switch(qRule.frequency()) {
case QOrganizerRecurrenceRule::Daily:
rule->freq = ICAL_DAILY_RECURRENCE;
break;
case QOrganizerRecurrenceRule::Weekly:
parseWeekRecurrence(qRule, rule);
break;
case QOrganizerRecurrenceRule::Monthly:
parseMonthRecurrence(qRule, rule);
break;
case QOrganizerRecurrenceRule::Yearly:
parseYearRecurrence(qRule, rule);
break;
case QOrganizerRecurrenceRule::Invalid:
rule->freq = ICAL_NO_RECURRENCE;
break;
}
if (qRule.limitDate().isValid()) {
rule->until = icaltime_from_timet(QDateTime(qRule.limitDate()).toTime_t(), TRUE);
rule->count = ICAL_RECURRENCE_ARRAY_MAX;
} else {
rule->count = qRule.limitCount();
}
QSet positions = qRule.positions();
for (int d=1; d < ICAL_BY_SETPOS_SIZE; d++) {
if (positions.contains(d)) {
rule->by_set_pos[d] = d;
} else {
rule->by_set_pos[d] = ICAL_RECURRENCE_ARRAY_MAX;
}
}
rule->interval = qRule.interval();
ruleList = g_slist_append(ruleList, rule);
}
e_cal_component_set_rrule_list(comp, ruleList);
g_slist_free_full(ruleList, g_free);
}
}
void QOrganizerEDSEngine::parsePriority(const QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerItemPriority priority = item.detail(QOrganizerItemDetail::TypePriority);
if (!priority.isEmpty()) {
gint iPriority = (gint) priority.priority();
e_cal_component_set_priority(comp, &iPriority);
}
}
void QOrganizerEDSEngine::parseLocation(const QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerItemLocation ld = item.detail(QOrganizerItemDetail::TypeLocation);
if (!ld.isEmpty()) {
e_cal_component_set_location(comp, ld.label().toUtf8().data());
}
}
void QOrganizerEDSEngine::parseDueDate(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerTodoTime ttr = item.detail(QOrganizerItemDetail::TypeTodoTime);
if (!ttr.isEmpty()) {
QByteArray tzId;
struct icaltimetype ict = fromQDateTime(ttr.dueDateTime(), ttr.isAllDay(), &tzId);
ECalComponentDateTime dt;
dt.tzid = tzId.isEmpty() ? NULL : tzId.constData();
dt.value = &ict;
e_cal_component_set_due(comp, &dt);;
}
}
void QOrganizerEDSEngine::parseProgress(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerTodoProgress tp = item.detail(QOrganizerItemDetail::TypeTodoProgress);
if (!tp.isEmpty()) {
e_cal_component_set_percent_as_int(comp, tp.percentageComplete());
}
}
void QOrganizerEDSEngine::parseStatus(const QtOrganizer::QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerTodoProgress tp = item.detail(QOrganizerItemDetail::TypeTodoProgress);
if (!tp.isEmpty()) {
switch(tp.status()) {
case QOrganizerTodoProgress::StatusNotStarted:
e_cal_component_set_status(comp, ICAL_STATUS_NONE);
break;
case QOrganizerTodoProgress::StatusInProgress:
e_cal_component_set_status(comp, ICAL_STATUS_INPROCESS);
break;
case QOrganizerTodoProgress::StatusComplete:
e_cal_component_set_status(comp, ICAL_STATUS_COMPLETED);
break;
default:
e_cal_component_set_status(comp, ICAL_STATUS_CANCELLED);
break;
}
}
}
void QOrganizerEDSEngine::parseAttendeeList(const QOrganizerItem &item, ECalComponent *comp)
{
GSList *attendeeList = 0;
Q_FOREACH(const QOrganizerEventAttendee &attendee, item.details(QOrganizerItemDetail::TypeEventAttendee)) {
ECalComponentAttendee *calAttendee = g_new0(ECalComponentAttendee, 1);
calAttendee->cn = g_strdup(attendee.name().toUtf8().constData());
calAttendee->value = g_strconcat("MAILTO:", attendee.emailAddress().toUtf8().constData(), NULL);
switch(attendee.participationRole()) {
case QOrganizerEventAttendee::RoleRequiredParticipant:
calAttendee->role = ICAL_ROLE_REQPARTICIPANT;
break;
case QOrganizerEventAttendee::RoleOptionalParticipant:
calAttendee->role = ICAL_ROLE_OPTPARTICIPANT;
break;
case QOrganizerEventAttendee::RoleChairperson:
calAttendee->role = ICAL_ROLE_CHAIR;
break;
default:
calAttendee->role = ICAL_ROLE_NONE;
}
switch(attendee.participationStatus()) {
case QOrganizerEventAttendee::StatusAccepted:
calAttendee->status = ICAL_PARTSTAT_ACCEPTED;
break;
case QOrganizerEventAttendee::StatusDeclined:
calAttendee->status = ICAL_PARTSTAT_DECLINED;
break;
case QOrganizerEventAttendee::StatusTentative:
calAttendee->status = ICAL_PARTSTAT_TENTATIVE;
break;
case QOrganizerEventAttendee::StatusDelegated:
calAttendee->status = ICAL_PARTSTAT_DELEGATED;
break;
case QOrganizerEventAttendee::StatusInProcess:
calAttendee->status = ICAL_PARTSTAT_INPROCESS;
break;
case QOrganizerEventAttendee::StatusCompleted:
calAttendee->status = ICAL_PARTSTAT_COMPLETED;
break;
case QOrganizerEventAttendee::StatusUnknown:
default:
calAttendee->status = ICAL_PARTSTAT_NONE;
break;
}
attendeeList = g_slist_append(attendeeList, calAttendee);
}
e_cal_component_set_attendee_list(comp, attendeeList);
}
bool QOrganizerEDSEngine::hasRecurrence(ECalComponent *comp)
{
char *rid = e_cal_component_get_recurid_as_string(comp);
bool result = (rid && strcmp(rid, "0"));
if (rid) {
free(rid);
}
return result;
}
void QOrganizerEDSEngine::parseId(ECalComponent *comp,
QOrganizerItem *item,
QOrganizerEDSCollectionEngineId *edsCollectionId)
{
ECalComponentId *id = e_cal_component_get_id(comp);
QOrganizerEDSEngineId *edsParentId = 0;
QOrganizerEDSEngineId *edsId = QOrganizerEDSEngineId::fromComponentId(edsCollectionId->m_collectionId, id, &edsParentId);
item->setId(QOrganizerItemId(edsId));
item->setGuid(QString::fromUtf8(id->uid));
if (edsParentId) {
QOrganizerItemParent itemParent = item->detail(QOrganizerItemDetail::TypeParent);
itemParent.setParentId(QOrganizerItemId(edsParentId));
item->saveDetail(&itemParent);
}
QOrganizerCollectionId cId = QOrganizerCollectionId(edsCollectionId);
item->setCollectionId(cId);
e_cal_component_free_id(id);
}
ECalComponent *QOrganizerEDSEngine::createDefaultComponent(ECalClient *client,
icalcomponent_kind iKind,
ECalComponentVType eType)
{
ECalComponent *comp;
icalcomponent *icalcomp = 0;
if (client && !e_cal_client_get_default_object_sync(client, &icalcomp, NULL, NULL)) {
icalcomp = icalcomponent_new(iKind);
}
comp = e_cal_component_new();
if (icalcomp && !e_cal_component_set_icalcomponent(comp, icalcomp)) {
icalcomponent_free(icalcomp);
}
e_cal_component_set_new_vtype(comp, eType);
return comp;
}
ECalComponent *QOrganizerEDSEngine::parseEventItem(ECalClient *client, const QOrganizerItem &item)
{
ECalComponent *comp = createDefaultComponent(client, ICAL_VEVENT_COMPONENT, E_CAL_COMPONENT_EVENT);
parseStartTime(item, comp);
parseEndTime(item, comp);
parseRecurrence(item, comp);
parsePriority(item, comp);
parseLocation(item, comp);
return comp;
}
ECalComponent *QOrganizerEDSEngine::parseTodoItem(ECalClient *client, const QOrganizerItem &item)
{
ECalComponent *comp = createDefaultComponent(client, ICAL_VTODO_COMPONENT, E_CAL_COMPONENT_TODO);
parseTodoStartTime(item, comp);
parseDueDate(item, comp);
parseRecurrence(item, comp);
parsePriority(item, comp);
parseProgress(item, comp);
parseStatus(item, comp);
return comp;
}
ECalComponent *QOrganizerEDSEngine::parseJournalItem(ECalClient *client, const QOrganizerItem &item)
{
ECalComponent *comp = createDefaultComponent(client, ICAL_VJOURNAL_COMPONENT, E_CAL_COMPONENT_JOURNAL);
QOrganizerJournalTime jtime = item.detail(QOrganizerItemDetail::TypeJournalTime);
if (!jtime.isEmpty()) {
QByteArray tzId;
struct icaltimetype ict = fromQDateTime(jtime.entryDateTime(), false, &tzId);
ECalComponentDateTime dt;
dt.tzid = tzId.isEmpty() ? NULL : tzId.constData();
dt.value = &ict;
e_cal_component_set_dtstart(comp, &dt);
}
return comp;
}
void QOrganizerEDSEngine::parseSummary(const QOrganizerItem &item, ECalComponent *comp)
{
//summary
if (!item.displayLabel().isEmpty()) {
ECalComponentText txt;
QByteArray str = item.displayLabel().toUtf8();
txt.altrep = 0;
txt.value = str.constData();
e_cal_component_set_summary(comp, &txt);
}
}
void QOrganizerEDSEngine::parseDescription(const QOrganizerItem &item, ECalComponent *comp)
{
//description
if (!item.description().isEmpty()) {
GSList *descriptions = 0;
QList descList;
Q_FOREACH(const QString &desc, item.description().split("\n")) {
QByteArray str = desc.toUtf8();
ECalComponentText *txt = g_new0(ECalComponentText, 1);
txt->value = str.constData();
descriptions = g_slist_append(descriptions, txt);
// keep str alive until the property gets updated
descList << str;
}
e_cal_component_set_description_list(comp, descriptions);
e_cal_component_free_text_list(descriptions);
}
}
void QOrganizerEDSEngine::parseComments(const QOrganizerItem &item, ECalComponent *comp)
{
//comments
GSList *comments = 0;
QList commentList;
Q_FOREACH(const QString &comment, item.comments()) {
QByteArray str = comment.toUtf8();
ECalComponentText *txt = g_new0(ECalComponentText, 1);
txt->value = str.constData();
comments = g_slist_append(comments, txt);
// keep str alive until the property gets updated
commentList << str;
}
if (comments) {
e_cal_component_set_comment_list(comp, comments);
e_cal_component_free_text_list(comments);
}
}
void QOrganizerEDSEngine::parseTags(const QOrganizerItem &item, ECalComponent *comp)
{
//tags
GSList *categories = 0;
QList tagList;
Q_FOREACH(const QString &tag, item.tags()) {
QByteArray str = tag.toUtf8();
ECalComponentText *txt = g_new0(ECalComponentText, 1);
txt->value = str.constData();
categories = g_slist_append(categories, txt);
// keep str alive until the property gets updated
tagList << str;
}
if (categories) {
e_cal_component_set_categories_list(comp, categories);
e_cal_component_free_text_list(categories);
}
}
void QOrganizerEDSEngine::encodeAttachment(const QUrl &url, ECalComponentAlarm *alarm)
{
icalattach *attach = icalattach_new_from_url(url.toString().toUtf8());
e_cal_component_alarm_set_attach(alarm, attach);
icalattach_unref(attach);
}
void QOrganizerEDSEngine::parseVisualReminderAttachment(const QOrganizerItemDetail &detail, ECalComponentAlarm *alarm)
{
ECalComponentText txt;
QByteArray str = detail.value(QOrganizerItemVisualReminder::FieldMessage).toString().toUtf8();
txt.altrep = 0;
txt.value = str.constData();
e_cal_component_alarm_set_description(alarm, &txt);
encodeAttachment(detail.value(QOrganizerItemVisualReminder::FieldDataUrl).toUrl(), alarm);
}
void QOrganizerEDSEngine::parseAudibleReminderAttachment(const QOrganizerItemDetail &detail, ECalComponentAlarm *alarm)
{
encodeAttachment(detail.value(QOrganizerItemAudibleReminder::FieldDataUrl).toUrl(), alarm);
}
void QOrganizerEDSEngine::parseReminders(const QOrganizerItem &item, ECalComponent *comp)
{
//reminders
QList reminders = item.details(QOrganizerItemDetail::TypeAudibleReminder);
reminders += item.details(QOrganizerItemDetail::TypeVisualReminder);
Q_FOREACH(const QOrganizerItemDetail &detail, reminders) {
const QOrganizerItemReminder *reminder = static_cast(&detail);
ECalComponentAlarm *alarm = e_cal_component_alarm_new();
switch(reminder->type())
{
case QOrganizerItemReminder::TypeVisualReminder:
e_cal_component_alarm_set_action(alarm, E_CAL_COMPONENT_ALARM_DISPLAY);
parseVisualReminderAttachment(detail, alarm);
break;
case QOrganizerItemReminder::TypeAudibleReminder:
default:
// use audio as fallback
e_cal_component_alarm_set_action(alarm, E_CAL_COMPONENT_ALARM_AUDIO);
parseAudibleReminderAttachment(detail, alarm);
break;
}
if (reminder->secondsBeforeStart() > 0) {
ECalComponentAlarmTrigger trigger;
trigger.type = E_CAL_COMPONENT_ALARM_TRIGGER_RELATIVE_START;
trigger.u.rel_duration = icaldurationtype_from_int(- reminder->secondsBeforeStart());
e_cal_component_alarm_set_trigger(alarm, trigger);
}
ECalComponentAlarmRepeat aRepeat;
// TODO: check if this is really necessary
aRepeat.repetitions = reminder->repetitionCount(); //qMax(reminder->repetitionCount(), 1);
aRepeat.duration = icaldurationtype_from_int(reminder->repetitionDelay());
e_cal_component_alarm_set_repeat(alarm, aRepeat);
e_cal_component_add_alarm(comp, alarm);
e_cal_component_alarm_free(alarm);
}
}
GSList *QOrganizerEDSEngine::parseItems(ECalClient *client,
QList items,
bool *hasRecurrence)
{
GSList *comps = 0;
Q_FOREACH(const QOrganizerItem &item, items) {
ECalComponent *comp = 0;
*hasRecurrence = ((item.type() == QOrganizerItemType::TypeTodoOccurrence) ||
(item.type() == QOrganizerItemType::TypeEventOccurrence));
switch(item.type()) {
case QOrganizerItemType::TypeEvent:
case QOrganizerItemType::TypeEventOccurrence:
comp = parseEventItem(client, item);
break;
case QOrganizerItemType::TypeTodo:
case QOrganizerItemType::TypeTodoOccurrence:
comp = parseTodoItem(client, item);
break;
case QOrganizerItemType::TypeJournal:
comp = parseJournalItem(client, item);
break;
case QOrganizerItemType::TypeNote:
qWarning() << "Component TypeNote not supported;";
case QOrganizerItemType::TypeUndefined:
continue;
}
parseId(item, comp);
parseSummary(item, comp);
parseDescription(item, comp);
parseComments(item, comp);
parseTags(item, comp);
parseReminders(item, comp);
parseAttendeeList(item, comp);
if (!item.id().isNull()) {
e_cal_component_commit_sequence(comp);
} else {
e_cal_component_abort_sequence(comp);
}
comps = g_slist_append(comps,
icalcomponent_new_clone(e_cal_component_get_icalcomponent(comp)));
g_object_unref(comp);
}
return comps;
}
void QOrganizerEDSEngine::parseId(const QOrganizerItem &item, ECalComponent *comp)
{
QOrganizerItemId itemId = item.id();
if (!itemId.isNull()) {
QString rId;
QString cId = QOrganizerEDSEngineId::toComponentId(itemId, &rId);
e_cal_component_set_uid(comp, cId.toUtf8().data());
if (!rId.isEmpty()) {
ECalComponentRange *recur_id;
struct icaltimetype tt = icaltime_from_string(rId.toUtf8().data());
recur_id = g_new0 (ECalComponentRange, 1);
recur_id->type = E_CAL_COMPONENT_RANGE_SINGLE;
recur_id->datetime.value = &tt;
e_cal_component_set_recurid(comp, recur_id);
g_free (recur_id);
}
}
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-saverequestdata.cpp 0000644 0000153 0177776 00000010344 12323305673 030475 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-saverequestdata.h"
#include "qorganizer-eds-enginedata.h"
#include
#include
#define UPDATE_MODE_PROPRETY "update-mode"
using namespace QtOrganizer;
SaveRequestData::SaveRequestData(QOrganizerEDSEngine *engine,
QtOrganizer::QOrganizerAbstractRequest *req)
: RequestData(engine, req)
{
// map items by collection
Q_FOREACH(const QOrganizerItem &i, request()->items()) {
QString collectionId = i.collectionId().toString();
if (collectionId == QStringLiteral("qtorganizer:::")) {
collectionId = QStringLiteral("");
}
QList li = m_items[collectionId];
li << i;
m_items.insert(collectionId, li);
}
}
SaveRequestData::~SaveRequestData()
{
}
void SaveRequestData::finish(QtOrganizer::QOrganizerManager::Error error)
{
QOrganizerManagerEngine::updateItemSaveRequest(request(),
m_result,
error,
m_erros,
QOrganizerAbstractRequest::FinishedState);
Q_FOREACH(const QOrganizerItem &item, m_result) {
m_changeSet.insertAddedItem(item.id());
}
emitChangeset(&m_changeSet);
}
void SaveRequestData::appendResults(QList result)
{
m_result += result;
}
QString SaveRequestData::nextCollection()
{
if (m_items.isEmpty()) {
m_currentCollection = QString(QString::null);
m_currentItems.clear();
} else {
m_currentCollection = m_items.keys().first();
m_currentItems = m_items.take(m_currentCollection);
}
m_workingItems.clear();
return m_currentCollection;
}
QString SaveRequestData::currentCollection() const
{
return m_currentCollection;
}
QList SaveRequestData::takeItemsToCreate()
{
QList result;
Q_FOREACH(const QOrganizerItem &i, m_currentItems) {
if (i.id().isNull()) {
result << i;
m_currentItems.removeAll(i);
}
}
return result;
}
QList SaveRequestData::takeItemsToUpdate()
{
QList result;
Q_FOREACH(const QOrganizerItem &i, m_currentItems) {
if (!i.id().isNull()) {
result << i;
m_currentItems.removeAll(i);
}
}
return result;
}
bool SaveRequestData::end() const
{
return m_items.isEmpty();
}
void SaveRequestData::appendResult(const QOrganizerItem &item, QOrganizerManager::Error error)
{
if (error != QOrganizerManager::NoError) {
int index = request()->items().indexOf(item);
if (index != -1) {
m_erros.insert(index, error);
}
} else {
m_result << item;
}
}
void SaveRequestData::setWorkingItems(QList items)
{
m_workingItems = items;
}
QList SaveRequestData::workingItems() const
{
return m_workingItems;
}
int SaveRequestData::updateMode() const
{
// due the lack of API we will use the QObject proprety "update-mode" to allow specify wich kind of
// update the developer want
QOrganizerItemSaveRequest *req = request();
QVariant updateMode = req->property(UPDATE_MODE_PROPRETY);
if (updateMode.isValid()) {
return updateMode.toInt();
} else {
return -1;
}
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-engineid.cpp 0000644 0000153 0177776 00000011673 12323305647 027065 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of canonical-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-engineid.h"
#include
#include
using namespace QtOrganizer;
QOrganizerEDSEngineId::QOrganizerEDSEngineId()
: QOrganizerItemEngineId()
{
}
QOrganizerEDSEngineId::QOrganizerEDSEngineId(const QString &collectionId,
const QString &id)
: QOrganizerItemEngineId()
{
if (!collectionId.isNull() && !collectionId.isEmpty()) {
m_collectionId = collectionId.contains(":") ? collectionId.mid(collectionId.lastIndexOf(":")+1) : collectionId;
}
if (!id.isNull() && !id.isEmpty()) {
m_itemId = id.contains(":") ? id.mid(id.lastIndexOf(":")+1) : id;
}
}
QOrganizerEDSEngineId::~QOrganizerEDSEngineId()
{
}
QOrganizerEDSEngineId::QOrganizerEDSEngineId(const QOrganizerEDSEngineId& other)
: QOrganizerItemEngineId(),
m_collectionId(other.m_collectionId),
m_itemId(other.m_itemId)
{
}
QOrganizerEDSEngineId::QOrganizerEDSEngineId(const QString& idString)
: QOrganizerItemEngineId()
{
QString edsIdPart = idString.contains(":") ? idString.mid(idString.lastIndexOf(":")+1) : idString;
QStringList idParts = edsIdPart.split("/");
Q_ASSERT(idParts.count() == 2);
m_collectionId = idParts.first();
m_itemId = idParts.last();
}
bool QOrganizerEDSEngineId::isEqualTo(const QOrganizerItemEngineId* other) const
{
// note: we don't need to check the collectionId because itemIds in the memory
// engine are unique regardless of which collection the item is in; also, we
// don't need to check the managerUri, because this function is not called if
// the managerUris don't match.
if (m_itemId != static_cast(other)->m_itemId)
return false;
return true;
}
bool QOrganizerEDSEngineId::isLessThan(const QOrganizerItemEngineId* other) const
{
// order by collection, then by item in collection.
const QOrganizerEDSEngineId* otherPtr = static_cast(other);
if (m_collectionId < otherPtr->m_collectionId)
return true;
if (m_collectionId == otherPtr->m_collectionId)
return (m_itemId < otherPtr->m_itemId);
return false;
}
QString QOrganizerEDSEngineId::managerUri() const
{
return managerUriStatic();
}
QString QOrganizerEDSEngineId::toString() const
{
return QString("%1/%2").arg(m_collectionId).arg(m_itemId);
}
QOrganizerItemEngineId* QOrganizerEDSEngineId::clone() const
{
return new QOrganizerEDSEngineId(m_collectionId, m_itemId);
}
uint QOrganizerEDSEngineId::hash() const
{
return qHash(m_itemId);
}
#ifndef QT_NO_DEBUG_STREAM
QDebug& QOrganizerEDSEngineId::debugStreamOut(QDebug& dbg) const
{
dbg.nospace() << "QOrganizerEDSEngineId(" << managerNameStatic() << ", " << m_collectionId << ", " << m_itemId << ")";
return dbg.maybeSpace();
}
#endif
QString QOrganizerEDSEngineId::managerNameStatic()
{
return QStringLiteral("eds");
}
QString QOrganizerEDSEngineId::managerUriStatic()
{
return QStringLiteral("qtorganizer:eds:");
}
QString QOrganizerEDSEngineId::toComponentId(const QtOrganizer::QOrganizerItemId &itemId, QString *rid)
{
return toComponentId(itemId.toString(), rid);
}
QString QOrganizerEDSEngineId::toComponentId(const QString &itemId, QString *rid)
{
QStringList ids = itemId.split("/").last().split("#");
if (ids.size() == 2) {
*rid = ids[1];
}
return ids[0];
}
ECalComponentId *QOrganizerEDSEngineId::toComponentIdObject(const QOrganizerItemId &itemId)
{
QString rId;
QString cId = toComponentId(itemId, &rId);
ECalComponentId *id = g_new0(ECalComponentId, 1);
id->uid = g_strdup(cId.toUtf8().data());
if (rId.isEmpty()) {
id->rid = NULL;
} else {
id->rid = g_strdup(rId.toUtf8().data());
}
return id;
}
QOrganizerEDSEngineId *QOrganizerEDSEngineId::fromComponentId(const QString &cId,
ECalComponentId *id,
QOrganizerEDSEngineId **parentId)
{
QString iId = QString::fromUtf8(id->uid);
QString rId = QString::fromUtf8(id->rid);
if(!rId.isEmpty()) {
*parentId = new QOrganizerEDSEngineId(cId, iId);
iId += "#" + rId;
}
return new QOrganizerEDSEngineId(cId, iId);
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-removecollectionrequestdata.cpp 0000644 0000153 0177776 00000005762 12323305647 033121 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-removecollectionrequestdata.h"
#include "qorganizer-eds-engineid.h"
#include "qorganizer-eds-enginedata.h"
#include "qorganizer-eds-source-registry.h"
#include
#include
#include
using namespace QtOrganizer;
RemoveCollectionRequestData::RemoveCollectionRequestData(QOrganizerEDSEngine *engine, QtOrganizer::QOrganizerAbstractRequest *req)
: RequestData(engine, req),
m_currentCollection(0),
m_remoteDeletable(false)
{
m_pendingCollections = request()->collectionIds();
}
RemoveCollectionRequestData::~RemoveCollectionRequestData()
{
}
void RemoveCollectionRequestData::finish(QtOrganizer::QOrganizerManager::Error error)
{
QOrganizerManagerEngine::updateCollectionRemoveRequest(request(),
error,
m_errorMap,
QOrganizerAbstractRequest::FinishedState);
QList removedIds = m_pendingCollections;
Q_FOREACH(int index, m_errorMap.keys()) {
removedIds.removeAt(index);
}
QOrganizerCollectionChangeSet cs;
cs.insertRemovedCollections(removedIds);
emitChangeset(&cs);
}
void RemoveCollectionRequestData::commit(QtOrganizer::QOrganizerManager::Error error)
{
if (error != QOrganizerManager::NoError) {
m_errorMap.insert(m_currentCollection, error);
} else {
QOrganizerCollectionId cId = m_pendingCollections.at(m_currentCollection);
parent()->d->m_sourceRegistry->remove(cId.toString());
}
m_currentCollection++;
m_remoteDeletable = false;
}
bool RemoveCollectionRequestData::remoteDeletable() const
{
return m_remoteDeletable;
}
void RemoveCollectionRequestData::setRemoteDeletable(bool deletable)
{
m_remoteDeletable = deletable;
}
ESource *RemoveCollectionRequestData::begin()
{
if (m_pendingCollections.count() > m_currentCollection) {
QOrganizerCollectionId cId = m_pendingCollections.at(m_currentCollection);
return parent()->d->m_sourceRegistry->source(cId.toString());
} else {
return 0;
}
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-fetchocurrencedata.h 0000644 0000153 0177776 00000002426 12323305647 030575 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_FETCHOCURRENCEDATA_H__
#define __QORGANIZER_EDS_FETCHOCURRENCEDATA_H__
#include "qorganizer-eds-requestdata.h"
#include
class FetchOcurrenceData : public RequestData
{
public:
FetchOcurrenceData(QOrganizerEDSEngine *engine,
QtOrganizer::QOrganizerAbstractRequest *req);
~FetchOcurrenceData();
time_t startDate() const;
time_t endDate() const;
void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
void appendResult(icalcomponent *comp);
private:
GSList *m_components;
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-fetchrequestdata.cpp 0000644 0000153 0177776 00000010717 12323305673 030634 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-fetchrequestdata.h"
#include
#include
#include
using namespace QtOrganizer;
FetchRequestData::FetchRequestData(QOrganizerEDSEngine *engine,
QStringList collections,
QOrganizerAbstractRequest *req)
: RequestData(engine, req),
m_components(0),
m_collections(collections)
{
}
FetchRequestData::~FetchRequestData()
{
if (m_components) {
g_slist_free_full(m_components, (GDestroyNotify)icalcomponent_free);
m_components = 0;
}
}
QString FetchRequestData::nextCollection()
{
if (m_components) {
appendResults(parent()->parseEvents(m_current, m_components, true));
g_slist_free_full(m_components, (GDestroyNotify)icalcomponent_free);
m_components = 0;
}
m_current = "";
setClient(0);
if (m_collections.size()) {
m_current = m_collections.takeFirst();
return m_current;
} else {
return QString();
}
}
QString FetchRequestData::collection() const
{
return m_current;
}
time_t FetchRequestData::startDate() const
{
QDateTime startDate = request()->startDate();
if (!startDate.isValid()) {
QDate currentDate = QDate::currentDate();
startDate.setTime(QTime(0, 0, 0));
startDate.setDate(QDate(currentDate.year(), 1, 1));
qWarning() << "Start date is invalid using " << startDate;
}
return startDate.toTime_t();
}
time_t FetchRequestData::endDate() const
{
QDateTime endDate = request()->endDate();
if (!endDate.isValid()) {
QDate currentDate = QDate::currentDate();
endDate.setTime(QTime(0, 0, 0));
endDate.setDate(QDate(currentDate.year()+1, 1, 1));
qWarning() << "End date is invalid using " << endDate;
}
return endDate.toTime_t();
}
bool FetchRequestData::hasDateInterval() const
{
QDateTime endDate = request()->endDate();
QDateTime startDate = request()->startDate();
return (endDate.isValid() && startDate.isValid());
}
void FetchRequestData::finish(QOrganizerManager::Error error)
{
QOrganizerManagerEngine::updateItemFetchRequest(request(),
m_results,
error,
QOrganizerAbstractRequest::FinishedState);
// TODO: emit changeset???
}
void FetchRequestData::appendResult(icalcomponent *comp)
{
m_components = g_slist_append(m_components, comp);
}
int FetchRequestData::appendResults(QList results)
{
int count = 0;
QOrganizerItemFetchRequest *req = request();
Q_FOREACH(const QOrganizerItem &item, results) {
if (QOrganizerManagerEngine::testFilter(req->filter(), item)) {
m_results << item;
count++;
}
}
return count;
}
QString FetchRequestData::dateFilter()
{
QDateTime startDate = request()->startDate();
QDateTime endDate = request()->endDate();
if (!startDate.isValid() ||
!endDate.isValid()) {
return QStringLiteral("#t"); // match all
}
gchar *startDateStr = isodate_from_time_t(startDate.toTime_t());
gchar *endDateStr = isodate_from_time_t(endDate.toTime_t());
QString query = QString("(occur-in-time-range? "
"(make-time \"%1\") (make-time \"%2\"))")
.arg(startDateStr)
.arg(endDateStr);
g_free(startDateStr);
g_free(endDateStr);
return query;
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-factory.h 0000644 0000153 0177776 00000003062 12323305647 026410 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of contact-service-app.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_FACTORY_H__
#define __QORGANIZER_EDS_FACTORY_H__
#include
#include
#include
#include
class QOrganizerEDSFactory : public QtOrganizer::QOrganizerManagerEngineFactory
{
Q_OBJECT
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QOrganizerManagerEngineFactoryInterface" FILE "eds.json")
public:
QtOrganizer::QOrganizerManagerEngine* engine(const QMap& parameters, QtOrganizer::QOrganizerManager::Error*);
QtOrganizer::QOrganizerItemEngineId* createItemEngineId(const QMap& parameters, const QString& idString) const;
QtOrganizer::QOrganizerCollectionEngineId* createCollectionEngineId(const QMap& parameters, const QString& idString) const;
QString managerName() const;
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-requestdata.cpp 0000644 0000153 0177776 00000004600 12323305647 027615 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-requestdata.h"
#include
#include
using namespace QtOrganizer;
RequestData::RequestData(QOrganizerEDSEngine *engine, QtOrganizer::QOrganizerAbstractRequest *req)
: m_parent(engine),
m_req(req),
m_client(0)
{
QOrganizerManagerEngine::updateRequestState(req, QOrganizerAbstractRequest::ActiveState);
m_cancellable = g_cancellable_new();
m_parent->m_runningRequests.insert(req, this);
}
RequestData::~RequestData()
{
Q_ASSERT(m_req->state() != QOrganizerAbstractRequest::ActiveState);
if (m_cancellable) {
g_clear_object(&m_cancellable);
}
if (m_client) {
g_clear_object(&m_client);
}
m_parent->m_runningRequests.remove(m_req);
}
GCancellable* RequestData::cancellable() const
{
g_cancellable_reset(m_cancellable);
g_object_ref(m_cancellable);
return m_cancellable;
}
bool RequestData::isLive() const
{
return !m_req.isNull();
}
ECalClient *RequestData::client() const
{
return E_CAL_CLIENT(m_client);
}
QOrganizerEDSEngine *RequestData::parent() const
{
return m_parent;
}
void RequestData::cancel()
{
if (m_cancellable) {
g_cancellable_cancel(m_cancellable);
m_parent->waitForRequestFinished(m_req, 0);
g_object_unref(m_cancellable);
m_cancellable = 0;
}
QOrganizerManagerEngine::updateRequestState(m_req, QOrganizerAbstractRequest::CanceledState);
}
void RequestData::setClient(EClient *client)
{
if (m_client == client) {
return;
}
if (m_client) {
g_clear_object(&m_client);
}
if (client) {
m_client = client;
g_object_ref(m_client);
}
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-fetchrequestdata.h 0000644 0000153 0177776 00000003136 12323305647 030277 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_FETCHREQUESTDATA_H__
#define __QORGANIZER_EDS_FETCHREQUESTDATA_H__
#include "qorganizer-eds-requestdata.h"
#include
class FetchRequestData : public RequestData
{
public:
FetchRequestData(QOrganizerEDSEngine *engine,
QStringList collections,
QtOrganizer::QOrganizerAbstractRequest *req);
~FetchRequestData();
QString nextCollection();
QString collection() const;
time_t startDate() const;
time_t endDate() const;
bool hasDateInterval() const;
void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
void appendResult(icalcomponent *comp);
int appendResults(QList results);
QString dateFilter();
private:
GSList *m_components;
QStringList m_collections;
QString m_current;
QList m_results;
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-savecollectionrequestdata.h 0000644 0000153 0177776 00000003740 12323305647 032221 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_SAVECOLLECTIONREQUESTDATA_H__
#define __QORGANIZER_EDS_SAVECOLLECTIONREQUESTDATA_H__
#include "qorganizer-eds-requestdata.h"
class SaveCollectionRequestData : public RequestData
{
public:
SaveCollectionRequestData(QOrganizerEDSEngine *engine,
QtOrganizer::QOrganizerAbstractRequest *req);
~SaveCollectionRequestData();
void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
bool isNew(int index) const;
bool prepareToCreate();
bool prepareToUpdate();
void setRegistry(ESourceRegistry *registry);
ESourceRegistry *registry() const;
GList *sourcesToCreate() const;
void commitSourceCreated();
void commitSourceUpdated(ESource *source, QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
ESource *nextSourceToUpdate();
private:
GList *m_currentSources;
ESourceRegistry *m_registry;
QMap m_errorMap;
QMap m_results;
QMap m_sources;
QMap m_sourcesToCreate;
QMap m_sourcesToUpdate;
QtOrganizer::QOrganizerCollectionChangeSet m_changeSet;
void parseCollections();
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-source-registry.h 0000644 0000153 0177776 00000007020 12323305647 030105 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_SOURCEREGISTRY_H__
#define __QORGANIZER_EDS_SOURCEREGISTRY_H__
#include
#include
#include
#include
#include "qorganizer-eds-collection-engineid.h"
#define COLLECTION_CALLENDAR_TYPE_METADATA "collection-type"
#define COLLECTION_SELECTED_METADATA "collection-selected"
class SourceRegistry : public QObject
{
Q_OBJECT
public:
SourceRegistry(QObject *parent=0);
~SourceRegistry();
ESourceRegistry *object() const;
void load();
QtOrganizer::QOrganizerCollection defaultCollection() const;
QtOrganizer::QOrganizerCollection collection(const QString &collectionId) const;
QList collections() const;
QStringList collectionsIds() const;
QList collectionsEngineIds() const;
ESource *source(const QString &collectionId) const;
QOrganizerEDSCollectionEngineId* collectionEngineId(const QString &collectionId) const;
QtOrganizer::QOrganizerCollection collection(ESource *source) const;
QtOrganizer::QOrganizerCollection insert(ESource *source);
void remove(ESource *source);
void remove(const QString &collectionId);
EClient *client(const QString &collectionId);
void clear();
static QtOrganizer::QOrganizerCollection parseSource(ESource *source,
QOrganizerEDSCollectionEngineId **edsId);
Q_SIGNALS:
void sourceAdded(const QString &collectionId);
void sourceRemoved(const QString &collectionId);
void sourceUpdated(const QString &collectionId);
private:
ESourceRegistry *m_sourceRegistry;
QtOrganizer::QOrganizerCollection m_defaultCollection;
QMap m_clients;
QMap m_sources;
QMap m_collections;
QMap m_collectionsMap;
// handler id
int m_sourceAddedId;
int m_sourceRemovedId;
int m_sourceChangedId;
int m_sourceEnabledId;
int m_sourceDisabledId;
QString findCollection(ESource *source) const;
QtOrganizer::QOrganizerCollection registerSource(ESource *source);
static void updateCollection(QtOrganizer::QOrganizerCollection *collection, ESource *source);
// glib callback
static void onSourceAdded(ESourceRegistry *registry,
ESource *source,
SourceRegistry *self);
static void onSourceChanged(ESourceRegistry *registry,
ESource *source,
SourceRegistry *self);
static void onSourceRemoved(ESourceRegistry *registry,
ESource *source,
SourceRegistry *self);
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-viewwatcher.cpp 0000644 0000153 0177776 00000013470 12323305711 027620 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-enginedata.h"
#include "qorganizer-eds-viewwatcher.h"
#include "qorganizer-eds-fetchrequestdata.h"
#include "qorganizer-eds-engineid.h"
#include
#include
#include
#include
#include
using namespace QtOrganizer;
ViewWatcher::ViewWatcher(const QString &collectionId,
QOrganizerEDSEngineData *data,
EClient *client)
: m_collectionId(collectionId),
m_engineData(data),
m_eClient(E_CAL_CLIENT(client)),
m_eView(0),
m_eventLoop(0)
{
g_object_ref(m_eClient);
m_cancellable = g_cancellable_new();
e_cal_client_get_view(m_eClient,
QStringLiteral("#t").toUtf8().constData(), // match all,
m_cancellable,
(GAsyncReadyCallback) ViewWatcher::viewReady,
this);
wait();
}
ViewWatcher::~ViewWatcher()
{
clear();
}
void ViewWatcher::viewReady(GObject *sourceObject, GAsyncResult *res, ViewWatcher *self)
{
Q_UNUSED(sourceObject);
GError *gError = 0;
ECalClientView *view = 0;
e_cal_client_get_view_finish(self->m_eClient, res, &view, &gError);
if (gError) {
qWarning() << "Fail to open view ("
<< self->m_collectionId << "):"
<< gError->message;
g_error_free(gError);
gError = 0;
} else {
self->m_eView = view;
g_signal_connect(view,
"objects-added",
(GCallback) ViewWatcher::onObjectsAdded,
self);
g_signal_connect(view,
"objects-removed",
(GCallback) ViewWatcher::onObjectsRemoved,
self);
g_signal_connect(view,
"objects-modified",
(GCallback) ViewWatcher::onObjectsModified,
self);
e_cal_client_view_set_flags(view, E_CAL_CLIENT_VIEW_FLAGS_NONE, NULL);
e_cal_client_view_start(view, &gError);
if (gError) {
qWarning() << "Fail to start view ("
<< self->m_collectionId << "):"
<< gError->message;
g_error_free(gError);
gError = 0;
}
}
g_clear_object(&self->m_cancellable);
if (self->m_eventLoop) {
self->m_eventLoop->quit();
}
}
void ViewWatcher::clear()
{
if (m_cancellable) {
g_cancellable_cancel(m_cancellable);
wait();
Q_ASSERT(m_cancellable == 0);
}
if (m_eView) {
e_cal_client_view_stop(m_eView, 0);
QCoreApplication::processEvents();
g_clear_object(&m_eView);
}
if (m_eClient) {
g_clear_object(&m_eClient);
QCoreApplication::processEvents();
}
}
void ViewWatcher::wait()
{
if (m_cancellable) {
QEventLoop eventLoop;
m_eventLoop = &eventLoop;
eventLoop.exec();
m_eventLoop = 0;
}
}
QList ViewWatcher::parseItemIds(GSList *objects)
{
QList result;
for (GSList *l = objects; l; l = l->next) {
const gchar *uid = 0;
icalcomponent *icalcomp = static_cast(l->data);
icalproperty *prop = icalcomponent_get_first_property(icalcomp, ICAL_UID_PROPERTY);
if (prop) {
uid = icalproperty_get_uid(prop);
} else {
qWarning() << "Fail to parse component ID";
}
QOrganizerEDSEngineId *itemId = new QOrganizerEDSEngineId(m_collectionId,
QString::fromUtf8(uid));
result << QOrganizerItemId(itemId);
}
return result;
}
void ViewWatcher::onObjectsAdded(ECalClientView *view,
GSList *objects,
ViewWatcher *self)
{
Q_UNUSED(view);
QOrganizerItemChangeSet changeSet;
changeSet.insertAddedItems(self->parseItemIds(objects));
self->m_engineData->emitSharedSignals(&changeSet);
}
void ViewWatcher::onObjectsRemoved(ECalClientView *view,
GSList *objects,
ViewWatcher *self)
{
Q_UNUSED(view);
QOrganizerItemChangeSet changeSet;
for (GSList *l = objects; l; l = l->next) {
ECalComponentId *id = static_cast(l->data);
QOrganizerEDSEngineId *itemId = new QOrganizerEDSEngineId(self->m_collectionId,
QString::fromUtf8(id->uid));
changeSet.insertRemovedItem(QOrganizerItemId(itemId));
}
self->m_engineData->emitSharedSignals(&changeSet);
}
void ViewWatcher::onObjectsModified(ECalClientView *view,
GSList *objects,
ViewWatcher *self)
{
Q_UNUSED(view);
QOrganizerItemChangeSet changeSet;
changeSet.insertChangedItems(self->parseItemIds(objects));
self->m_engineData->emitSharedSignals(&changeSet);
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-removerequestdata.h 0000644 0000153 0177776 00000003431 12323305647 030501 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_REMOVEQUESTDATA_H__
#define __QORGANIZER_EDS_REMOVEQUESTDATA_H__
#include "qorganizer-eds-requestdata.h"
#include
class RemoveRequestData : public RequestData
{
public:
RemoveRequestData(QOrganizerEDSEngine *engine, QtOrganizer::QOrganizerAbstractRequest *req);
~RemoveRequestData();
QList pendingCollections() const;
QtOrganizer::QOrganizerCollectionId collectionId() const;
void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
GSList *compIds() const;
QtOrganizer::QOrganizerCollectionId next();
void commit();
virtual void cancel();
private:
QSet m_pendingCollections;
QList m_pendingItems;
bool m_sessionStaterd;
GSList *m_currentCompIds;
QList m_currentIds;
QtOrganizer::QOrganizerCollectionId m_currentCollectionId;
void clear();
void reset();
GSList* takeItemsIds(QtOrganizer::QOrganizerCollectionId collectionId);
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-enginedata.cpp 0000644 0000153 0177776 00000003403 12323305647 027372 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of canonical-pim-service
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-enginedata.h"
#include "qorganizer-eds-viewwatcher.h"
#include "qorganizer-eds-source-registry.h"
QOrganizerEDSEngineData::QOrganizerEDSEngineData()
: QSharedData(),
m_sourceRegistry(0)
{
}
QOrganizerEDSEngineData::QOrganizerEDSEngineData(const QOrganizerEDSEngineData& other)
: QSharedData(other)
{
}
QOrganizerEDSEngineData::~QOrganizerEDSEngineData()
{
qDeleteAll(m_viewWatchers);
m_viewWatchers.clear();
if (m_sourceRegistry) {
delete m_sourceRegistry;
m_sourceRegistry = 0;
}
}
ViewWatcher* QOrganizerEDSEngineData::watch(const QString &collectionId)
{
ViewWatcher *vw = m_viewWatchers[collectionId];
if (!vw) {
EClient *client = m_sourceRegistry->client(collectionId);
vw = new ViewWatcher(collectionId, this, client);
m_viewWatchers.insert(collectionId, vw);
g_object_unref(client);
}
return vw;
}
void QOrganizerEDSEngineData::unWatch(const QString &collectionId)
{
ViewWatcher *viewW = m_viewWatchers.take(collectionId);
if (viewW) {
delete viewW;
}
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-collection-engineid.cpp 0000644 0000153 0177776 00000007376 12323305647 031223 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of canonical-pim-service
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-collection-engineid.h"
#include "qorganizer-eds-engineid.h"
#include
QOrganizerEDSCollectionEngineId::QOrganizerEDSCollectionEngineId(ESource *source)
: m_esource(source)
{
g_object_ref(m_esource);
m_collectionId = QString::fromUtf8(e_source_get_uid(m_esource));
if (e_source_has_extension(m_esource, E_SOURCE_EXTENSION_CALENDAR)) {
m_sourceType = E_CAL_CLIENT_SOURCE_TYPE_EVENTS;
} else if (e_source_has_extension(m_esource, E_SOURCE_EXTENSION_TASK_LIST)) {
m_sourceType = E_CAL_CLIENT_SOURCE_TYPE_TASKS;
} else if (e_source_has_extension(m_esource, E_SOURCE_EXTENSION_MEMO_LIST)) {
m_sourceType = E_CAL_CLIENT_SOURCE_TYPE_MEMOS;
} else {
qWarning() << "Source extension not supported";
Q_ASSERT(false);
}
}
QOrganizerEDSCollectionEngineId::QOrganizerEDSCollectionEngineId()
: QOrganizerCollectionEngineId(),
m_esource(0)
{
}
QOrganizerEDSCollectionEngineId::QOrganizerEDSCollectionEngineId(const QOrganizerEDSCollectionEngineId& other)
: QOrganizerCollectionEngineId(),
m_collectionId(other.m_collectionId),
m_esource(other.m_esource),
m_sourceType(other.m_sourceType)
{
if (m_esource) {
g_object_ref(m_esource);
}
}
QOrganizerEDSCollectionEngineId::QOrganizerEDSCollectionEngineId(const QString& idString)
: QOrganizerCollectionEngineId(),
m_esource(0)
{
// separate engine id part, if full id given
m_collectionId = idString.contains(":") ? idString.mid(idString.lastIndexOf(":")+1) : idString;
}
QOrganizerEDSCollectionEngineId::~QOrganizerEDSCollectionEngineId()
{
if (m_esource) {
g_clear_object(&m_esource);
}
}
bool QOrganizerEDSCollectionEngineId::isEqualTo(const QOrganizerCollectionEngineId* other) const
{
// note: we don't need to check the managerUri because this function is not called
// if the managerUris are different.
if (m_collectionId != static_cast(other)->m_collectionId)
return false;
return true;
}
bool QOrganizerEDSCollectionEngineId::isLessThan(const QOrganizerCollectionEngineId* other) const
{
// order by collection, then by item in collection.
const QOrganizerEDSCollectionEngineId* otherPtr = static_cast(other);
if (m_collectionId < otherPtr->m_collectionId)
return true;
return false;
}
QString QOrganizerEDSCollectionEngineId::managerUri() const
{
return QOrganizerEDSEngineId::managerUriStatic();
}
QString QOrganizerEDSCollectionEngineId::toString() const
{
return m_collectionId;
}
QOrganizerEDSCollectionEngineId* QOrganizerEDSCollectionEngineId::clone() const
{
return new QOrganizerEDSCollectionEngineId(m_esource);
}
uint QOrganizerEDSCollectionEngineId::hash() const
{
return qHash(m_collectionId);
}
#ifndef QT_NO_DEBUG_STREAM
QDebug& QOrganizerEDSCollectionEngineId::debugStreamOut(QDebug& dbg) const
{
dbg.nospace() << "QOrganizerEDSCollectionEngineId(" << managerUri() << "," << m_collectionId << ")";
return dbg.maybeSpace();
}
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-collection-engineid.h 0000644 0000153 0177776 00000003551 12323305647 030657 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of canonical-pim-service
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_COLLECTION_ENGINEID_H__
#define __QORGANIZER_EDS_COLLECTION_ENGINEID_H__
#include
#include
#include
class QOrganizerEDSCollectionEngineId : public QtOrganizer::QOrganizerCollectionEngineId
{
public:
QOrganizerEDSCollectionEngineId();
QOrganizerEDSCollectionEngineId(const QOrganizerEDSCollectionEngineId& other);
QOrganizerEDSCollectionEngineId(const QString& idString);
QOrganizerEDSCollectionEngineId(ESource *source);
~QOrganizerEDSCollectionEngineId();
bool isEqualTo(const QtOrganizer::QOrganizerCollectionEngineId* other) const;
bool isLessThan(const QtOrganizer::QOrganizerCollectionEngineId* other) const;
QString managerUri() const;
QOrganizerEDSCollectionEngineId *clone() const;
QString toString() const;
uint hash() const;
#ifndef QT_NO_DEBUG_STREAM
QDebug& debugStreamOut(QDebug& dbg) const;
#endif
private:
QString m_collectionId;
ESource *m_esource;
ECalClientSourceType m_sourceType;
friend class SourceRegistry;
//friend class ViewWatcher;
friend class QOrganizerEDSEngine;
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-removebyidrequestdata.cpp 0000644 0000153 0177776 00000010016 12323305647 031701 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-removebyidrequestdata.h"
#include "qorganizer-eds-engineid.h"
#include "qorganizer-eds-enginedata.h"
#include
#include
using namespace QtOrganizer;
RemoveByIdRequestData::RemoveByIdRequestData(QOrganizerEDSEngine *engine, QtOrganizer::QOrganizerAbstractRequest *req)
: RequestData(engine, req),
m_sessionStaterd(0),
m_currentCompIds(0)
{
Q_FOREACH(const QOrganizerItemId &id, request()->itemIds()) {
QString strId = id.toString();
QString collectionId;
if (strId.contains("/")) {
collectionId = strId.split("/").first();
QSet ids = m_pending.value(collectionId);
ids << id;
m_pending.insert(collectionId, ids);
}
}
}
RemoveByIdRequestData::~RemoveByIdRequestData()
{
}
void RemoveByIdRequestData::finish(QtOrganizer::QOrganizerManager::Error error)
{
QOrganizerManagerEngine::updateItemRemoveByIdRequest(request(),
error,
QMap(),
QOrganizerAbstractRequest::FinishedState);
//The signal will be fired by the view watcher. Check ViewWatcher::onObjectsRemoved
//emitChangeset(&m_changeSet);
}
GSList *RemoveByIdRequestData::compIds() const
{
return m_currentCompIds;
}
void RemoveByIdRequestData::commit()
{
Q_ASSERT(m_sessionStaterd);
QOrganizerManagerEngine::updateItemRemoveByIdRequest(request(),
QtOrganizer::QOrganizerManager::NoError,
QMap(),
QOrganizerAbstractRequest::ActiveState);
reset();
}
GSList *RemoveByIdRequestData::parseIds(QSet iids)
{
GSList *ids = 0;
Q_FOREACH(const QOrganizerItemId &iid, iids) {
ECalComponentId *id = QOrganizerEDSEngineId::toComponentIdObject(iid);
if (id) {
ids = g_slist_append(ids, id);
}
}
return ids;
}
QString RemoveByIdRequestData::next()
{
Q_ASSERT(!m_sessionStaterd);
if (m_pending.count() > 0) {
m_sessionStaterd = true;
m_currentCollectionId = m_pending.keys().first();
m_currentIds = m_pending[m_currentCollectionId];
m_currentCompIds = parseIds(m_currentIds);
m_pending.remove(m_currentCollectionId);
return m_currentCollectionId;
}
return QString(QString::null);
}
void RemoveByIdRequestData::reset()
{
m_currentIds.clear();
m_currentCollectionId = QString(QString::null);
if (m_currentCompIds) {
g_slist_free_full(m_currentCompIds, (GDestroyNotify)e_cal_component_free_id);
m_currentCompIds = 0;
}
m_sessionStaterd = false;
}
void RemoveByIdRequestData::cancel()
{
Q_ASSERT(m_sessionStaterd);
RequestData::cancel();
clear();
}
void RemoveByIdRequestData::clear()
{
reset();
m_pending.clear();
setClient(0);
}
QString RemoveByIdRequestData::collectionId() const
{
return m_currentCollectionId;
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-source-registry.cpp 0000644 0000153 0177776 00000024556 12323305711 030445 0 ustar pbuser nogroup 0000000 0000000 #include "qorganizer-eds-source-registry.h"
#include
using namespace QtOrganizer;
SourceRegistry::SourceRegistry(QObject *parent)
: QObject(parent),
m_sourceRegistry(0),
m_sourceAddedId(0),
m_sourceRemovedId(0),
m_sourceChangedId(0),
m_sourceEnabledId(0),
m_sourceDisabledId(0)
{
}
SourceRegistry::~SourceRegistry()
{
clear();
if (m_sourceRegistry) {
g_signal_handler_disconnect(m_sourceRegistry, m_sourceAddedId);
g_signal_handler_disconnect(m_sourceRegistry, m_sourceRemovedId);
g_signal_handler_disconnect(m_sourceRegistry, m_sourceChangedId);
g_signal_handler_disconnect(m_sourceRegistry, m_sourceEnabledId);
g_signal_handler_disconnect(m_sourceRegistry, m_sourceDisabledId);
g_clear_object(&m_sourceRegistry);
}
}
ESourceRegistry *SourceRegistry::object() const
{
return m_sourceRegistry;
}
void SourceRegistry::load()
{
if (m_sourceRegistry) {
return;
}
clear();
GError *error = 0;
m_sourceRegistry = e_source_registry_new_sync(0, &error);
if (error) {
qWarning() << "Fail to create sourge registry:" << error->message;
g_error_free(error);
return;
}
m_sourceAddedId = g_signal_connect(m_sourceRegistry,
"source-added",
(GCallback) SourceRegistry::onSourceAdded,
this);
m_sourceChangedId = g_signal_connect(m_sourceRegistry,
"source-changed",
(GCallback) SourceRegistry::onSourceChanged,
this);
m_sourceDisabledId = g_signal_connect(m_sourceRegistry,
"source-disabled",
(GCallback) SourceRegistry::onSourceRemoved,
this);
m_sourceEnabledId = g_signal_connect(m_sourceRegistry,
"source-enabled",
(GCallback) SourceRegistry::onSourceAdded,
this);
m_sourceRemovedId = g_signal_connect(m_sourceRegistry,
"source-removed",
(GCallback) SourceRegistry::onSourceRemoved,
this);
// We use calendar as default source, if you are trying to use other source type
// you need to set the item source id manually
ESource *defaultCalendarSource = e_source_registry_ref_default_calendar(m_sourceRegistry);
GList *sources = e_source_registry_list_sources(m_sourceRegistry, 0);
for(int i = 0, iMax = g_list_length(sources); i < iMax; i++) {
ESource *source = E_SOURCE(g_list_nth_data(sources, i));
QOrganizerCollection collection = registerSource(source);
if (e_source_equal(defaultCalendarSource, source)) {
m_defaultCollection = collection;
}
}
g_list_free_full(sources, g_object_unref);
if (defaultCalendarSource) {
g_object_unref(defaultCalendarSource);
}
}
QtOrganizer::QOrganizerCollection SourceRegistry::defaultCollection() const
{
return m_defaultCollection;
}
QOrganizerCollection SourceRegistry::collection(const QString &collectionId) const
{
return m_collections.value(collectionId);
}
QList SourceRegistry::collections() const
{
return m_collections.values();
}
QStringList SourceRegistry::collectionsIds() const
{
return m_collections.keys();
}
QList SourceRegistry::collectionsEngineIds() const
{
return m_collectionsMap.values();
}
QOrganizerEDSCollectionEngineId *SourceRegistry::collectionEngineId(const QString &collectionId) const
{
return m_collectionsMap.value(collectionId, 0);
}
ESource *SourceRegistry::source(const QString &collectionId) const
{
return m_sources[collectionId];
}
QOrganizerCollection SourceRegistry::collection(ESource *source) const
{
QString collectionId = findCollection(source);
return m_collections[collectionId];
}
QOrganizerCollection SourceRegistry::insert(ESource *source)
{
return registerSource(source);
}
void SourceRegistry::remove(ESource *source)
{
QString collectionId = findCollection(source);
remove(collectionId);
}
void SourceRegistry::remove(const QString &collectionId)
{
if (collectionId.isEmpty()) {
return;
}
QOrganizerCollection collection = m_collections.take(collectionId);
if (!collection.id().isNull()) {
Q_EMIT sourceRemoved(collectionId);
m_collectionsMap.remove(collectionId);
g_object_unref(m_sources.take(collectionId));
EClient *client = m_clients.take(collectionId);
if (client) {
g_object_unref(client);
}
}
}
EClient* SourceRegistry::client(const QString &collectionId)
{
if (collectionId.isEmpty()) {
return 0;
}
EClient *client = m_clients.value(collectionId, 0);
if (!client) {
QOrganizerEDSCollectionEngineId *eid = m_collectionsMap[collectionId];
if (eid) {
GError *gError = 0;
client = e_cal_client_connect_sync(eid->m_esource, eid->m_sourceType, 0, &gError);
if (gError) {
qWarning() << "Fail to connect with client" << gError->message;
g_error_free(gError);
} else {
m_clients.insert(collectionId, client);
}
}
}
if (client) {
g_object_ref(client);
}
return client;
}
void SourceRegistry::clear()
{
Q_FOREACH(ESource *source, m_sources.values()) {
g_object_unref(source);
}
Q_FOREACH(EClient *client, m_clients.values()) {
g_object_unref(client);
}
m_sources.clear();
m_collections.clear();
m_collectionsMap.clear();
m_clients.clear();
}
QString SourceRegistry::findCollection(ESource *source) const
{
QMap::ConstIterator i = m_sources.constBegin();
while (i != m_sources.constEnd()) {
if (e_source_equal(source, i.value())) {
return i.key();
}
i++;
}
return QString();
}
QOrganizerCollection SourceRegistry::registerSource(ESource *source)
{
QString collectionId = findCollection(source);
if (collectionId.isEmpty()) {
bool isEnabled = e_source_get_enabled(source);
bool isCalendar = e_source_has_extension(source, E_SOURCE_EXTENSION_CALENDAR);
bool isTaskList = e_source_has_extension(source, E_SOURCE_EXTENSION_TASK_LIST);
bool isMemoList = e_source_has_extension(source, E_SOURCE_EXTENSION_MEMO_LIST);
bool isAlarms = e_source_has_extension(source, E_SOURCE_EXTENSION_ALARMS);
if ( isEnabled && (isCalendar || isTaskList || isMemoList || isAlarms)) {
QOrganizerEDSCollectionEngineId *edsId = 0;
QOrganizerCollection collection = parseSource(source, &edsId);
QString collectionId = collection.id().toString();
if (!m_collectionsMap.contains(collectionId)) {
m_collections.insert(collectionId, collection);
m_collectionsMap.insert(collectionId, edsId);
m_sources.insert(collectionId, source);
g_object_ref(source);
Q_EMIT sourceAdded(collectionId);
} else {
Q_ASSERT(false);
}
return collection;
}
return QOrganizerCollection();
} else {
return m_collections.value(collectionId);
}
}
QOrganizerCollection SourceRegistry::parseSource(ESource *source,
QOrganizerEDSCollectionEngineId **edsId)
{
*edsId = new QOrganizerEDSCollectionEngineId(source);
QOrganizerCollectionId id(*edsId);
QOrganizerCollection collection;
collection.setId(id);
updateCollection(&collection, source);
return collection;
}
void SourceRegistry::onSourceAdded(ESourceRegistry *registry,
ESource *source,
SourceRegistry *self)
{
Q_UNUSED(registry);
self->insert(source);
}
void SourceRegistry::onSourceChanged(ESourceRegistry *registry,
ESource *source,
SourceRegistry *self)
{
Q_UNUSED(registry);
QString collectionId = self->findCollection(source);
if (!collectionId.isEmpty() && self->m_collections.contains(collectionId)) {
QOrganizerCollection &collection = self->m_collections[collectionId];
self->updateCollection(&collection, source);
Q_EMIT self->sourceUpdated(collectionId);
} else {
qWarning() << "Source changed not found";
}
}
void SourceRegistry::onSourceRemoved(ESourceRegistry *registry,
ESource *source,
SourceRegistry *self)
{
Q_UNUSED(registry);
self->remove(source);
}
void SourceRegistry::updateCollection(QOrganizerCollection *collection,
ESource *source)
{
//TODO get metadata (color, etc..)
collection->setMetaData(QOrganizerCollection::KeyName,
QString::fromUtf8(e_source_get_display_name(source)));
// name
collection->setMetaData(QOrganizerCollection::KeyName,
QString::fromUtf8(e_source_get_display_name(source)));
// extension
ESourceBackend *extCalendar;
if (e_source_has_extension(source, E_SOURCE_EXTENSION_TASK_LIST)) {
extCalendar = E_SOURCE_BACKEND(e_source_get_extension(source, E_SOURCE_EXTENSION_TASK_LIST));
collection->setExtendedMetaData(COLLECTION_CALLENDAR_TYPE_METADATA, E_SOURCE_EXTENSION_TASK_LIST);
} else if (e_source_has_extension(source, E_SOURCE_EXTENSION_MEMO_LIST)) {
extCalendar = E_SOURCE_BACKEND(e_source_get_extension(source, E_SOURCE_EXTENSION_MEMO_LIST));
collection->setExtendedMetaData(COLLECTION_CALLENDAR_TYPE_METADATA, E_SOURCE_EXTENSION_MEMO_LIST);
} else {
extCalendar = E_SOURCE_BACKEND(e_source_get_extension(source, E_SOURCE_EXTENSION_CALENDAR));
collection->setExtendedMetaData(COLLECTION_CALLENDAR_TYPE_METADATA, E_SOURCE_EXTENSION_CALENDAR);
}
// color
const gchar *color = e_source_selectable_get_color(E_SOURCE_SELECTABLE(extCalendar));
collection->setMetaData(QOrganizerCollection::KeyColor, QString::fromUtf8(color));
// selected
bool selected = (e_source_selectable_get_selected(E_SOURCE_SELECTABLE(extCalendar)) == TRUE);
collection->setExtendedMetaData(COLLECTION_SELECTED_METADATA, selected);
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-saverequestdata.h 0000644 0000153 0177776 00000004037 12323305673 030144 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_SAVEREQUESTDATA_H__
#define __QORGANIZER_EDS_SAVEREQUESTDATA_H__
#include "qorganizer-eds-requestdata.h"
#include "qorganizer-eds-engine.h"
class SaveRequestData : public RequestData
{
public:
SaveRequestData(QOrganizerEDSEngine *engine,
QtOrganizer::QOrganizerAbstractRequest *req);
~SaveRequestData();
void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
QString nextCollection();
QString currentCollection() const;
QList takeItemsToCreate();
QList takeItemsToUpdate();
bool end() const;
void setWorkingItems(QList items);
QList workingItems() const;
int updateMode() const;
void appendResults(QList results);
void appendResult(const QtOrganizer::QOrganizerItem &item, QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
private:
QList m_result;
QMap m_erros;
QMap > m_items;
QList m_currentItems;
QList m_workingItems;
QString m_currentCollection;
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-engineid.h 0000644 0000153 0177776 00000004446 12323305647 026532 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of canonical-pim-service
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_ENGINEID_H__
#define __QORGANIZER_EDS_ENGINEID_H__
#include "qorganizer-eds-collection-engineid.h"
#include
#include
#include
class QOrganizerEDSEngineId : public QtOrganizer::QOrganizerItemEngineId
{
public:
QOrganizerEDSEngineId();
QOrganizerEDSEngineId(const QString& collectionId,
const QString& id);
~QOrganizerEDSEngineId();
QOrganizerEDSEngineId(const QOrganizerEDSEngineId& other);
QOrganizerEDSEngineId(const QString& idString);
bool isEqualTo(const QtOrganizer::QOrganizerItemEngineId* other) const;
bool isLessThan(const QtOrganizer::QOrganizerItemEngineId* other) const;
QString managerUri() const;
QtOrganizer::QOrganizerItemEngineId* clone() const;
QString toString() const;
uint hash() const;
#ifndef QT_NO_DEBUG_STREAM
QDebug& debugStreamOut(QDebug& dbg) const;
#endif
static QString managerUriStatic();
static QString managerNameStatic();
static QString toComponentId(const QtOrganizer::QOrganizerItemId &itemId, QString *rid);
static QString toComponentId(const QString &itemId, QString *rid);
static ECalComponentId *toComponentIdObject(const QtOrganizer::QOrganizerItemId &itemId);
static QOrganizerEDSEngineId *fromComponentId(const QString &cId,
ECalComponentId *id,
QOrganizerEDSEngineId **parentId);
private:
QString m_collectionId;
QString m_itemId;
friend class QOrganizerEDSEngine;
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-removebyidrequestdata.h 0000644 0000153 0177776 00000003112 12323305647 031345 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#ifndef __QORGANIZER_EDS_REMOVEBYIDQUESTDATA_H__
#define __QORGANIZER_EDS_REMOVEBYIDQUESTDATA_H__
#include "qorganizer-eds-requestdata.h"
#include
class RemoveByIdRequestData : public RequestData
{
public:
RemoveByIdRequestData(QOrganizerEDSEngine *engine, QtOrganizer::QOrganizerAbstractRequest *req);
~RemoveByIdRequestData();
QString collectionId() const;
void finish(QtOrganizer::QOrganizerManager::Error error = QtOrganizer::QOrganizerManager::NoError);
GSList *compIds() const;
QString next();
void commit();
virtual void cancel();
private:
QHash > m_pending;
QSet m_currentIds;
QString m_currentCollectionId;
bool m_sessionStaterd;
GSList *m_currentCompIds;
void reset();
void clear();
GSList *parseIds(QSet iids);
};
#endif
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-fetchocurrencedata.cpp 0000644 0000153 0177776 00000005575 12323305647 031140 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-fetchocurrencedata.h"
#include
#include
#include
using namespace QtOrganizer;
FetchOcurrenceData::FetchOcurrenceData(QOrganizerEDSEngine *engine,
QOrganizerAbstractRequest *req)
: RequestData(engine, req),
m_components(0)
{
}
FetchOcurrenceData::~FetchOcurrenceData()
{
if (m_components) {
g_slist_free_full(m_components, (GDestroyNotify)icalcomponent_free);
m_components = 0;
}
}
time_t FetchOcurrenceData::startDate() const
{
QDateTime startDate = request()->startDate();
if (!startDate.isValid()) {
startDate = QDateTime::fromTime_t(0);
qWarning() << "Start date is invalide using " << startDate;
}
return startDate.toTime_t();
}
time_t FetchOcurrenceData::endDate() const
{
QDateTime endDate = request()->endDate();
if (!endDate.isValid()) {
QDate currentDate = QDate::currentDate();
endDate.setTime(QTime(0, 0, 0));
endDate.setDate(QDate(currentDate.year()+1, 1, 1));
qWarning() << "End date is invalid using " << endDate;
}
return endDate.toTime_t();
}
void FetchOcurrenceData::finish(QOrganizerManager::Error error)
{
QList results;
if (m_components) {
QString collectionId = request()->parentItem().collectionId().toString();
results = parent()->parseEvents(collectionId, m_components, true);
g_slist_free_full(m_components, (GDestroyNotify)icalcomponent_free);
m_components = 0;
}
QOrganizerManagerEngine::updateItemOccurrenceFetchRequest(request(),
results,
error,
QOrganizerAbstractRequest::FinishedState);
}
void FetchOcurrenceData::appendResult(icalcomponent *comp)
{
m_components = g_slist_append(m_components, comp);
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/eds.json 0000644 0000153 0177776 00000000032 12323305647 023300 0 ustar pbuser nogroup 0000000 0000000 {
"Keys": [ "eds" ]
}
qtorganizer5-eds-0.1.1+14.04.20140415.1/qorganizer/qorganizer-eds-fetchbyidrequestdata.cpp 0000644 0000153 0177776 00000005040 12323305647 031476 0 ustar pbuser nogroup 0000000 0000000 /*
* Copyright 2013 Canonical Ltd.
*
* This file is part of ubuntu-pim-service.
*
* contact-service-app 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; version 3.
*
* contact-service-app 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, see .
*/
#include "qorganizer-eds-fetchbyidrequestdata.h"
#include
using namespace QtOrganizer;
FetchByIdRequestData::FetchByIdRequestData(QOrganizerEDSEngine *engine,
QOrganizerAbstractRequest *req)
: RequestData(engine, req),
m_current(-1)
{
}
FetchByIdRequestData::~FetchByIdRequestData()
{
}
QString FetchByIdRequestData::nextId()
{
QString id;
QList