static gboolean
update_objects (ECal *client, icalcomponent *icalcomp)
{
icalcomponent_kind kind;
icalcomponent *vcal;
gboolean success = TRUE;
kind = icalcomponent_isa (icalcomp);
if (kind == ICAL_VTODO_COMPONENT || kind == ICAL_VEVENT_COMPONENT) {
vcal = e_cal_util_new_top_level ();
if (icalcomponent_get_method (icalcomp) == ICAL_METHOD_CANCEL)
icalcomponent_set_method (vcal, ICAL_METHOD_CANCEL);
else
icalcomponent_set_method (vcal, ICAL_METHOD_PUBLISH);
icalcomponent_add_component (vcal, icalcomponent_new_clone (icalcomp));
} else if (kind == ICAL_VCALENDAR_COMPONENT) {
vcal = icalcomponent_new_clone (icalcomp);
if (!icalcomponent_get_first_property (vcal, ICAL_METHOD_PROPERTY))
icalcomponent_set_method (vcal, ICAL_METHOD_PUBLISH);
} else
return FALSE;
if (!e_cal_receive_objects (client, vcal, NULL))
success = FALSE;
icalcomponent_free (vcal);
return success;
}
void
dates_ical_drop_cb (DatesView *view, const gchar *ical, DatesData *d)
{
icalcomponent *icalcomp, *icalcomp2;
gint events;
if (!d->cal_loaded) {
/* TODO: Toggle the default calendar here maybe? */
g_warning ("No calendars selected to add new event to");
return;
}
icalcomp = icalcomponent_new_from_string (g_strdup (ical));
if (!icalcomp)
g_warning ("Error creating icalcomponent from string");
switch (icalcomponent_isa (icalcomp)) {
case ICAL_VEVENT_COMPONENT :
icalcomponent_set_uid (icalcomp, "");
dates_new (d, icalcomponent_new_clone (icalcomp), TRUE);
return;
case ICAL_VCALENDAR_COMPONENT :
/* Iterate through events */
/* TODO: A confirmation dialog when calendar has
* multiple events?
*/
events = icalcomponent_count_components (icalcomp,
ICAL_VEVENT_COMPONENT);
if (events == 0) {
g_warning ("Dragged ical contains no supported "
"kinds.");
break;
}
icalcomp2 = icalcomponent_get_first_component (icalcomp,
ICAL_VEVENT_COMPONENT);
do {
icalcomponent_set_uid (icalcomp2, "");
dates_new (d, icalcomponent_new_clone (
icalcomp2), (events == 1) ?
TRUE : FALSE);
} while ((icalcomp2 = icalcomponent_get_next_component (
icalcomp2, ICAL_VEVENT_COMPONENT)));
break;
default :
g_warning ("Dragged ical not a supported kind.");
break;
}
icalcomponent_free (icalcomp);
}
static char *
serialize (ScalixObject * object)
{
ScalixAppointmentPrivate *priv;
icalcomponent *icomp, *toplevel_comp;
ECalComponent *comp;
GSList *iter;
char *result = NULL;
priv = SCALIX_APPOINTMENT_GET_PRIVATE (SCALIX_APPOINTMENT (object));
scalix_appointment_unset (SCALIX_APPOINTMENT (object),
"X-SCALIX-DESCRIPTION-CHANGED");
comp = E_CAL_COMPONENT (object);
e_cal_component_commit_sequence (comp);
icomp = e_cal_component_get_icalcomponent (comp);
if (icomp) {
toplevel_comp = e_cal_util_new_top_level ();
/* add timezone if one exists */
if (priv->timezone) {
icalcomponent_add_component (toplevel_comp,
icalcomponent_new_clone
(icaltimezone_get_component
(priv->timezone)));
}
/* add the main vevent */
icalcomponent_add_component (toplevel_comp,
icalcomponent_new_clone (icomp));
/* add exceptions if they exist */
for (iter = priv->exceptions; iter; iter = iter->next) {
icalcomponent_add_component (toplevel_comp,
icalcomponent_new_clone ((icalcomponent*) iter->data));
}
result = icalcomponent_as_ical_string (toplevel_comp);
if (result != NULL) {
result = g_strdup (result);
}
icalcomponent_free (toplevel_comp);
}
return result;
}
static void
insert_tz_comps (icalparameter *param,
gpointer cb_data)
{
const gchar *tzid;
CompTzData *tdata = cb_data;
icaltimezone *zone = NULL;
icalcomponent *tzcomp;
GError *error = NULL;
tzid = icalparameter_get_tzid (param);
if (g_hash_table_lookup (tdata->zones, tzid))
return;
e_cal_client_get_timezone_sync (
tdata->client, tzid, &zone, NULL, &error);
if (error != NULL) {
g_warning (
"Could not get the timezone information for %s: %s",
tzid, error->message);
g_error_free (error);
return;
}
tzcomp = icalcomponent_new_clone (icaltimezone_get_component (zone));
g_hash_table_insert (tdata->zones, (gpointer) tzid, (gpointer) tzcomp);
}
static void
action_calendar_taskpad_print_cb (GtkAction *action,
ECalShellView *cal_shell_view)
{
ECalShellContent *cal_shell_content;
ECalModelComponent *comp_data;
ETaskTable *task_table;
ECalComponent *comp;
ECalModel *model;
icalcomponent *clone;
GSList *list;
cal_shell_content = cal_shell_view->priv->cal_shell_content;
task_table = e_cal_shell_content_get_task_table (cal_shell_content);
model = e_task_table_get_model (task_table);
list = e_task_table_get_selected (task_table);
g_return_if_fail (list != NULL);
comp_data = list->data;
g_slist_free (list);
/* XXX We only print the first selected task. */
comp = e_cal_component_new ();
clone = icalcomponent_new_clone (comp_data->icalcomp);
e_cal_component_set_icalcomponent (comp, clone);
print_comp (
comp, comp_data->client,
e_cal_model_get_timezone (model),
e_cal_model_get_use_24_hour_format (model),
GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG);
g_object_unref (comp);
}
enum OpenAB_Storage::Storage::eGetItem EDSCalendarStorage::getEvent(const OpenAB::PIMItem::ID & id,
OpenAB::SmartPtr<OpenAB::PIMCalendarEventItem> & item)
{
if (getItemType() != OpenAB::eEvent)
{
return eGetItemFail;
}
GError* gerror = NULL;
GSList* events = NULL;
std::vector<icalcomponent*> iCalComponents;
if (!e_cal_client_get_objects_for_uid_sync(client, id.c_str(), &events, NULL, &gerror))
{
LOG_ERROR() << "Error e_cal_client_get_objects_for_uid_sync result: " << GERROR_MESSAGE(gerror) << std::endl;
GERROR_FREE(gerror);
return eGetItemFail;
}
GSList* current = events;
while(current)
{
ECalComponent* component = (ECalComponent*)current->data;
iCalComponents.push_back(icalcomponent_new_clone(e_cal_component_get_icalcomponent(component)));
current = current->next;
}
item = (OpenAB::PIMCalendarEventItem*)EDSCalendarStorageCommon::processObject(iCalComponents);
e_cal_client_free_ecalcomp_slist(events);
return eGetItemOk;
}
nsresult
calIcalComponent::Serialize(char **icalstr)
{
NS_ENSURE_ARG_POINTER(icalstr);
// add the timezone bits
if (icalcomponent_isa(mComponent) == ICAL_VCALENDAR_COMPONENT && mReferencedTimezones.Count() > 0) {
for (auto iter = mReferencedTimezones.ConstIter(); !iter.Done(); iter.Next() ) {
icaltimezone * icaltz = cal::getIcalTimezone(iter.Data());
if (icaltz) {
icalcomponent * const tzcomp = icalcomponent_new_clone(icaltimezone_get_component(icaltz));
icalcomponent_add_component(mComponent, tzcomp);
}
}
}
*icalstr = icalcomponent_as_ical_string(mComponent);
if (!*icalstr) {
// xxx todo: what about NS_ERROR_OUT_OF_MEMORY?
#ifdef DEBUG
fprintf(stderr, "Error serializing: %d (%s)\n",
icalerrno, icalerror_strerror(icalerrno));
#endif
// The return values in calIError match with libical errnos,
// so no need for a conversion table or anything.
return static_cast<nsresult>(calIErrors::ICS_ERROR_BASE + icalerrno);
}
return NS_OK;
}
static void
action_calendar_taskpad_forward_cb (GtkAction *action,
ECalShellView *cal_shell_view)
{
ECalShellContent *cal_shell_content;
ECalModelComponent *comp_data;
ETaskTable *task_table;
ECalComponent *comp;
GSList *list;
cal_shell_content = cal_shell_view->priv->cal_shell_content;
task_table = e_cal_shell_content_get_task_table (cal_shell_content);
list = e_task_table_get_selected (task_table);
g_return_if_fail (list != NULL);
comp_data = list->data;
g_slist_free (list);
/* XXX We only forward the first selected task. */
comp = e_cal_component_new_from_icalcomponent (icalcomponent_new_clone (comp_data->icalcomp));
g_return_if_fail (comp != NULL);
itip_send_component (e_task_table_get_model (task_table),
E_CAL_COMPONENT_METHOD_PUBLISH, comp, comp_data->client,
NULL, NULL, NULL, TRUE, FALSE, TRUE);
g_object_unref (comp);
}
/**
* get ICalendar VTIMEZONE block from ECalComponentWithTZ
*
* @param ectz
* An evolution event/task/note type which may contain a time zone.
*
* @return the ICalendar VTIMEZONE block
*/
static gchar*
get_vtimezone (const ECalComponentWithTZ *ectz)
{
icalcomponent *icc = NULL;
icalcomponent *cloned_icc = NULL;
icalproperty *dtstamp = NULL;
icalproperty *uid = NULL;
gchar *ical_str = NULL;
if (ectz == NULL || ectz->maincomp == NULL || ectz->timezone == NULL)
return NULL;
icc = e_cal_component_get_icalcomponent (ectz->timezone);
cloned_icc = icalcomponent_new_clone (icc);
/* uid and dtstamp are not needed (nor wanted) in timezone block */
uid = icalcomponent_get_first_property(cloned_icc, ICAL_UID_PROPERTY);
icalcomponent_remove_property (cloned_icc, uid);
free(uid);
dtstamp = icalcomponent_get_first_property(cloned_icc, ICAL_DTSTAMP_PROPERTY);
icalcomponent_remove_property (cloned_icc, dtstamp);
free(dtstamp);
/* memory returned by *_as_ical_string() is owned by libical */
ical_str = g_strdup (icalcomponent_as_ical_string (cloned_icc));
icalcomponent_free (cloned_icc);
return ical_str;
}
/**
* e_cal_util_construct_instance:
* @icalcomp: A recurring #icalcomponent
* @rid: The RECURRENCE-ID to construct a component for
*
* This checks that @rid indicates a valid recurrence of @icalcomp, and
* if so, generates a copy of @comp containing a RECURRENCE-ID of @rid.
*
* Returns: the instance, or %NULL.
**/
icalcomponent *
e_cal_util_construct_instance (icalcomponent *icalcomp,
struct icaltimetype rid)
{
struct instance_data instance;
struct icaltimetype start, end;
g_return_val_if_fail (icalcomp != NULL, NULL);
/* Make sure this is really recurring */
if (!icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY) &&
!icalcomponent_get_first_property (icalcomp, ICAL_RDATE_PROPERTY))
return NULL;
/* Make sure the specified instance really exists */
start = icaltime_convert_to_zone (rid, icaltimezone_get_utc_timezone ());
end = start;
icaltime_adjust (&end, 0, 0, 0, 1);
instance.start = icaltime_as_timet (start);
instance.found = FALSE;
icalcomponent_foreach_recurrence (icalcomp, start, end,
check_instance, &instance);
if (!instance.found)
return NULL;
/* Make the instance */
icalcomp = icalcomponent_new_clone (icalcomp);
icalcomponent_set_recurrenceid (icalcomp, rid);
return icalcomp;
}
static void
calendar_appointment_generate_occurrences (CalendarAppointment *appointment,
icalcomponent *ical,
ECalClient *cal,
time_t start,
time_t end,
icaltimezone *default_zone)
{
ECalComponent *ecal;
g_assert (appointment->occurrences == NULL);
ecal = e_cal_component_new ();
e_cal_component_set_icalcomponent (ecal,
icalcomponent_new_clone (ical));
e_cal_recur_generate_instances (ecal,
start,
end,
calendar_appointment_collect_occurrence,
&appointment->occurrences,
(ECalRecurResolveTimezoneFn) resolve_timezone_id,
cal,
default_zone);
g_object_unref (ecal);
appointment->occurrences = g_slist_reverse (appointment->occurrences);
}
static void
add_timezone_cb (icalparameter *param,
gpointer data)
{
icaltimezone *tz;
const gchar *tzid;
icalcomponent *vtz_comp;
ForeachTzidData *f_data = (ForeachTzidData *) data;
tzid = icalparameter_get_tzid (param);
if (!tzid)
return;
tz = icalcomponent_get_timezone (f_data->vcal_comp, tzid);
if (tz)
return;
tz = icalcomponent_get_timezone (f_data->icalcomp, tzid);
if (!tz) {
tz = icaltimezone_get_builtin_timezone_from_tzid (tzid);
if (!tz)
return;
}
vtz_comp = icaltimezone_get_component (tz);
if (!vtz_comp)
return;
icalcomponent_add_component (
f_data->vcal_comp,
icalcomponent_new_clone (vtz_comp));
}
void
e_task_shell_view_open_task (ETaskShellView *task_shell_view,
ECalModelComponent *comp_data)
{
EShell *shell;
EShellView *shell_view;
EShellWindow *shell_window;
ESourceRegistry *registry;
CompEditor *editor;
CompEditorFlags flags = 0;
ECalComponent *comp;
icalcomponent *clone;
icalproperty *prop;
const gchar *uid;
g_return_if_fail (E_IS_TASK_SHELL_VIEW (task_shell_view));
g_return_if_fail (E_IS_CAL_MODEL_COMPONENT (comp_data));
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
shell = e_shell_window_get_shell (shell_window);
registry = e_shell_get_registry (shell);
uid = icalcomponent_get_uid (comp_data->icalcomp);
editor = comp_editor_find_instance (uid);
if (editor != NULL)
goto exit;
comp = e_cal_component_new ();
clone = icalcomponent_new_clone (comp_data->icalcomp);
e_cal_component_set_icalcomponent (comp, clone);
prop = icalcomponent_get_first_property (
comp_data->icalcomp, ICAL_ATTENDEE_PROPERTY);
if (prop != NULL)
flags |= COMP_EDITOR_IS_ASSIGNED;
if (itip_organizer_is_user (registry, comp, comp_data->client))
flags |= COMP_EDITOR_USER_ORG;
if (!e_cal_component_has_attendees (comp))
flags |= COMP_EDITOR_USER_ORG;
editor = task_editor_new (comp_data->client, shell, flags);
comp_editor_edit_comp (editor, comp);
g_object_unref (comp);
if (flags & COMP_EDITOR_IS_ASSIGNED)
task_editor_show_assignment (TASK_EDITOR (editor));
exit:
gtk_window_present (GTK_WINDOW (editor));
}
icalcluster *icalcluster_new_clone(const icalcluster *data) {
struct icalcluster_impl *old = (struct icalcluster_impl *)data;
struct icalcluster_impl *impl = icalcluster_new_impl();
impl->key = strdup(old->key);
impl->data = icalcomponent_new_clone(old->data);
impl->changed = 0;
return impl;
}
Todo::Todo (const Todo & event) :
_summary(event._summary), _location(event._location), _description(event._description) {
if (event._ptrIcal) {
_ptrIcal = icalcomponent_new_clone(event._ptrIcal);
}
else {
_ptrIcal = nullptr;
}
}
static PLDHashOperator
AddTimezoneComponentToIcal(nsACString const& /*tzid*/, calITimezone * tz, void * arg)
{
icalcomponent * const comp = static_cast<icalcomponent *>(arg);
icaltimezone * icaltz = cal::getIcalTimezone(tz);
if (icaltz) {
icalcomponent * const tzcomp = icalcomponent_new_clone(icaltimezone_get_component(icaltz));
icalcomponent_add_component(comp, tzcomp);
}
return PL_DHASH_NEXT;
}
static void
cal_model_calendar_set_value_at (ETableModel *etm,
gint col,
gint row,
gconstpointer value)
{
ECalModelComponent *comp_data;
ECalObjModType mod = E_CAL_OBJ_MOD_ALL;
ECalComponent *comp;
ECalModelCalendar *model = (ECalModelCalendar *) etm;
g_return_if_fail (E_IS_CAL_MODEL_CALENDAR (model));
g_return_if_fail (col >= 0 && col < E_CAL_MODEL_CALENDAR_FIELD_LAST);
g_return_if_fail (row >= 0 && row < e_table_model_row_count (etm));
if (col < E_CAL_MODEL_FIELD_LAST) {
table_model_parent_interface->set_value_at (etm, col, row, value);
return;
}
comp_data = e_cal_model_get_component_at (E_CAL_MODEL (model), row);
if (!comp_data)
return;
comp = e_cal_component_new_from_icalcomponent (icalcomponent_new_clone (comp_data->icalcomp));
if (!comp) {
return;
}
/* ask about mod type */
if (e_cal_component_is_instance (comp)) {
if (!e_cal_dialogs_recur_component (comp_data->client, comp, &mod, NULL, FALSE)) {
g_object_unref (comp);
return;
}
}
switch (col) {
case E_CAL_MODEL_CALENDAR_FIELD_DTEND :
set_dtend ((ECalModel *) model, comp_data, value);
break;
case E_CAL_MODEL_CALENDAR_FIELD_LOCATION :
set_location (comp_data, value);
break;
case E_CAL_MODEL_CALENDAR_FIELD_TRANSPARENCY :
set_transparency (comp_data, value);
break;
}
e_cal_model_modify_component (E_CAL_MODEL (model), comp_data, mod);
g_object_unref (comp);
}
static void
update_objects (ECalClient *cal_client,
icalcomponent *icalcomp,
GCancellable *cancellable,
void (*done_cb) (gpointer user_data),
gpointer user_data)
{
icalcomponent_kind kind;
icalcomponent *vcal;
struct UpdateObjectsData *uod;
kind = icalcomponent_isa (icalcomp);
if (kind == ICAL_VTODO_COMPONENT || kind == ICAL_VEVENT_COMPONENT) {
vcal = e_cal_util_new_top_level ();
if (icalcomponent_get_method (icalcomp) == ICAL_METHOD_CANCEL)
icalcomponent_set_method (vcal, ICAL_METHOD_CANCEL);
else
icalcomponent_set_method (vcal, ICAL_METHOD_PUBLISH);
icalcomponent_add_component (vcal, icalcomponent_new_clone (icalcomp));
} else if (kind == ICAL_VCALENDAR_COMPONENT) {
vcal = icalcomponent_new_clone (icalcomp);
if (!icalcomponent_get_first_property (vcal, ICAL_METHOD_PROPERTY))
icalcomponent_set_method (vcal, ICAL_METHOD_PUBLISH);
} else {
if (done_cb)
done_cb (user_data);
return;
}
uod = g_new0 (struct UpdateObjectsData, 1);
uod->done_cb = done_cb;
uod->user_data = user_data;
e_cal_client_receive_objects (cal_client, vcal, cancellable, receive_objects_ready_cb, uod);
icalcomponent_free (vcal);
return;
}
static void addsystemtz(gpointer key,
gpointer value,
gpointer user_data)
{
const char *tzid = key;
icalcomponent *comp = user_data;
icaltimezone *zone;
zone = icaltimezone_get_builtin_timezone_from_tzid(tzid);
if (zone) {
icalcomponent_add_component(comp,
icalcomponent_new_clone(icaltimezone_get_component(zone)));
}
}
NS_IMETHODIMP
calIcalComponent::AddSubcomponent(calIIcalComponent *aComp)
{
NS_ENSURE_ARG_POINTER(aComp);
/* XXX mildly unsafe assumption here.
* To fix it, I will:
* - check the object's classinfo to find out if I have one of my
* own objects, and if not
* - use comp->serializeToICS and reparse to create a copy.
*
* I should probably also return the new/reused component so that the
* caller has something it can poke at all live-like.
*/
nsresult rv;
nsCOMPtr<calIIcalComponentLibical> icalcomp = do_QueryInterface(aComp, &rv);
NS_ENSURE_SUCCESS(rv, rv);
calIcalComponent * const ical = toIcalComponent(icalcomp);
uint32_t tzCount = 0;
calITimezone ** timezones = nullptr;
rv = ical->GetReferencedTimezones(&tzCount, &timezones);
NS_ENSURE_SUCCESS(rv, rv);
calIcalComponent * const vcal = getParentVCalendarOrThis();
bool failed = false;
for (uint32_t i = 0; i < tzCount; i++) {
if (!failed) {
rv = vcal->AddTimezoneReference(timezones[i]);
if (NS_FAILED(rv))
failed = true;
}
NS_RELEASE(timezones[i]);
}
free(timezones);
if (failed)
return rv;
if (ical->mParent) {
ical->mComponent = icalcomponent_new_clone(ical->mComponent);
}
ical->mParent = this;
icalcomponent_add_component(mComponent, ical->mComponent);
return NS_OK;
}
NS_IMETHODIMP
calIcalComponent::Clone(calIIcalComponent **_retval)
{
NS_ENSURE_ARG_POINTER(_retval);
icalcomponent * cloned = icalcomponent_new_clone(mComponent);
if (cloned == nullptr)
return NS_ERROR_OUT_OF_MEMORY;
calIcalComponent * const comp = new calIcalComponent(cloned, nullptr, getTzProvider());
if (comp == nullptr) {
icalcomponent_free(cloned);
return NS_ERROR_OUT_OF_MEMORY;
}
NS_ADDREF(*_retval = comp);
return NS_OK;
}
static void
memo_shell_content_cursor_change_cb (EMemoShellContent *memo_shell_content,
gint row,
ETable *table)
{
ECalComponentPreview *memo_preview;
ECalModel *memo_model;
ECalModelComponent *comp_data;
EPreviewPane *preview_pane;
EWebView *web_view;
const gchar *uid;
memo_model = e_memo_shell_content_get_memo_model (memo_shell_content);
preview_pane = e_memo_shell_content_get_preview_pane (memo_shell_content);
web_view = e_preview_pane_get_web_view (preview_pane);
memo_preview = E_CAL_COMPONENT_PREVIEW (web_view);
if (e_table_selected_count (table) != 1) {
if (memo_shell_content->priv->preview_visible)
e_cal_component_preview_clear (memo_preview);
return;
}
row = e_table_get_cursor_row (table);
comp_data = e_cal_model_get_component_at (memo_model, row);
if (memo_shell_content->priv->preview_visible) {
ECalComponent *comp;
comp = e_cal_component_new_from_icalcomponent (
icalcomponent_new_clone (comp_data->icalcomp));
e_cal_component_preview_display (
memo_preview, comp_data->client, comp,
e_cal_model_get_timezone (memo_model),
e_cal_model_get_use_24_hour_format (memo_model));
g_object_unref (comp);
}
uid = icalcomponent_get_uid (comp_data->icalcomp);
g_free (memo_shell_content->priv->current_uid);
memo_shell_content->priv->current_uid = g_strdup (uid);
}
icalcluster * icalcluster_new(const char* key, icalcomponent *data) {
struct icalcluster_impl *impl = icalcluster_new_impl();
assert(impl->data == 0);
impl->key = strdup(key);
impl->changed = 0;
impl->data = 0;
if (data != NULL) {
if (icalcomponent_isa(data) != ICAL_XROOT_COMPONENT) {
impl->data = icalcomponent_new(ICAL_XROOT_COMPONENT);
icalcomponent_add_component(impl->data, data);
} else {
impl->data = icalcomponent_new_clone(data);
}
} else {
impl->data = icalcomponent_new(ICAL_XROOT_COMPONENT);
}
return impl;
}
static icalcomponent *
toplevel_with_zones (SunOneInvitationList *list, ECalComponent *comp)
{
icalcomponent *top_level, *icomp;
icalproperty *prop;
icalvalue *value;
top_level = e_cal_util_new_top_level ();
prop = icalproperty_new (ICAL_METHOD_PROPERTY);
value = icalvalue_new_method (ICAL_METHOD_REQUEST);
icalproperty_set_value (prop, value);
icalcomponent_add_property (top_level, prop);
icomp = e_cal_component_get_icalcomponent (comp);
icomp = icalcomponent_new_clone (icomp);
icalcomponent_add_component (top_level, icomp);
return top_level;
}
static void
action_task_forward_cb (GtkAction *action,
ETaskShellView *task_shell_view)
{
ETaskShellContent *task_shell_content;
EShell *shell;
EShellView *shell_view;
EShellWindow *shell_window;
ESourceRegistry *registry;
ECalModelComponent *comp_data;
ETaskTable *task_table;
ECalComponent *comp;
icalcomponent *clone;
GSList *list;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
shell = e_shell_window_get_shell (shell_window);
registry = e_shell_get_registry (shell);
task_shell_content = task_shell_view->priv->task_shell_content;
task_table = e_task_shell_content_get_task_table (task_shell_content);
list = e_task_table_get_selected (task_table);
g_return_if_fail (list != NULL);
comp_data = list->data;
g_slist_free (list);
/* XXX We only forward the first selected task. */
comp = e_cal_component_new ();
clone = icalcomponent_new_clone (comp_data->icalcomp);
e_cal_component_set_icalcomponent (comp, clone);
itip_send_comp (
registry, E_CAL_COMPONENT_METHOD_PUBLISH, comp,
comp_data->client, NULL, NULL, NULL, TRUE, FALSE);
g_object_unref (comp);
}
static void
print_icomp (icalcomponent *icalcomp)
{
ECalComponent *ecomp;
g_return_if_fail (icalcomp != NULL);
ecomp = e_cal_component_new ();
icalcomp = icalcomponent_new_clone (icalcomp);
if (!e_cal_component_set_icalcomponent (ecomp, icalcomp)) {
icalcomponent_free (icalcomp);
g_object_unref (ecomp);
g_printerr ("%s: Failed to assing icalcomp to ECalComponent\n", G_STRFUNC);
g_print ("\n");
return;
}
print_ecomp (ecomp);
g_object_unref (ecomp);
}
static void
memo_shell_content_table_foreach_cb (gint model_row,
gpointer user_data)
{
ECalModelComponent *comp_data;
icalcomponent *clone;
icalcomponent *vcal;
gchar *string;
struct {
ECalModel *model;
GSList *list;
} *foreach_data = user_data;
comp_data = e_cal_model_get_component_at (
foreach_data->model, model_row);
vcal = e_cal_util_new_top_level ();
clone = icalcomponent_new_clone (comp_data->icalcomp);
e_cal_util_add_timezones_from_component (vcal, comp_data->icalcomp);
icalcomponent_add_component (vcal, clone);
/* String is owned by libical; do not free. */
string = icalcomponent_as_ical_string (vcal);
if (string != NULL) {
ESource *source;
const gchar *source_uid;
source = e_client_get_source (E_CLIENT (comp_data->client));
source_uid = e_source_get_uid (source);
foreach_data->list = g_slist_prepend (
foreach_data->list,
g_strdup_printf ("%s\n%s", source_uid, string));
}
icalcomponent_free (vcal);
}
/** Get all timezones from the cache.
*
* @param cb 3E calendar backend.
* @param cache Calendar backend cache object.
*
* @return List of icaltimezone objects (free them using icaltimezone_free(x, 1);).
*/
static GSList *e_cal_backend_cache_get_timezones(ECalBackend3e *cb, ECalBackendCache *cache)
{
GSList *keys, *iter;
GSList *list = NULL;
g_return_val_if_fail(E_IS_CAL_BACKEND_CACHE(cache), NULL);
keys = e_file_cache_get_keys(E_FILE_CACHE(cache));
for (iter = keys; iter; iter = iter->next)
{
char *key = iter->data;
const icaltimezone *zone;
g_static_rw_lock_reader_lock(&cb->priv->cache_lock);
zone = e_cal_backend_cache_get_timezone(cache, key);
g_static_rw_lock_reader_unlock(&cb->priv->cache_lock);
if (zone)
{
icalcomponent *zone_comp = icaltimezone_get_component((icaltimezone *)zone);
icaltimezone *new_zone = icaltimezone_new();
/* make sure you have patched eds if you get segfaults here */
if (zone_comp == NULL)
{
g_critical("Patch your evolution-data-server or else...");
}
icaltimezone_set_component(new_zone, icalcomponent_new_clone(zone_comp));
list = g_slist_prepend(list, new_zone);
}
}
/* eds patch required here! */
g_slist_free(keys);
return list;
}
/** Sync changes from the server to the cache.
*
* @param cb 3E calendar backend.
*
* @return TRUE on success.
*
* @todo Handle UID/RID.
* @todo Better server error handling.
* @todo Conflict resolution.
*/
gboolean e_cal_backend_3e_sync_server_to_cache(ECalBackend3e *cb)
{
GError *local_err = NULL;
gboolean update_sync = TRUE;
icalcomponent *ical;
icalcomponent *icomp;
char filter[128];
struct tm tm;
time_t stamp = MAX(e_cal_backend_3e_get_sync_timestamp(cb) - 60 * 60 * 24, 0); /*XXX: always add 1 day padding to prevent timezone problems */
/* prepare query filter string */
gmtime_r(&stamp, &tm);
strftime(filter, sizeof(filter), "modified_since('%F %T')", &tm);
ical = get_server_objects(cb, filter);
if (ical == NULL)
{
return FALSE;
}
for (icomp = icalcomponent_get_first_component(ical, ICAL_ANY_COMPONENT);
icomp;
icomp = icalcomponent_get_next_component(ical, ICAL_ANY_COMPONENT))
{
icalcomponent_kind kind = icalcomponent_isa(icomp);
icalcomponent_set_cache_state(icomp, E_CAL_COMPONENT_CACHE_STATE_NONE);
if (kind == ICAL_VEVENT_COMPONENT)
{
ECalComponent *comp;
const char *uid = icalcomponent_get_uid(icomp);
gboolean server_deleted = icalcomponent_3e_status_is_deleted(icomp);
ECalComponentCacheState comp_state = E_CAL_COMPONENT_CACHE_STATE_NONE;
g_static_rw_lock_reader_lock(&cb->priv->cache_lock);
comp = e_cal_backend_cache_get_component(cb->priv->cache, uid, NULL);
g_static_rw_lock_reader_unlock(&cb->priv->cache_lock);
if (comp)
{
comp_state = e_cal_component_get_cache_state(comp);
}
if (server_deleted)
{
/* deleted by the server */
if (comp && e_cal_component_get_cache_state(comp) != E_CAL_COMPONENT_CACHE_STATE_CREATED &&
e_cal_component_get_cache_state(comp) != E_CAL_COMPONENT_CACHE_STATE_MODIFIED)
{
char *object = e_cal_component_get_as_string(comp);
ECalComponentId *id = e_cal_component_get_id(comp);
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_remove_component(cb->priv->cache, uid, NULL);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
e_cal_backend_notify_object_removed(E_CAL_BACKEND(cb), id, object, NULL);
e_cal_component_free_id(id);
g_free(object);
}
}
else
{
char *old_object = NULL;
char *object;
ECalComponent *new_comp = e_cal_component_new();
e_cal_component_set_icalcomponent(new_comp, icalcomponent_new_clone(icomp));
e_cal_component_set_cache_state(new_comp, E_CAL_COMPONENT_CACHE_STATE_NONE);
e_cal_backend_3e_convert_attachment_uris_to_local(cb, new_comp);
if (comp)
{
old_object = e_cal_component_get_as_string(comp);
}
object = e_cal_component_get_as_string(new_comp);
if (old_object == NULL)
{
if (e_cal_backend_3e_download_attachments(cb, new_comp, &local_err))
{
/* not in cache yet */
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_put_component(cb->priv->cache, new_comp);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
e_cal_backend_notify_object_created(E_CAL_BACKEND(cb), object);
}
else
{
e_cal_backend_notify_gerror_error(E_CAL_BACKEND(cb), "Can't download attachment.", local_err);
g_clear_error(&local_err);
update_sync = FALSE;
}
}
else if (strcmp(old_object, object))
{
/* what is in cache and what is on server differs */
if (comp_state != E_CAL_COMPONENT_CACHE_STATE_NONE)
{
/* modified in cache, don't do anything */
}
else
{
if (e_cal_backend_3e_download_attachments(cb, new_comp, &local_err))
{
/* sync with server */
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_put_component(cb->priv->cache, new_comp);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
e_cal_backend_notify_object_modified(E_CAL_BACKEND(cb), old_object, object);
}
else
{
e_cal_backend_notify_gerror_error(E_CAL_BACKEND(cb), "Can't download attachment.", local_err);
g_clear_error(&local_err);
update_sync = FALSE;
}
}
}
g_free(old_object);
g_free(object);
g_object_unref(new_comp);
}
if (comp)
{
g_object_unref(comp);
}
}
else if (kind == ICAL_VTIMEZONE_COMPONENT)
{
const char *tzid = icalcomponent_get_tzid(icomp);
/* import non-existing timezones from the server */
if (!e_cal_backend_cache_get_timezone(cb->priv->cache, tzid))
{
icaltimezone *zone = icaltimezone_new();
icalcomponent *zone_comp = icalcomponent_new_clone(icomp);
if (icaltimezone_set_component(zone, zone_comp))
{
g_static_rw_lock_writer_lock(&cb->priv->cache_lock);
e_cal_backend_cache_put_timezone(cb->priv->cache, zone);
g_static_rw_lock_writer_unlock(&cb->priv->cache_lock);
}
else
{
icalcomponent_free(zone_comp);
}
icaltimezone_free(zone, 1);
}
}
else
{
g_warning("Unsupported component kind (%d) found on the 3e server.", kind);
}
}
if (update_sync)
{
e_cal_backend_3e_set_sync_timestamp(cb, time(NULL));
}
icalcomponent_free(ical);
return TRUE;
}
/**
* e_cal_util_split_at_instance:
* @icalcomp: A (recurring) #icalcomponent
* @rid: The base RECURRENCE-ID to remove
* @master_dtstart: The DTSTART of the master object
*
* Splits a recurring @icalcomp into two at time @rid. The returned icalcomponent
* is modified @icalcomp which contains recurrences beginning at @rid, inclusive.
* The instance identified by @rid should exist. The @master_dtstart can be
* a null time, then it is read from the @icalcomp.
*
* Use e_cal_util_remove_instances() with E_CAL_OBJ_MOD_THIS_AND_FUTURE mode
* on the @icalcomp to remove the overlapping interval from it, if needed.
*
* Returns: the split icalcomponent, or %NULL.
*
* Since: 3.16
**/
icalcomponent *
e_cal_util_split_at_instance (icalcomponent *icalcomp,
struct icaltimetype rid,
struct icaltimetype master_dtstart)
{
icalproperty *prop;
struct instance_data instance;
struct icaltimetype start, end;
struct icaldurationtype duration;
GSList *remove_props = NULL, *link;
g_return_val_if_fail (icalcomp != NULL, NULL);
g_return_val_if_fail (!icaltime_is_null_time (rid), NULL);
/* Make sure this is really recurring */
if (!icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY) &&
!icalcomponent_get_first_property (icalcomp, ICAL_RDATE_PROPERTY))
return NULL;
/* Make sure the specified instance really exists */
start = icaltime_convert_to_zone (rid, icaltimezone_get_utc_timezone ());
end = start;
icaltime_adjust (&end, 0, 0, 0, 1);
instance.start = icaltime_as_timet (start);
instance.found = FALSE;
icalcomponent_foreach_recurrence (icalcomp, start, end,
check_instance, &instance);
/* Make the copy */
icalcomp = icalcomponent_new_clone (icalcomp);
e_cal_util_remove_instances_ex (icalcomp, rid, E_CAL_OBJ_MOD_THIS_AND_PRIOR, TRUE, FALSE);
start = rid;
if (icaltime_is_null_time (master_dtstart))
master_dtstart = icalcomponent_get_dtstart (icalcomp);
duration = icalcomponent_get_duration (icalcomp);
/* Expect that DTSTART and DTEND are already set when the instance could not be found */
if (instance.found) {
icalcomponent_set_dtstart (icalcomp, start);
/* Update either DURATION or DTEND */
if (icaltime_is_null_time (icalcomponent_get_dtend (icalcomp))) {
icalcomponent_set_duration (icalcomp, duration);
} else {
end = start;
if (duration.is_neg)
icaltime_adjust (&end, -duration.days - 7 * duration.weeks, -duration.hours, -duration.minutes, -duration.seconds);
else
icaltime_adjust (&end, duration.days + 7 * duration.weeks, duration.hours, duration.minutes, duration.seconds);
icalcomponent_set_dtend (icalcomp, end);
}
}
/* any RRULE with 'count' should be shortened */
for (prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY);
prop;
prop = icalcomponent_get_next_property (icalcomp, ICAL_RRULE_PROPERTY)) {
struct icaltimetype recur;
struct icalrecurrencetype rule;
rule = icalproperty_get_rrule (prop);
if (rule.count != 0) {
gint occurrences_count = 0;
icalrecur_iterator *iter;
iter = icalrecur_iterator_new (rule, master_dtstart);
while (recur = icalrecur_iterator_next (iter), !icaltime_is_null_time (recur) && occurrences_count < rule.count) {
if (icaltime_compare (recur, rid) >= 0)
break;
occurrences_count++;
}
icalrecur_iterator_free (iter);
if (icaltime_is_null_time (recur)) {
remove_props = g_slist_prepend (remove_props, prop);
} else {
rule.count -= occurrences_count;
icalproperty_set_rrule (prop, rule);
icalproperty_remove_parameter_by_name (prop, "X-EVOLUTION-ENDDATE");
}
}
}
for (link = remove_props; link; link = g_slist_next (link)) {
prop = link->data;
icalcomponent_remove_property (icalcomp, prop);
}
g_slist_free (remove_props);
return icalcomp;
}
