struct icalperiodtype icalperiodtype_from_string (const char* str)
{
struct icalperiodtype p, null_p;
char *s = icalmemory_strdup(str);
char *start, *end = s;
icalerrorstate es;
/* Errors are normally generated in the following code, so save
the error state for resoration later */
icalerrorenum e = icalerrno;
p.start = p.end = icaltime_null_time();
p.duration = icaldurationtype_from_int(0);
null_p = p;
if(s == 0) goto error;
start = s;
end = strchr(s, '/');
if(end == 0) goto error;
*end = 0;
end++;
p.start = icaltime_from_string(start);
if (icaltime_is_null_time(p.start)) goto error;
es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
p.end = icaltime_from_string(end);
icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
if (icaltime_is_null_time(p.end)) {
p.duration = icaldurationtype_from_string(end);
if(icaldurationtype_as_int(p.duration) == 0) goto error;
}
icalerrno = e;
icalmemory_free_buffer(s);
return p;
error:
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
if (s)
icalmemory_free_buffer (s);
return null_p;
}
struct icaltriggertype icaltriggertype_from_string(const char* str)
{
struct icaltriggertype tr, null_tr;
int old_ieaf = icalerror_errors_are_fatal;
tr.time= icaltime_null_time();
tr.duration = icaldurationtype_from_int(0);
null_tr = tr;
if(str == 0) goto error;
icalerror_errors_are_fatal = 0;
tr.time = icaltime_from_string(str);
icalerror_errors_are_fatal = old_ieaf;
if (icaltime_is_null_time(tr.time)){
tr.duration = icaldurationtype_from_string(str);
if(icaldurationtype_as_int(tr.duration) == 0) goto error;
}
return tr;
error:
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return null_tr;
}
int main(int argc, char *argv[]) {
struct icalrecurrencetype recur;
icalrecur_iterator *ritr;
struct icaltimetype dtstart, next;
char *icr = "FREQ=WEEKLY;INTERVAL=2;COUNT=6;BYDAY=WE,SA,SU";
char *dtstr = "20081217T133000";
int howmany = 1;
if (argc > 0) {
icr = argv[1];
}
if (argc > 1) {
howmany = atoi(argv[2]);
}
if (argc > 2) {
dtstr = argv[3];
}
dtstart = icaltime_from_string(dtstr);
recur = icalrecurrencetype_from_string(icr);
ritr = icalrecur_iterator_new(recur, dtstart);
printf("Using rule: %s\n", icr);
printf("Iterating %d occurrences beginning from %s\n", howmany, dtstr);
if (ritr) {
while (howmany-- && !icaltime_is_null_time(next)) {
next = icalrecur_iterator_next(ritr);
printf("%s\n", icaltime_as_ical_string_r(next));
}
} else {
printf("Error: %d\n", icalerrno);
}
}
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;
}
NS_IMETHODIMP
calDateTime::SetIcalString(nsACString const& aIcalString)
{
NS_ENSURE_FALSE(mImmutable, NS_ERROR_OBJECT_IS_IMMUTABLE);
icaltimetype icalt;
icalt = icaltime_from_string(PromiseFlatCString(aIcalString).get());
if (icaltime_is_null_time(icalt)) {
return static_cast<nsresult>(calIErrors::ICS_ERROR_BASE + icalerrno);
}
FromIcalTime(&icalt, nullptr);
return NS_OK;
}
/** Get timestamp of last sync.
*
* @param cb 3E calendar backend.
*
* @return Timestamp in local time.
*/
time_t e_cal_backend_3e_get_sync_timestamp(ECalBackend3e *cb)
{
time_t stamp = 0;
g_static_rw_lock_reader_lock(&cb->priv->cache_lock);
const char *ts = e_cal_backend_cache_get_server_utc_time(cb->priv->cache);
g_static_rw_lock_reader_unlock(&cb->priv->cache_lock);
if (ts)
{
icaltimetype time = icaltime_from_string(ts);
stamp = icaltime_as_timet_with_zone(time, NULL);
}
return stamp;
}
/*
* Add iCalendar recur-rule-parts to a structured element.
*/
void icalrecurrencetype_add_as_xxx(struct icalrecurrencetype *recur, void *obj,
void (*add_int)(void *, const char *, int),
void (*add_str)(void *, const char *,
const char *))
{
char *rrule, *rpart;
tok_t rparts;
/* generate an iCal RRULE string */
rrule = icalrecurrencetype_as_string_r(recur);
/* split string into rparts & values */
tok_initm(&rparts, rrule, "=;", TOK_TRIMLEFT|TOK_TRIMRIGHT);
while ((rpart = tok_next(&rparts))) {
if (!strcmp(rpart, "UNTIL")) {
/* need to translate date format to ISO */
struct icaltimetype until = icaltime_from_string(tok_next(&rparts));
add_str(obj, "until", icaltime_as_iso_string(until));
}
else {
/* assume the rpart has multiple values - split them */
tok_t vlist;
char *val, *p;
tok_init(&vlist, tok_next(&rparts), ",",
TOK_TRIMLEFT|TOK_TRIMRIGHT);
while ((val = tok_next(&vlist))) {
if (add_int) {
/* try converting value to integer */
int n = strtol(val, &p, 10);
if (n && !*p) {
add_int(obj, lcase(rpart), n);
continue;
}
}
add_str(obj, lcase(rpart), val);
}
tok_fini(&vlist);
}
}
tok_fini(&rparts);
free(rrule);
}
static void
test_modify_object (ETestServerFixture *fixture,
gconstpointer user_data)
{
ECal *cal;
ECalComponent *e_component;
ECalComponent *e_component_final;
icalcomponent *component;
icalcomponent *component_final;
struct icaltimetype icaltime;
gchar *uid;
cal = E_TEST_SERVER_UTILS_SERVICE (fixture, ECal);
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);
g_object_unref (e_component_final);
g_free (uid);
icalcomponent_free (component);
}
int main(int argc, char *argv[]) {
char *dtstr = "20031026T190000";
icaltimezone *zone;
struct icaltimetype tt;
int utc_offset;
if (argc > 1) {
dtstr = argv[1];
}
icalcomponent *zonecomp = icalcomponent_new_from_string(mytz);
zone = icaltimezone_new();
icaltimezone_set_component(zone, zonecomp);
tt = icaltime_from_string(dtstr);
icaltime_set_timezone(&tt, zone);
utc_offset = icaltimezone_get_utc_offset(zone, &tt, NULL);
printf("OFFSET for %s is %d %p\n", dtstr, utc_offset, zone);
}
struct icaltriggertype icaltriggertype_from_string(const char* str)
{
struct icaltriggertype tr, null_tr;
icalerrorstate es = ICAL_ERROR_DEFAULT;
icalerrorenum e;
tr.time= icaltime_null_time();
tr.duration = icaldurationtype_from_int(0);
null_tr = tr;
/* Suppress errors so a failure in icaltime_from_string() does not cause an abort */
es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
if(str == 0) goto error;
icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
e = icalerrno;
icalerror_set_errno(ICAL_NO_ERROR);
tr.time = icaltime_from_string(str);
if (icaltime_is_null_time(tr.time)){
tr.duration = icaldurationtype_from_string(str);
if (icaldurationtype_is_bad_duration(tr.duration)) goto error;
}
icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
icalerror_set_errno(e);
return tr;
error:
icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return tr;
}
/*
* Construct an iCalendar property value from XML content.
*/
static icalvalue *xml_element_to_icalvalue(xmlNodePtr xtype,
icalvalue_kind kind)
{
icalvalue *value = NULL;
xmlNodePtr node;
xmlChar *content = NULL;
switch (kind) {
case ICAL_GEO_VALUE: {
struct icalgeotype geo;
node = xmlFirstElementChild(xtype);
if (!node) {
syslog(LOG_WARNING, "Missing <latitude> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "latitude")) {
syslog(LOG_WARNING,
"Expected <latitude> XML element, received %s", node->name);
break;
}
content = xmlNodeGetContent(node);
geo.lat = atof((const char *) content);
node = xmlNextElementSibling(node);
if (!node) {
syslog(LOG_WARNING, "Missing <longitude> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "longitude")) {
syslog(LOG_WARNING,
"Expected <longitude> XML element, received %s", node->name);
break;
}
xmlFree(content);
content = xmlNodeGetContent(node);
geo.lon = atof((const char *) content);
value = icalvalue_new_geo(geo);
break;
}
case ICAL_PERIOD_VALUE: {
struct icalperiodtype p;
p.start = p.end = icaltime_null_time();
p.duration = icaldurationtype_from_int(0);
node = xmlFirstElementChild(xtype);
if (!node) {
syslog(LOG_WARNING, "Missing <start> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "start")) {
syslog(LOG_WARNING,
"Expected <start> XML element, received %s", node->name);
break;
}
content = xmlNodeGetContent(node);
p.start = icaltime_from_string((const char *) content);
if (icaltime_is_null_time(p.start)) break;
node = xmlNextElementSibling(node);
if (!node) {
syslog(LOG_WARNING, "Missing <end> / <duration> XML element");
break;
}
else if (!xmlStrcmp(node->name, BAD_CAST "end")) {
xmlFree(content);
content = xmlNodeGetContent(node);
p.end = icaltime_from_string((const char *) content);
if (icaltime_is_null_time(p.end)) break;
}
else if (!xmlStrcmp(node->name, BAD_CAST "duration")) {
xmlFree(content);
content = xmlNodeGetContent(node);
p.duration = icaldurationtype_from_string((const char *) content);
if (icaldurationtype_as_int(p.duration) == 0) break;
}
else {
syslog(LOG_WARNING,
"Expected <end> / <duration> XML element, received %s",
node->name);
break;
}
value = icalvalue_new_period(p);
break;
}
case ICAL_RECUR_VALUE: {
struct buf rrule = BUF_INITIALIZER;
struct hash_table byrules;
struct icalrecurrencetype rt;
char *sep = "";
construct_hash_table(&byrules, 10, 1);
/* create an iCal RRULE string from xCal <recur> sub-elements */
for (node = xmlFirstElementChild(xtype); node;
node = xmlNextElementSibling(node)) {
content = xmlNodeGetContent(node);
if (!xmlStrncmp(node->name, BAD_CAST "by", 2)) {
/* BY* rules can have a list of values -
assemble them using a hash table */
struct buf *vals =
hash_lookup((const char *) node->name, &byrules);
if (vals) {
/* append this value to existing list */
buf_printf(vals, ",%s", (char *) content);
}
else {
/* create new list with this valiue */
vals = xzmalloc(sizeof(struct buf));
buf_setcstr(vals, (char *) content);
hash_insert((char *) node->name, vals, &byrules);
}
}
else {
/* single value rpart */
buf_printf(&rrule, "%s%s=%s", sep,
ucase((char *) node->name), (char *) content);
sep = ";";
}
xmlFree(content);
content = NULL;
}
/* append the BY* rules to RRULE buffer */
hash_enumerate(&byrules,
(void (*)(const char*, void*, void*)) &append_byrule,
&rrule);
free_hash_table(&byrules, NULL);
/* parse our iCal RRULE string */
rt = icalrecurrencetype_from_string(buf_cstring(&rrule));
buf_free(&rrule);
if (rt.freq != ICAL_NO_RECURRENCE) value = icalvalue_new_recur(rt);
break;
}
case ICAL_REQUESTSTATUS_VALUE: {
struct icalreqstattype rst = { ICAL_UNKNOWN_STATUS, NULL, NULL };
short maj, min;
node = xmlFirstElementChild(xtype);
if (!node) {
syslog(LOG_WARNING, "Missing <code> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "code")) {
syslog(LOG_WARNING,
"Expected <code> XML element, received %s", node->name);
break;
}
content = xmlNodeGetContent(node);
if (sscanf((const char *) content, "%hd.%hd", &maj, &min) == 2) {
rst.code = icalenum_num_to_reqstat(maj, min);
}
if (rst.code == ICAL_UNKNOWN_STATUS) {
syslog(LOG_WARNING, "Unknown request-status code");
break;
}
node = xmlNextElementSibling(node);
if (!node) {
syslog(LOG_WARNING, "Missing <description> XML element");
break;
}
else if (xmlStrcmp(node->name, BAD_CAST "description")) {
syslog(LOG_WARNING,
"Expected <description> XML element, received %s",
node->name);
break;
}
xmlFree(content);
content = xmlNodeGetContent(node);
rst.desc = (const char *) content;
node = xmlNextElementSibling(node);
if (node) {
if (xmlStrcmp(node->name, BAD_CAST "data")) {
syslog(LOG_WARNING,
"Expected <data> XML element, received %s", node->name);
break;
}
xmlFree(content);
content = xmlNodeGetContent(node);
rst.debug = (const char *) content;
}
value = icalvalue_new_requeststatus(rst);
break;
}
case ICAL_UTCOFFSET_VALUE: {
int n, utcoffset, hours, minutes, seconds = 0;
char sign;
content = xmlNodeGetContent(xtype);
n = sscanf((const char *) content, "%c%02d:%02d:%02d",
&sign, &hours, &minutes, &seconds);
if (n < 3) {
syslog(LOG_WARNING, "Unexpected utc-offset format");
break;
}
utcoffset = hours*3600 + minutes*60 + seconds;
if (sign == '-') utcoffset = -utcoffset;
value = icalvalue_new_utcoffset(utcoffset);
break;
}
default:
content = xmlNodeGetContent(xtype);
value = icalvalue_new_from_string(kind, (const char *) content);
break;
}
if (content) xmlFree(content);
return value;
}
gint
ics_parse_file (struct ics_file *file_entry, gchar *name, gchar *filename, gboolean desc_flag,
gboolean count_only, GUI *appGUI) {
FILE *ics_stream;
icalparser *ics_parser;
icalcomponent *ics_component;
icalcomponent *h, *l;
icalproperty *p, *r;
struct icaltimetype tt;
struct ics_entry *item;
gint n = 0;
ics_parser = icalparser_new ();
g_return_val_if_fail (ics_parser != NULL, n);
ics_stream = fopen (filename, "r");
if (ics_stream == NULL) {
icalparser_free (ics_parser);
return n;
}
icalparser_set_gen_data (ics_parser, ics_stream);
ics_component = icalparser_parse (ics_parser, ics_read_stream);
if (ics_component == NULL) {
fclose (ics_stream);
icalparser_free (ics_parser);
return n;
}
/* FIXME */
if (icalcomponent_get_first_component (ics_component, ICAL_VEVENT_COMPONENT) != NULL) {
for (h = icalcomponent_get_first_component (ics_component, ICAL_VEVENT_COMPONENT); h;
h = icalcomponent_get_next_component (ics_component, ICAL_VEVENT_COMPONENT)) {
p = icalcomponent_get_first_property (h, ICAL_DTSTART_PROPERTY);
tt = icaltime_from_string (icalproperty_get_value_as_string (p));
p = icalcomponent_get_first_property (h, ICAL_SUMMARY_PROPERTY);
if (p != NULL && count_only == FALSE) {
r = icalcomponent_get_first_property (h, ICAL_DESCRIPTION_PROPERTY);
item = g_malloc (sizeof (struct ics_entry));
if (item != NULL) {
item->date.day = tt.day;
item->date.month = tt.month;
item->date.year = tt.year;
item->summary = g_strdup (icalproperty_get_value_as_string (p));
if (r != NULL) {
item->description = g_strdup (icalproperty_get_value_as_string (r));
} else {
item->description = NULL;
}
file_entry->entries_list = g_slist_append (file_entry->entries_list, item);
}
}
n++;
}
} else if (icalcomponent_get_first_component (ics_component, ICAL_VCALENDAR_COMPONENT) != NULL) {
for (l = icalcomponent_get_first_component (ics_component, ICAL_VCALENDAR_COMPONENT); l;
l = icalcomponent_get_next_component (ics_component, ICAL_VCALENDAR_COMPONENT)) {
h = icalcomponent_get_first_component (l, ICAL_VEVENT_COMPONENT);
p = icalcomponent_get_first_property (h, ICAL_DTSTART_PROPERTY);
tt = icaltime_from_string (icalproperty_get_value_as_string (p));
p = icalcomponent_get_first_property (h, ICAL_SUMMARY_PROPERTY);
if (p != NULL && count_only == FALSE) {
r = icalcomponent_get_first_property (h, ICAL_DESCRIPTION_PROPERTY);
item = g_malloc (sizeof (struct ics_entry));
if (item != NULL) {
item->date.day = tt.day;
item->date.month = tt.month;
item->date.year = tt.year;
item->summary = g_strdup (icalproperty_get_value_as_string(p));
if (r != NULL) {
item->description = g_strdup (icalproperty_get_value_as_string (r));
} else {
item->description = NULL;
}
file_entry->entries_list = g_slist_append (file_entry->entries_list, item);
}
}
n++;
}
}
icalcomponent_free (ics_component);
fclose (ics_stream);
icalparser_free (ics_parser);
return n;
}
struct icalrecurrencetype icalrecurrencetype_from_string(const char* str)
{
struct icalrecur_parser parser;
memset(&parser,0,sizeof(parser));
icalrecurrencetype_clear(&parser.rt);
icalerror_check_arg_re(str!=0,"str",parser.rt);
/* Set up the parser struct */
parser.rule = str;
parser.copy = _strdup(parser.rule);
parser.this_clause = parser.copy;
if(parser.copy == 0){
//icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return parser.rt;
}
/* Loop through all of the clauses */
for(icalrecur_first_clause(&parser);
parser.this_clause != 0;
icalrecur_next_clause(&parser))
{
char *name, *value;
icalrecur_clause_name_and_value(&parser,&name,&value);
if(name == 0){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
icalrecurrencetype_clear(&parser.rt);
free(parser.copy);
return parser.rt;
}
if (strcasecmp(name,"FREQ") == 0){
parser.rt.freq = icalrecur_string_to_freq(value);
} else if (strcasecmp(name,"COUNT") == 0){
int v = atoi(value);
if (v >= 0) {
parser.rt.count = v;
}
} else if (strcasecmp(name,"UNTIL") == 0){
parser.rt.until = icaltime_from_string(value);
} else if (strcasecmp(name,"INTERVAL") == 0){
int v = atoi(value);
if (v > 0 && v <= SHRT_MAX) {
parser.rt.interval = (short) v;
}
} else if (strcasecmp(name,"WKST") == 0){
parser.rt.week_start = icalrecur_string_to_weekday(value);
sort_bydayrules(parser.rt.by_day, parser.rt.week_start);
} else if (strcasecmp(name,"BYSECOND") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_second,
ICAL_BY_SECOND_SIZE,value);
} else if (strcasecmp(name,"BYMINUTE") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_minute,
ICAL_BY_MINUTE_SIZE,value);
} else if (strcasecmp(name,"BYHOUR") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_hour,
ICAL_BY_HOUR_SIZE,value);
} else if (strcasecmp(name,"BYDAY") == 0){
icalrecur_add_bydayrules(&parser,value);
} else if (strcasecmp(name,"BYMONTHDAY") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_month_day,
ICAL_BY_MONTHDAY_SIZE,value);
} else if (strcasecmp(name,"BYYEARDAY") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_year_day,
ICAL_BY_YEARDAY_SIZE,value);
} else if (strcasecmp(name,"BYWEEKNO") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_week_no,
ICAL_BY_WEEKNO_SIZE,value);
} else if (strcasecmp(name,"BYMONTH") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_month,
ICAL_BY_MONTH_SIZE,value);
} else if (strcasecmp(name,"BYSETPOS") == 0){
icalrecur_add_byrules(&parser,parser.rt.by_set_pos,
ICAL_BY_SETPOS_SIZE,value);
} else {
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
icalrecurrencetype_clear(&parser.rt);
free(parser.copy);
return parser.rt;
}
}
free(parser.copy);
return parser.rt;
}
void
e_sendoptions_utils_set_default_data (ESendOptionsDialog *sod, ESource *source, char * type)
{
ESendOptionsGeneral *gopts = NULL;
ESendOptionsStatusTracking *sopts;
GConfClient *gconf = gconf_client_get_default ();
ESourceList *source_list;
const char *uid;
const char *value;
gopts = sod->data->gopts;
sopts = sod->data->sopts;
if (!strcmp (type, "calendar"))
source_list = e_source_list_new_for_gconf (gconf, "/apps/evolution/calendar/sources");
else
source_list = e_source_list_new_for_gconf (gconf, "/apps/evolution/tasks/sources");
uid = e_source_peek_uid (source);
source = e_source_list_peek_source_by_uid (source_list, uid);
/* priority */
value = e_source_get_property (source, "priority");
if (value) {
if (!strcmp (value, "high"))
gopts->priority = E_PRIORITY_HIGH;
else if (!strcmp (value, "standard"))
gopts->priority = E_PRIORITY_STANDARD;
else if (!strcmp (value, "low"))
gopts->priority = E_PRIORITY_LOW;
else
gopts->priority = E_PRIORITY_UNDEFINED;
}
/* Reply requested */
value = e_source_get_property (source, "reply-requested");
if (value) {
if (!strcmp (value, "none"))
gopts->reply_enabled = FALSE;
else if (!strcmp (value, "convinient")) {
gopts->reply_enabled = TRUE;
gopts->reply_convenient = TRUE;
} else {
gint i = atoi (value);
gopts->reply_within = i;
}
}
/* Delay delivery */
value = e_source_get_property (source, "delay-delivery");
if (value) {
if (!strcmp (value, "none"))
gopts->delay_enabled = FALSE;
else {
gopts->delay_enabled = TRUE;
gopts->delay_until = icaltime_as_timet (icaltime_from_string (value));
}
}
/* Expiration Date */
value = e_source_get_property (source, "expiration");
if (value) {
if (!strcmp (value, "none"))
gopts->expiration_enabled = FALSE;
else {
gint i = atoi (value);
if (i == 0)
gopts->expiration_enabled = FALSE;
else
gopts->expiration_enabled = TRUE;
gopts->expire_after = i;
}
}
/* status tracking */
value = e_source_get_property (source, "status-tracking");
if (value) {
if (!strcmp (value, "none"))
sopts->tracking_enabled = FALSE;
else {
sopts->tracking_enabled = TRUE;
if (!strcmp (value, "delivered"))
sopts->track_when = E_DELIVERED;
else if (!strcmp (value, "delivered-opened"))
sopts->track_when = E_DELIVERED_OPENED;
else
sopts->track_when = E_ALL;
}
}
/* Return Notifications */
value = e_source_get_property (source, "return-open");
if (value) {
if (!strcmp (value, "none"))
sopts->opened = E_RETURN_NOTIFY_NONE;
else
sopts->opened = E_RETURN_NOTIFY_MAIL;
}
value = e_source_get_property (source, "return-accept");
if (value) {
if (!strcmp (value, "none"))
sopts->accepted = E_RETURN_NOTIFY_NONE;
else
sopts->accepted = E_RETURN_NOTIFY_MAIL;
}
value = e_source_get_property (source, "return-decline");
if (value) {
if (!strcmp (value, "none"))
sopts->declined = E_RETURN_NOTIFY_NONE;
else
sopts->declined = E_RETURN_NOTIFY_MAIL;
}
value = e_source_get_property (source, "return-complete");
if (value) {
if (!strcmp (value, "none"))
sopts->completed = E_RETURN_NOTIFY_NONE;
else
sopts->completed = E_RETURN_NOTIFY_MAIL;
}
g_object_unref (gconf);
}
static const gchar *
test_object_creation (ECal *client,
gchar **uid)
{
ECalComponent *comp, *comp_retrieved;
icalcomponent *icalcomp, *icalcomp_retrieved;
struct icaltimetype tt;
ECalComponentText text;
ECalComponentDateTime dt;
ECalComponentTransparency transp;
gboolean compare;
GError *error = NULL;
comp = e_cal_component_new ();
/* set fields */
e_cal_component_set_new_vtype (comp, E_CAL_COMPONENT_EVENT);
text.value = "Creation of new test event";
text.altrep = NULL;
e_cal_component_set_summary (comp, &text);
tt = icaltime_from_string ("20040109T090000Z");
dt.value = &tt;
dt.tzid ="UTC";
e_cal_component_set_dtstart (comp, &dt);
tt = icaltime_from_string ("20040109T103000");
dt.value = &tt;
dt.tzid ="UTC";
e_cal_component_set_dtend (comp, &dt);
e_cal_component_set_transparency (comp, E_CAL_COMPONENT_TRANSP_OPAQUE);
e_cal_component_commit_sequence (comp);
icalcomp = e_cal_component_get_icalcomponent (comp);
if (!e_cal_create_object (client, icalcomp, uid, &error)) {
cl_printf (client, "Object creation: %s\n", error->message);
g_free (comp);
g_free (icalcomp);
return "Test Object Creation failed";
}
e_cal_component_commit_sequence (comp);
if (!e_cal_get_object (client, *uid, NULL, &icalcomp_retrieved, &error)) {
cl_printf (client, "Object retrieval: %s\n", error->message);
g_free (uid);
g_free (comp);
g_free (icalcomp);
return "Test Object Creation failed";
}
comp_retrieved = e_cal_component_new ();
if (!e_cal_component_set_icalcomponent (comp_retrieved, icalcomp_retrieved)) {
cl_printf (client, "Could not set icalcomponent\n");
g_free (uid);
g_free (comp);
g_free (icalcomp);
g_free (icalcomp_retrieved);
return "Test Object Creation failed";
}
/* Dumping icalcomp into a string is not useful as the retrieved object
* has some generated information like timestamps. We compare
* member values we set during creation*/
compare = e_cal_component_event_dates_match (comp, comp_retrieved);
if (compare) {
e_cal_component_get_transparency (comp_retrieved, &transp);
compare = (transp == E_CAL_COMPONENT_TRANSP_OPAQUE);
}
g_free (comp_retrieved);
g_free (comp);
g_free (icalcomp);
g_free (icalcomp_retrieved);
mu_assert ("Test Object creation : Created object does not match retrieved data\n", compare);
return NULL;
}
