static void test_remove_object (ETestServerFixture *fixture, gconstpointer user_data) { ECal *cal; icalcomponent *component; icalcomponent *component_final; gchar *uid; cal = E_TEST_SERVER_UTILS_SERVICE (fixture, ECal); component = icalcomponent_new (ICAL_VEVENT_COMPONENT); uid = ecal_test_utils_cal_create_object (cal, component); /* FIXME: In the same way test-ecal-create-object.c, * this part of the test is broken, need to fix this. */ component_final = ecal_test_utils_cal_get_object (cal, uid); /* ecal_test_utils_cal_assert_objects_equal_shallow (component, component_final); */ ecal_test_utils_cal_remove_object (cal, uid); g_free (uid); icalcomponent_free (component); icalcomponent_free (component_final); }
gint main (gint argc, gchar **argv) { ECalClient *cal_client; GError *error = NULL; icalcomponent *icalcomp; struct icaltimetype now; gchar *uid = NULL; main_initialize (); cal_client = new_temp_client (E_CAL_CLIENT_SOURCE_TYPE_EVENTS, NULL); g_return_val_if_fail (cal_client != NULL, FALSE); if (!e_client_open_sync (E_CLIENT (cal_client), FALSE, NULL, &error)) { report_error ("client open sync", &error); g_object_unref (cal_client); return 1; } now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "Test event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0)); if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error)) { report_error ("create object sync", &error); icalcomponent_free (icalcomp); g_object_unref (cal_client); return 1; } icalcomponent_free (icalcomp); g_free (uid); /* synchronously without main-loop */ if (!test_sync (cal_client)) { g_object_unref (cal_client); return 1; } start_in_thread_with_main_loop (test_sync_in_thread, cal_client); if (!e_client_remove_sync (E_CLIENT (cal_client), NULL, &error)) { report_error ("client remove sync", &error); g_object_unref (cal_client); return 1; } g_object_unref (cal_client); if (get_main_loop_stop_result () == 0) g_print ("Test finished successfully.\n"); return get_main_loop_stop_result (); }
gint main (gint argc, gchar **argv) { ECal *cal; gchar *uri = NULL; ECalComponent *e_component; ECalComponent *e_component_final; icalcomponent *component; icalcomponent *component_final; struct icaltimetype icaltime; gchar *uid; g_type_init (); cal = ecal_test_utils_cal_new_temp (&uri, E_CAL_SOURCE_TYPE_EVENT); ecal_test_utils_cal_open (cal, FALSE); ecal_test_utils_create_component (cal, INITIAL_BEGIN_TIME, INITIAL_BEGIN_TIMEZONE, INITIAL_END_TIME, INITIAL_END_TIMEZONE, EVENT_SUMMARY, &e_component, &uid); component = e_cal_component_get_icalcomponent (e_component); component_final = ecal_test_utils_cal_get_object (cal, uid); ecal_test_utils_cal_assert_objects_equal_shallow (component, component_final); icalcomponent_free (component_final); /* make and commit changes */ icaltime = icaltime_from_string (FINAL_BEGIN_TIME); icalcomponent_set_dtstart (component, icaltime); ecal_test_utils_cal_component_set_icalcomponent (e_component, component); ecal_test_utils_cal_modify_object (cal, component, CALOBJ_MOD_ALL); /* verify */ component_final = ecal_test_utils_cal_get_object (cal, uid); e_component_final = e_cal_component_new (); ecal_test_utils_cal_component_set_icalcomponent (e_component_final, component_final); ecal_test_utils_cal_assert_e_cal_components_equal (e_component, e_component_final); /* Clean-up */ ecal_test_utils_cal_remove (cal); g_object_unref (e_component_final); g_free (uid); icalcomponent_free (component); return 0; }
static gboolean deserialize (ScalixObject * object, const char *string) { ScalixAppointmentPrivate *priv; icalcomponent *icomp, *subcomp; icalcomponent_kind kind; icaltimezone *zone; priv = SCALIX_APPOINTMENT_GET_PRIVATE (SCALIX_APPOINTMENT (object)); icomp = icalparser_parse_string (string); if (icalcomponent_isa (icomp) != ICAL_VCALENDAR_COMPONENT) { g_warning ("No VCALENAR while deserializing! (%s)\n", string); icalcomponent_free (icomp); return FALSE; } /* Grab the timezone if any */ subcomp = icalcomponent_get_first_component (icomp, ICAL_VTIMEZONE_COMPONENT); if (subcomp != NULL) { zone = icaltimezone_new (); icalcomponent_remove_component (icomp, subcomp); if (icaltimezone_set_component (zone, subcomp)) priv->timezone = zone; } kind = ICAL_VEVENT_COMPONENT; /* Grab the main VEVENT */ subcomp = icalcomponent_get_first_component (icomp, kind); if (subcomp == NULL) { icalcomponent_free (icomp); return FALSE; } icalcomponent_remove_component (icomp, subcomp); e_cal_component_set_icalcomponent (E_CAL_COMPONENT (object), subcomp); e_cal_component_commit_sequence (E_CAL_COMPONENT (object)); priv->exceptions = NULL; while ((subcomp = icalcomponent_get_next_component (icomp, kind))) { icalcomponent_remove_component (icomp, subcomp); priv->exceptions = g_slist_prepend (priv->exceptions, subcomp); } icalcomponent_free (icomp); return TRUE; }
/* Get_free_busy handler for the file backend */ static void e_cal_backend_http_get_free_busy (ECalBackendSync *backend, EDataCal *cal, GCancellable *cancellable, const GSList *users, time_t start, time_t end, GSList **freebusy, GError **error) { ESourceRegistry *registry; ECalBackendHttp *cbhttp; ECalBackendHttpPrivate *priv; gchar *address, *name; icalcomponent *vfb; gchar *calobj; cbhttp = E_CAL_BACKEND_HTTP (backend); priv = cbhttp->priv; if (!priv->store) { g_propagate_error (error, EDC_ERROR (NoSuchCal)); return; } registry = e_cal_backend_get_registry (E_CAL_BACKEND (backend)); if (users == NULL) { if (e_cal_backend_mail_account_get_default (registry, &address, &name)) { vfb = create_user_free_busy (cbhttp, address, name, start, end); calobj = icalcomponent_as_ical_string_r (vfb); *freebusy = g_slist_append (*freebusy, calobj); icalcomponent_free (vfb); g_free (address); g_free (name); } } else { const GSList *l; for (l = users; l != NULL; l = l->next ) { address = l->data; if (e_cal_backend_mail_account_is_valid (registry, address, &name)) { vfb = create_user_free_busy (cbhttp, address, name, start, end); calobj = icalcomponent_as_ical_string_r (vfb); *freebusy = g_slist_append (*freebusy, calobj); icalcomponent_free (vfb); g_free (name); } } } }
/** * 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; }
void icalparser_free(icalparser *parser) { icalcomponent *c; if (parser->root_component != 0) { icalcomponent_free(parser->root_component); } while ((c = pvl_pop(parser->components)) != 0) { icalcomponent_free(c); } pvl_free(parser->components); free(parser); }
static GtkWidget * vcal_get_preview (EImport *ei, EImportTarget *target, EImportImporter *im) { GtkWidget *preview; EImportTargetURI *s = (EImportTargetURI *) target; gchar *filename; icalcomponent *icalcomp; filename = g_filename_from_uri (s->uri_src, NULL, NULL); if (filename == NULL) { g_message (G_STRLOC ": Couldn't get filename from URI '%s'", s->uri_src); return NULL; } icalcomp = load_vcalendar_file (filename); g_free (filename); if (!icalcomp) return NULL; preview = ical_get_preview (icalcomp); icalcomponent_free (icalcomp); return preview; }
NS_IMETHODIMP calICSService::ParseICS(const nsACString& serialized, calITimezoneProvider *tzProvider, calIIcalComponent **component) { NS_ENSURE_ARG_POINTER(component); icalcomponent *ical = icalparser_parse_string(PromiseFlatCString(serialized).get()); if (!ical) { #ifdef DEBUG fprintf(stderr, "Error parsing: '%20s': %d (%s)\n", PromiseFlatCString(serialized).get(), icalerrno, icalerror_strerror(icalerrno)); #endif // The return values is calIError match with ical errors, // so no need for a conversion table or anything. return static_cast<nsresult>(calIErrors::ICS_ERROR_BASE + icalerrno); } calIcalComponent *comp = new calIcalComponent(ical, nullptr, tzProvider); if (!comp) { icalcomponent_free(ical); return NS_ERROR_OUT_OF_MEMORY; } NS_ADDREF(*component = comp); return NS_OK; }
GNOKII_API int gn_icalstr2todo(const char * ical, gn_todo *ctodo, int id) { #ifdef HAVE_LIBICAL icalparser *parser = NULL; icalcomponent *comp = NULL; gn_error error; parser = icalparser_new(); if (!parser) { return GN_ERR_FAILED; } comp = icalparser_parse_string (ical); if (!comp) { icalparser_free(parser); return GN_ERR_FAILED; } error = gn_ical2todo_real(comp, ctodo, id); icalcomponent_free(comp); icalparser_free(parser); return error; #else return GN_ERR_NOTIMPLEMENTED; #endif /* HAVE_LIBICAL */ }
/** Loads the builtin VTIMEZONE data for the given timezone. */ static void icaltimezone_load_builtin_timezone (icaltimezone *zone) { char *filename; unsigned int filename_len; FILE *fp; icalparser *parser; icalcomponent *comp, *subcomp; /* If the location isn't set, it isn't a builtin timezone. */ if (!zone->location || !zone->location[0]) return; filename_len = strlen (get_zone_directory()) + strlen (zone->location) + 6; filename = (char*) malloc (filename_len); if (!filename) { icalerror_set_errno(ICAL_NEWFAILED_ERROR); return; } snprintf (filename, filename_len, "%s/%s.ics", get_zone_directory(), zone->location); fp = fopen (filename, "r"); free (filename); if (!fp) { icalerror_set_errno(ICAL_FILE_ERROR); return; } /* ##### B.# Sun, 11 Nov 2001 04:04:29 +1100 this is where the MALFORMEDDATA error is being set, after the call to 'icalparser_parse' fprintf(stderr, "** WARNING ** %s: %d %s\n", __FILE__, __LINE__, icalerror_strerror(icalerrno)); */ parser = icalparser_new (); icalparser_set_gen_data (parser, fp); comp = icalparser_parse (parser, icaltimezone_load_get_line_fn); icalparser_free (parser); fclose (fp); /* Find the VTIMEZONE component inside the VCALENDAR. There should be 1. */ subcomp = icalcomponent_get_first_component (comp, ICAL_VTIMEZONE_COMPONENT); if (!subcomp) { icalerror_set_errno(ICAL_PARSE_ERROR); return; } icaltimezone_get_vtimezone_properties (zone, subcomp); icalcomponent_remove_component(comp,subcomp); icalcomponent_free(comp); }
/* read a vcalendar event given by id from file f and store the data in calnote */ GNOKII_API gn_error gn_ical2calnote(FILE *f, gn_calnote *calnote, int id) { #ifdef HAVE_LIBICAL icalparser *parser = NULL; icalcomponent *comp = NULL; gn_error retval; parser = icalparser_new(); if (!parser) { return GN_ERR_FAILED; } icalparser_set_gen_data(parser, f); comp = icalparser_parse(parser, ical_fgets); if (!comp) { icalparser_free(parser); return GN_ERR_FAILED; } retval = gn_ical2calnote_real(comp, calnote, id); icalcomponent_free(comp); icalparser_free(parser); return retval; #else return GN_ERR_NOTIMPLEMENTED; #endif /* HAVE_LIBICAL */ }
/* Add_timezone handler for the file backend */ static void e_cal_backend_http_add_timezone (ECalBackendSync *backend, EDataCal *cal, GCancellable *cancellable, const gchar *tzobj, GError **error) { ETimezoneCache *timezone_cache; icalcomponent *tz_comp; icaltimezone *zone; timezone_cache = E_TIMEZONE_CACHE (backend); tz_comp = icalparser_parse_string (tzobj); if (!tz_comp) { g_propagate_error (error, EDC_ERROR (InvalidObject)); return; } if (icalcomponent_isa (tz_comp) != ICAL_VTIMEZONE_COMPONENT) { icalcomponent_free (tz_comp); g_propagate_error (error, EDC_ERROR (InvalidObject)); return; } zone = icaltimezone_new (); icaltimezone_set_component (zone, tz_comp); e_timezone_cache_add_timezone (timezone_cache, zone); }
static void ical_import_done(ICalImporterData *icidata) { g_object_unref (icidata->client); icalcomponent_free (icidata->icalcomp); g_free (icidata); }
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; }
/* This removes all components except VTODOs and VTIMEZONEs from the toplevel icalcomponent, and adds the given list of VTODO components. The list is freed afterwards. */ static void prepare_tasks (icalcomponent *icalcomp, GList *vtodos) { icalcomponent *subcomp; GList *elem; icalcompiter iter; iter = icalcomponent_begin_component (icalcomp, ICAL_ANY_COMPONENT); while ((subcomp = icalcompiter_deref (&iter)) != NULL) { icalcomponent_kind child_kind = icalcomponent_isa (subcomp); if (child_kind != ICAL_VTODO_COMPONENT && child_kind != ICAL_VTIMEZONE_COMPONENT) { icalcompiter_next (&iter); icalcomponent_remove_component (icalcomp, subcomp); icalcomponent_free (subcomp); } else { icalcompiter_next (&iter); } } for (elem = vtodos; elem; elem = elem->next) { icalcomponent_add_component (icalcomp, elem->data); } g_list_free (vtodos); }
/* This removes all components except VEVENTs and VTIMEZONEs from the toplevel */ static void prepare_events (icalcomponent *icalcomp, GList **vtodos) { icalcomponent *subcomp; icalcompiter iter; if (vtodos) *vtodos = NULL; iter = icalcomponent_begin_component (icalcomp, ICAL_ANY_COMPONENT); while ((subcomp = icalcompiter_deref (&iter)) != NULL) { icalcomponent_kind child_kind = icalcomponent_isa (subcomp); if (child_kind != ICAL_VEVENT_COMPONENT && child_kind != ICAL_VTIMEZONE_COMPONENT) { icalcompiter_next (&iter); icalcomponent_remove_component (icalcomp, subcomp); if (child_kind == ICAL_VTODO_COMPONENT && vtodos) *vtodos = g_list_prepend (*vtodos, subcomp); else icalcomponent_free (subcomp); } else { icalcompiter_next (&iter); } } }
icalcomponent * icalcap_component_new_from_string(const char *data) { icalcomponent *ret = NULL; char *mtype; /* FIXME split the check */ if (strncmp(data, CONTENT_TYPE, strlen(CONTENT_TYPE))) { return NULL; } mtype = (char *)data+strlen(CONTENT_TYPE); ret = icalcomponent_new_from_string(mtype); if (ret == NULL) { return NULL; } #ifdef DEBUG g_message("icalcap_component_new_from_string icalcomponent_new_from_string = %p", ret); #endif /* FIXME * Validate here: should check at least the version */ if (icalcomponent_isa(ret) != ICAL_VCALENDAR_COMPONENT && icalcomponent_isa(ret) != ICAL_XROOT_COMPONENT) { icalcomponent_free(ret); return NULL; } return ret; }
static PyObject * cal_JsonToIcal(PyObject *self, PyObject *args) { JsonObject *a; BongoCalObject *cal; icalcomponent *comp; if (!PyArg_ParseTuple(args, "O", &a)) { PyErr_SetString(PyExc_TypeError, "JsonToIcal() takes 2 arguments"); return NULL; } cal = BongoCalObjectNew(a->obj); BongoCalObjectResolveSystemTimezones(cal); BongoCalObjectFree(cal, FALSE); comp = BongoCalJsonToIcal(a->obj); if (comp) { PyObject *ret; char *data = icalcomponent_as_ical_string(comp); ret = PyUnicode_Decode(data, strlen(data), "utf-8", "strict"); icalcomponent_free(comp); return ret; } else { PyErr_SetString(PyExc_ValueError, "Couldn't convert json object"); return NULL; } }
/* read the entry identified by id from the vcal file f and write it to the phone */ static int gn_ical2todo_real(icalcomponent *comp, gn_todo *ctodo, int id) { icalcomponent *compresult = NULL; if (id < 1) id = 1; /* iterate through the component */ iterate_cal(comp, 0, &id, &compresult, ICAL_VTODO_COMPONENT); if (!compresult) { dprintf("No component found.\n"); return GN_ERR_EMPTYLOCATION; } else { icalproperty *priority = icalcomponent_get_first_property(compresult, ICAL_PRIORITY_PROPERTY); /* summary goes into text */ /* TODO: UTF8 --> ascii */ snprintf(ctodo->text, GN_TODO_MAX_LENGTH-1, "%s", icalcomponent_get_summary(compresult)); /* priority */ ctodo->priority = icalproperty_get_priority((const icalproperty *)priority); dprintf("Component found\n%s\n", icalcomponent_as_ical_string(compresult)); } icalcomponent_free(compresult); return GN_ERR_NONE; }
/* read a vcalendar event given by id from string ical and store the data in calnote */ GNOKII_API gn_error gn_icalstr2calnote(const char * ical, gn_calnote *calnote, int id) { #ifdef HAVE_LIBICAL icalparser *parser = NULL; icalcomponent *comp = NULL; gn_error retval; parser = icalparser_new(); if (!parser) { return GN_ERR_FAILED; } comp = icalparser_parse_string (ical); if (!comp) { icalparser_free(parser); return GN_ERR_FAILED; } retval = gn_ical2calnote_real(comp, calnote, id); icalcomponent_free(comp); icalparser_free(parser); return retval; #else return GN_ERR_NOTIMPLEMENTED; #endif /* HAVE_LIBICAL */ }
static gboolean manage_result (GSList *users, icalcomponent *modified_icalcomp) { g_print ("Wishes to send to %d users", g_slist_length (users)); if (users) { GSList *u; g_print (": "); for (u = users; u; u = u->next) g_print ("%s%s", u == users ? "" : ", ", (const gchar *) u->data); } g_print ("\n"); if (!modified_icalcomp) g_print ("No modified icalcomp, would send the same\n"); else print_icomp (modified_icalcomp); e_client_util_free_string_slist (users); if (modified_icalcomp) icalcomponent_free (modified_icalcomp); return TRUE; }
GNOKII_API int gn_ical2todo(FILE *f, gn_todo *ctodo, int id) { #ifdef HAVE_LIBICAL icalparser *parser = NULL; icalcomponent *comp = NULL; gn_error error; parser = icalparser_new(); if (!parser) { return GN_ERR_FAILED; } icalparser_set_gen_data(parser, f); comp = icalparser_parse(parser, ical_fgets); if (!comp) { icalparser_free(parser); return GN_ERR_FAILED; } error = gn_ical2todo_real(comp, ctodo, id); icalcomponent_free(comp); icalparser_free(parser); return error; #else return GN_ERR_NOTIMPLEMENTED; #endif /* HAVE_LIBICAL */ }
/* synchronously in idle with main-loop running */ static gboolean test_sync_in_idle (gpointer user_data) { ECalClient *cal_client = user_data; icalcomponent *icalcomp; g_return_val_if_fail (cal_client != NULL, FALSE); g_return_val_if_fail (E_IS_CAL_CLIENT (cal_client), FALSE); if (!test_sync (cal_client)) { stop_main_loop (1); return FALSE; } icalcomp = create_object (); if (!icalcomp) { stop_main_loop (1); return FALSE; } e_cal_client_send_objects (cal_client, icalcomp, NULL, async_send_result_ready, NULL); icalcomponent_free (icalcomp); return FALSE; }
/* XXX add more to this */ void icalbdbset_free(icalset *set) { icalbdbset *bset = (icalbdbset *) set; int ret; icalerror_check_arg_rv((bset != 0), "bset"); if (bset->cluster != 0) { (void)icalbdbset_commit(set); icalcomponent_free(bset->cluster); bset->cluster = 0; } if (bset->gauge != 0) { icalgauge_free(bset->gauge); } if (bset->path != 0) { free((char *)bset->path); bset->path = 0; } if (bset->sindex != 0) { free((char *)bset->sindex); bset->sindex = 0; } if (bset->dbp && ((ret = bset->dbp->close(bset->dbp, 0)) != 0)) { } bset->dbp = NULL; }
void create_simple_component(void) { icalcomponent* calendar; icalproperty *version, *bogus; /* Create calendar and add properties */ calendar = icalcomponent_new(ICAL_VCALENDAR_COMPONENT); ok("create vcalendar component", (calendar!=NULL)); icalcomponent_add_property( calendar, icalproperty_new_version("2.0") ); version = icalcomponent_get_first_property(calendar,ICAL_VERSION_PROPERTY); ok("version property added", (version!=NULL)); bogus = icalcomponent_get_first_property(calendar,ICAL_DTSTART_PROPERTY); ok("bogus dtstart not found", (bogus == NULL)); if (VERBOSE && calendar) printf("%s\n",icalcomponent_as_ical_string(calendar)); icalcomponent_free(calendar); }
NS_IMETHODIMP calICSService::ParserWorker::Run() { icalcomponent *ical = icalparser_parse_string(PromiseFlatCString(mString).get()); nsresult status = NS_OK; calIIcalComponent *comp = nullptr; if (ical) { comp = new calIcalComponent(ical, nullptr, mProvider); if (!comp) { icalcomponent_free(ical); status = NS_ERROR_OUT_OF_MEMORY; } } else { status = static_cast<nsresult>(calIErrors::ICS_ERROR_BASE + icalerrno); } nsCOMPtr<nsIRunnable> completer = new ParserWorkerCompleter(mWorkerThread, status, comp, mListener); mMainThread->Dispatch(completer, NS_DISPATCH_NORMAL); mWorkerThread = nullptr; mMainThread = nullptr; return NS_OK; }
static void local_record_from_uid (EMemoLocalRecord *local, const char *uid, EMemoConduitContext *ctxt) { ECalComponent *comp; icalcomponent *icalcomp; GError *error = NULL; g_assert(local!=NULL); LOG(g_message("local_record_from_uid\n")); if (e_cal_get_object (ctxt->client, uid, NULL, &icalcomp, &error)) { comp = e_cal_component_new (); if (!e_cal_component_set_icalcomponent (comp, icalcomp)) { g_object_unref (comp); icalcomponent_free (icalcomp); return; } local_record_from_comp (local, comp, ctxt); g_object_unref (comp); } else if (error->code == E_CALENDAR_STATUS_OBJECT_NOT_FOUND) { comp = e_cal_component_new (); e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_JOURNAL); e_cal_component_set_uid (comp, uid); local_record_from_comp (local, comp, ctxt); g_object_unref (comp); } else { INFO ("Object did not exist"); } g_clear_error (&error); }
static gpointer alter_cal_client (gpointer user_data) { ECalClient *cal_client = user_data; GError *error = NULL; icalcomponent *icalcomp; struct icaltimetype now; gchar *uid = NULL; g_return_val_if_fail (cal_client != NULL, NULL); now = icaltime_current_time_with_zone (icaltimezone_get_utc_timezone ()); icalcomp = icalcomponent_new (ICAL_VEVENT_COMPONENT); icalcomponent_set_summary (icalcomp, "Initial event summary"); icalcomponent_set_dtstart (icalcomp, now); icalcomponent_set_dtend (icalcomp, icaltime_from_timet (icaltime_as_timet (now) + 60 * 60 * 60, 0)); if (!e_cal_client_create_object_sync (cal_client, icalcomp, &uid, NULL, &error)) g_error ("create object sync: %s", error->message); icalcomponent_set_uid (icalcomp, uid); icalcomponent_set_summary (icalcomp, "Modified event summary"); if (!e_cal_client_modify_object_sync (cal_client, icalcomp, CALOBJ_MOD_ALL, NULL, &error)) g_error ("modify object sync: %s", error->message); if (!e_cal_client_remove_object_sync (cal_client, uid, NULL, CALOBJ_MOD_ALL, NULL, &error)) g_error ("remove object sync: %s", error->message); g_free (uid); icalcomponent_free (icalcomp); return FALSE; }
static GtkWidget * ivcal_get_preview (EImport *ei, EImportTarget *target, EImportImporter *im) { GtkWidget *preview; EImportTargetURI *s = (EImportTargetURI *) target; gchar *filename; icalcomponent *icalcomp; gchar *contents; filename = g_filename_from_uri (s->uri_src, NULL, NULL); if (filename == NULL) { g_message (G_STRLOC ": Couldn't get filename from URI '%s'", s->uri_src); return NULL; } if (!g_file_get_contents (filename, &contents, NULL, NULL)) { g_free (filename); return NULL; } g_free (filename); icalcomp = e_cal_util_parse_ics_string (contents); g_free (contents); if (!icalcomp) return NULL; preview = ical_get_preview (icalcomp); icalcomponent_free (icalcomp); return preview; }