void ical_property_DTEND(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
icalparameter *tzid;
struct icaltimetype icaltime;
/* Sanity check */
if (!exchange2ical->apptEndWhole) return;
/* If this is an all-day appointment */
if (exchange2ical->apptSubType && (*exchange2ical->apptSubType == 0x1)) {
icaltime = get_icaldate_from_FILETIME(exchange2ical->apptEndWhole);
prop = icalproperty_new_dtend(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
} else {
if (exchange2ical->TimeZoneDesc) {
icaltime = get_icaltime_from_FILETIME(exchange2ical->apptEndWhole);
prop = icalproperty_new_dtend(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
tzid = icalparameter_new_tzid(exchange2ical->TimeZoneDesc);
icalproperty_add_parameter(prop, tzid);
} else {
icaltime = get_icaltime_from_FILETIME_UTC(exchange2ical->apptEndWhole);
prop = icalproperty_new_dtend(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
}
}
void ical_property_DTSTAMP(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
struct icaltimetype icaltime;
struct tm *tm;
icalparameter *tzid;
time_t t;
/* Sanity check */
/*If OwnerCriticalChange field is null, get time system time*/
if (!exchange2ical->OwnerCriticalChange) {
t=time(NULL);
tm = gmtime(&t);
icaltime = get_icaltimetype_from_tm_UTC(tm);
prop = icalproperty_new_dtstamp(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
return;
} else {
icaltime = get_icaltime_from_FILETIME_UTC(exchange2ical->OwnerCriticalChange);
prop = icalproperty_new_dtstamp(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
if (exchange2ical->TimeZoneDesc) {
tzid = icalparameter_new_tzid(exchange2ical->TimeZoneDesc);
icalproperty_add_parameter(prop, tzid);
}
}
}
static icalcomponent *icalmessage_new_reply_base(icalcomponent *c,
const char *user, const char *msg)
{
icalproperty *attendee;
char tmp[45];
icalcomponent *reply =
icalcomponent_vanew(
ICAL_VCALENDAR_COMPONENT, icalproperty_new_method(ICAL_METHOD_REPLY),
icalcomponent_vanew(
ICAL_VEVENT_COMPONENT,
icalproperty_new_dtstamp(icaltime_from_timet_with_zone(time(0), 0, NULL)),
0),
0);
icalcomponent *inner = icalmessage_get_inner(reply);
icalerror_check_arg_rz(c, "c");
icalmessage_copy_properties(reply, c, ICAL_UID_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_ORGANIZER_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_RECURRENCEID_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_SUMMARY_PROPERTY);
icalmessage_copy_properties(reply, c, ICAL_SEQUENCE_PROPERTY);
icalcomponent_set_dtstamp(reply, icaltime_from_timet_with_zone(time(0), 0, NULL));
if (msg != 0) {
icalcomponent_add_property(inner, icalproperty_new_comment(msg));
}
/* Copy this user's attendee property */
attendee = icalmessage_find_attendee(c, user);
if (attendee == 0) {
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
icalcomponent_free(reply);
return 0;
}
icalcomponent_add_property(inner, icalproperty_new_clone(attendee));
/* Add PRODID and VERSION */
icalcomponent_add_property(reply, icalproperty_new_version("2.0"));
snprintf(tmp, sizeof(tmp), "-//SoftwareStudio//NONSGML %s %s //EN", ICAL_PACKAGE, ICAL_VERSION);
icalcomponent_add_property(reply, icalproperty_new_prodid(tmp));
return reply;
}
void ical_property_TRIGGER(struct exchange2ical *exchange2ical)
{
struct icaltriggertype duration;
icalproperty *prop;
if (!exchange2ical->ReminderDelta) return;
if (*exchange2ical->ReminderDelta == 0x5AE980E1) {
duration = icaltriggertype_from_int(-15 * 60);
prop = icalproperty_new_trigger(duration);
icalcomponent_add_property(exchange2ical->valarm, prop);
} else {
duration = icaltriggertype_from_int(*(exchange2ical->ReminderDelta) * -1 * 60);
prop = icalproperty_new_trigger(duration);
icalcomponent_add_property(exchange2ical->valarm, prop);
}
}
void ical_property_RRULE_Yearly(struct exchange2ical *exchange2ical)
{
struct icalrecurrencetype recurrence;
icalproperty *prop;
struct RecurrencePattern *pat = exchange2ical->RecurrencePattern;
uint32_t day = pat->PatternTypeSpecific.Day;
struct icaltimetype icaltime;
icalrecurrencetype_clear(&recurrence);
recurrence.freq = ICAL_YEARLY_RECURRENCE;
recurrence.interval = (pat->Period / 12);
if (day == 0x0000001F) {
recurrence.by_month_day[0] = -1;
} else {
recurrence.by_month_day[0] = day;
}
recurrence.by_month_day[1] = ICAL_RECURRENCE_ARRAY_MAX;
icaltime = get_icaltime_from_FILETIME_UTC(exchange2ical->apptStartWhole);
recurrence.by_month[0] = icaltime.month;
recurrence.by_month[1] = ICAL_RECURRENCE_ARRAY_MAX;
if (pat->EndType == END_AFTER_N_OCCURRENCES || pat->EndType == END_AFTER_DATE) {
recurrence.count = pat->OccurrenceCount;
}
prop = icalproperty_new_rrule(recurrence);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
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);
}
/** Set icalcomponent X-* property.
*
* @param comp iCal component.
* @param key Property name (i.e. X-EEE-WHATEVER).
* @param value Property value.
*/
static void icomp_x_prop_set(icalcomponent *comp, const char *key, const char *value)
{
icalproperty *iter;
g_return_if_fail(comp != NULL);
g_return_if_fail(key != NULL);
again:
for (iter = icalcomponent_get_first_property(comp, ICAL_X_PROPERTY);
iter;
iter = icalcomponent_get_next_property(comp, ICAL_X_PROPERTY))
{
const char *str = icalproperty_get_x_name(iter);
if (str && !g_strcmp0(str, key))
{
icalcomponent_remove_property(comp, iter);
icalproperty_free(iter);
goto again;
}
}
if (value)
{
iter = icalproperty_new_x(value);
icalproperty_set_x_name(iter, key);
icalcomponent_add_property(comp, iter);
}
}
void ical_property_RRULE_daylight_standard(icalcomponent* component , struct SYSTEMTIME st)
{
struct icalrecurrencetype recurrence;
icalproperty *prop;
icalrecurrencetype_clear(&recurrence);
recurrence.freq = ICAL_YEARLY_RECURRENCE;
if(st.wYear ==0x0000){
recurrence.by_month[0]=st.wMonth;
/* Microsoft day of week = libIcal day of week +1; */
/* Day encode = day + occurrence*8 */
if (st.wDay==5){
/* Last occurrence of day in the month*/
recurrence.by_day[0] = -1 * (st.wDayOfWeek + 9);
}else{
/* st.wDay occurrence of day in the month */
recurrence.by_day[0] = (st.wDayOfWeek + 1 + st.wDay*8);
}
}else{
recurrence.by_month_day[0]=st.wDay;
recurrence.by_month[0]=st.wMonth;
}
prop = icalproperty_new_rrule(recurrence);
icalcomponent_add_property(component, prop);
}
static void
change_status (icalcomponent *ical_comp, const char *address, icalparameter_partstat status)
{
icalproperty *prop;
prop = find_attendee (ical_comp, address);
if (prop) {
icalparameter *param;
icalproperty_remove_parameter (prop, ICAL_PARTSTAT_PARAMETER);
param = icalparameter_new_partstat (status);
icalproperty_add_parameter (prop, param);
} else {
icalparameter *param;
prop = icalproperty_new_attendee (address);
icalcomponent_add_property (ical_comp, prop);
param = icalparameter_new_role (ICAL_ROLE_OPTPARTICIPANT);
icalproperty_add_parameter (prop, param);
param = icalparameter_new_partstat (status);
icalproperty_add_parameter (prop, param);
}
}
static void icaldirset_add_uid(icalcomponent* comp)
{
char uidstring[ICAL_PATH_MAX];
icalproperty *uid;
#ifndef WIN32
struct utsname unamebuf;
#endif
icalerror_check_arg_rv( (comp!=0), "comp");
uid = icalcomponent_get_first_property(comp,ICAL_UID_PROPERTY);
if (uid == 0) {
#ifndef WIN32
uname(&unamebuf);
snprintf(uidstring,sizeof(uidstring),"%d-%s",(int)getpid(),unamebuf.nodename);
#else
snprintf(uidstring,sizeof(uidstring),"%d-%s",(int)getpid(),"WINDOWS"); /* FIX: There must be an easy get the system name */
#endif
uid = icalproperty_new_uid(uidstring);
icalcomponent_add_property(comp,uid);
} else {
strcpy(uidstring,icalproperty_get_uid(uid));
}
}
static gboolean
free_busy_instance (ECalComponent *comp,
time_t instance_start,
time_t instance_end,
gpointer data)
{
icalcomponent *vfb = data;
icalproperty *prop;
icalparameter *param;
struct icalperiodtype ipt;
icaltimezone *utc_zone;
utc_zone = icaltimezone_get_utc_timezone ();
ipt.start = icaltime_from_timet_with_zone (instance_start, FALSE, utc_zone);
ipt.end = icaltime_from_timet_with_zone (instance_end, FALSE, utc_zone);
ipt.duration = icaldurationtype_null_duration ();
/* add busy information to the vfb component */
prop = icalproperty_new (ICAL_FREEBUSY_PROPERTY);
icalproperty_set_freebusy (prop, ipt);
param = icalparameter_new_fbtype (ICAL_FBTYPE_BUSY);
icalproperty_add_parameter (prop, param);
icalcomponent_add_property (vfb, prop);
return TRUE;
}
icalcomponent *icalmessage_new_delegate_request(icalcomponent *c,
const char *user,
const char *delegatee, const char *msg)
{
icalcomponent *reply;
icalproperty *attendee;
icalcomponent *inner;
icalparameter *delegateeParam;
icalerror_check_arg_rz(c, "c");
reply = icalmessage_new_reply_base(c, user, msg);
inner = icalmessage_get_inner(reply);
if (reply == 0) {
return 0;
}
icalcomponent_set_method(reply, ICAL_METHOD_REQUEST);
attendee = icalcomponent_get_first_property(inner, ICAL_ATTENDEE_PROPERTY);
icalproperty_set_parameter(attendee, icalparameter_new_partstat(ICAL_PARTSTAT_DELEGATED));
icalproperty_set_parameter(attendee, icalparameter_new_delegatedto(delegatee));
delegateeParam = icalparameter_new_delegatedfrom(icalproperty_get_attendee(attendee));
icalcomponent_add_property(
inner,
icalproperty_vanew_attendee(delegatee, delegateeParam, 0));
icalparameter_free(delegateeParam);
return reply;
}
NS_IMETHODIMP
calIcalComponent::AddProperty(calIIcalProperty * aProp)
{
NS_ENSURE_ARG_POINTER(aProp);
// We assume a calIcalProperty is passed in (else the cast wouldn't run and
// we are about to crash), so we assume that this ICS service code has created
// the property.
nsresult rv;
nsCOMPtr<calIIcalPropertyLibical> icalprop = do_QueryInterface(aProp, &rv);
NS_ENSURE_SUCCESS(rv, rv);
calIcalProperty * const ical = toIcalProperty(icalprop);
if (ical->mParent) {
ical->mProperty = icalproperty_new_clone(ical->mProperty);
}
ical->mParent = this;
icalcomponent_add_property(mComponent, ical->mProperty);
nsCOMPtr<calIDateTime> dt;
if (NS_SUCCEEDED(aProp->GetValueAsDatetime(getter_AddRefs(dt))) && dt) {
// make sure timezone definition will be included:
nsCOMPtr<calITimezone> tz;
if (NS_SUCCEEDED(dt->GetTimezone(getter_AddRefs(tz))) && tz) {
getParentVCalendarOrThis()->AddTimezoneReference(tz);
}
}
return NS_OK;
}
static void icaldirset_add_uid(icalcomponent *comp)
{
char uidstring[MAXPATHLEN] = { 0 };
icalproperty *uid;
#if defined(HAVE_SYS_UTSNAME_H)
struct utsname unamebuf;
#endif
icalerror_check_arg_rv((comp != 0), "comp");
uid = icalcomponent_get_first_property(comp, ICAL_UID_PROPERTY);
if (uid == 0) {
#if defined(HAVE_SYS_UTSNAME_H)
uname(&unamebuf);
snprintf(uidstring, sizeof(uidstring), "%d-%s", (int)getpid(), unamebuf.nodename);
#else
/* FIXME: There must be an easy get the system name */
snprintf(uidstring, sizeof(uidstring), "%d-%s", (int)getpid(), "WINDOWS");
#endif
uid = icalproperty_new_uid(uidstring);
icalcomponent_add_property(comp, uid);
} else {
strncpy(uidstring, icalproperty_get_uid(uid), MAXPATHLEN - 1);
uidstring[MAXPATHLEN - 1] = '\0';
}
}
void ical_property_RRULE_Monthly(struct exchange2ical *exchange2ical)
{
struct icalrecurrencetype recurrence;
icalproperty *prop;
struct RecurrencePattern *pat = exchange2ical->RecurrencePattern;
uint32_t day = pat->PatternTypeSpecific.Day;
icalrecurrencetype_clear(&recurrence);
recurrence.freq = ICAL_MONTHLY_RECURRENCE;
recurrence.interval = pat->Period;
if (day == 0x0000001F) {
recurrence.by_month_day[0] = -1;
} else {
recurrence.by_month_day[0] = day;
}
recurrence.by_month_day[1] = ICAL_RECURRENCE_ARRAY_MAX;
if (pat->EndType == END_AFTER_N_OCCURRENCES || pat->EndType == END_AFTER_DATE) {
recurrence.count = pat->OccurrenceCount;
}
prop = icalproperty_new_rrule(recurrence);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
void ical_property_ORGANIZER(struct exchange2ical *exchange2ical)
{
const char *smtp;
const char *display_name;
uint32_t *RecipientFlags;
uint32_t *RecipientType;
uint32_t i;
struct SRowSet *SRowSet;
/* Sanity check */
if (!exchange2ical->apptStateFlags) return;
if (!(*exchange2ical->apptStateFlags & 0x1)) return;
SRowSet = &(exchange2ical->Recipients.SRowSet);
/* Loop over the recipient table */
for (i = 0; i < SRowSet->cRows; i++) {
smtp = (const char *) octool_get_propval(&(SRowSet->aRow[i]), PR_SMTP_ADDRESS);
display_name = (const char *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_DISPLAY_NAME);
RecipientFlags = (uint32_t *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_FLAGS);
RecipientType = (uint32_t *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_TYPE);
if (RecipientFlags && !(*RecipientFlags & 0x20) &&
((*RecipientFlags & 0x2) || (RecipientType && !*RecipientType))) {
icalproperty *prop;
icalparameter *cn;
if (smtp) {
char *mailtoURL;
mailtoURL = talloc_strdup(exchange2ical->mem_ctx, "mailto:");
mailtoURL = talloc_strdup_append(mailtoURL, smtp);
prop = icalproperty_new_organizer(mailtoURL);
icalcomponent_add_property(exchange2ical->vevent, prop);
talloc_free(mailtoURL);
} else {
prop = icalproperty_new_organizer("invalid:nomail");
icalcomponent_add_property(exchange2ical->vevent, prop);
}
if (display_name) {
cn = icalparameter_new_cn(display_name);
icalproperty_add_parameter(prop, cn);
}
}
}
}
void ical_property_LOCATION(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
/* Sanity check */
if (!exchange2ical->Location) return;
prop = icalproperty_new_location(exchange2ical->Location);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
nsresult
calIcalComponent::SetProperty(icalproperty_kind kind, icalproperty *prop)
{
ClearAllProperties(kind);
if (!prop)
return NS_OK;
icalcomponent_add_property(mComponent, prop);
return NS_OK;
}
void ical_property_CLASS(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
/* Sanity check */
if (!exchange2ical->sensitivity) return;
prop = icalproperty_new_class(get_ical_class(*exchange2ical->sensitivity));
icalcomponent_add_property(exchange2ical->vevent, prop);
}
void ical_property_SEQUENCE(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
if (!exchange2ical->Sequence) {
prop = icalproperty_new_sequence(0);
} else {
prop = icalproperty_new_sequence(*(exchange2ical->Sequence));
}
icalcomponent_add_property(exchange2ical->vevent, prop);
}
void ical_property_DESCRIPTION(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
if (exchange2ical->method == ICAL_METHOD_REPLY) return;
if (!exchange2ical->body) return;
prop = icalproperty_new_description(exchange2ical->body);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
void ical_property_UID(struct exchange2ical *exchange2ical)
{
uint32_t i;
const char *uid;
char* outstr;
struct GlobalObjectId *GlbObjId;
icalproperty *prop;
outstr = talloc_strdup(exchange2ical->mem_ctx, "");
if(exchange2ical->GlobalObjectId){
GlbObjId = get_GlobalObjectId(exchange2ical->mem_ctx, exchange2ical->GlobalObjectId);
}
if (exchange2ical->GlobalObjectId && (exchange2ical->GlobalObjectId->cb >= 36) && GlbObjId) {
if (GlbObjId->Size >= 16 && (0 == memcmp(GlbObjId->Data, GLOBAL_OBJECT_ID_DATA_START, 12))) {
fflush(0);
for (i = 12; i < exchange2ical->GlobalObjectId->cb; i++) {
char objID[6];
snprintf(objID, 6, "%.2X", exchange2ical->GlobalObjectId->lpb[i]);
outstr = talloc_strdup_append(outstr, objID);
}
uid = (const char *)&(GlbObjId->Data[13]);
outstr = talloc_strdup_append(outstr, uid);
} else {
fflush(0);
for (i = 0; i < 16; i++) {
char objID[6];
snprintf(objID, 6, "%.2X", exchange2ical->GlobalObjectId->lpb[i]);
outstr = talloc_strdup_append(outstr, objID);
}
/* YH, YL, Month and D must be set to 0 */
outstr = talloc_strdup_append(outstr, "00000000");
for (i = 20; i < exchange2ical->GlobalObjectId->cb; i++) {
char objID[6];
snprintf(objID, 6, "%.2X", exchange2ical->GlobalObjectId->lpb[i]);
outstr = talloc_strdup_append(outstr, objID);
}
}
talloc_free(GlbObjId);
} else {
char objID[32];
snprintf(objID, 32, "%i", exchange2ical->idx);
outstr = talloc_strdup(outstr, objID);
}
prop = icalproperty_new_uid(outstr);
icalcomponent_add_property(exchange2ical->vevent, prop);
talloc_free(outstr);
}
void MainWindow::createIcalTask(Task* task)
{
icalcomponent *todo;
icalproperty *prop;
todo = icalcomponent_new(ICAL_VTODO_COMPONENT);
prop = icalproperty_new_summary(task->icalSummary().c_str());
icalcomponent_add_property(todo, prop);
prop = icalproperty_new_uid(task->icalUid().c_str());
icalcomponent_add_property(todo, prop);
if (task->icalRelatedTo() != "")
{
prop = icalproperty_new_relatedto(task->icalRelatedTo().c_str());
icalcomponent_add_property(todo, prop);
}
saveToIcsFile(todo, task->icalUid());
}
gint
main (gint argc,
gchar **argv)
{
ECal *cal;
gchar *uri = NULL;
icalproperty *property;
icalcomponent *component;
icaltimezone *zone;
icaltimezone *zone_final;
g_type_init ();
cal = ecal_test_utils_cal_new_temp (&uri, E_CAL_SOURCE_TYPE_EVENT);
ecal_test_utils_cal_open (cal, FALSE);
/* Build up new timezone */
component = icalcomponent_new_vtimezone ();
property = icalproperty_new_tzid (TZID_NEW);
icalcomponent_add_property (component, property);
property = icalproperty_new_tzname (TZNAME_NEW);
icalcomponent_add_property (component, property);
zone = icaltimezone_new ();
icaltimezone_set_component (zone, component);
/* add */
ecal_test_utils_cal_add_timezone (cal, zone);
/* verify */
zone_final = ecal_test_utils_cal_get_timezone (cal, TZID_NEW);
g_assert (!g_strcmp0 (icaltimezone_get_tzid (zone),
icaltimezone_get_tzid (zone_final)));
g_assert (!g_strcmp0 (icaltimezone_get_tznames (zone),
icaltimezone_get_tznames (zone_final)));
ecal_test_utils_cal_remove (cal);
icaltimezone_free (zone, TRUE);
return 0;
}
void ical_property_CREATED(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
struct icaltimetype icaltime;
/* Sanity check */
if (!exchange2ical->created) return;
icaltime = get_icaltime_from_FILETIME_UTC(exchange2ical->created);
prop = icalproperty_new_created(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
void ical_property_RECURRENCE_ID(struct exchange2ical *exchange2ical)
{
struct icaltimetype icaltime;
icalproperty *prop;
icalparameter *tzid;
struct GlobalObjectId *GlbObjId;
if (exchange2ical->ExceptionReplaceTime){
/*if parent has an all day event*/
if (exchange2ical->apptSubType && (*exchange2ical->apptSubType == 0x1)) {
icaltime = get_icaldate_from_FILETIME(exchange2ical->ExceptionReplaceTime);
prop = icalproperty_new_recurrenceid(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
} else {
if (exchange2ical->TimeZoneDesc) {
icaltime=get_icaltime_from_FILETIME(exchange2ical->ExceptionReplaceTime);
prop = icalproperty_new_recurrenceid(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
tzid = icalparameter_new_tzid(exchange2ical->TimeZoneDesc);
icalproperty_add_parameter(prop, tzid);
} else {
icaltime = get_icaltime_from_FILETIME_UTC(exchange2ical->ExceptionReplaceTime);
prop = icalproperty_new_recurrenceid(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
}
} else if (exchange2ical->GlobalObjectId){
GlbObjId = get_GlobalObjectId(exchange2ical->mem_ctx, exchange2ical->GlobalObjectId);
if(GlbObjId){
icaltime=get_icaldate_from_GlobalObjectId(GlbObjId);
prop = icalproperty_new_recurrenceid(icaltime);
icalcomponent_add_property(exchange2ical->vevent, prop);
talloc_free(GlbObjId);
}
}
}
icalcomponent *icalmessage_new_error_reply(icalcomponent *c,
const char *user,
const char *msg,
const char *debug, icalrequeststatus code)
{
icalcomponent *reply;
icalcomponent *inner, *cinner;
struct icalreqstattype rs;
icalerror_check_arg_rz(c, "c");
memset(&rs, 0, sizeof(struct icalreqstattype));
reply = icalmessage_new_reply_base(c, user, msg);
inner = icalmessage_get_inner(reply);
cinner = icalmessage_get_inner(c);
if (reply == 0) {
return 0;
}
if (code != ICAL_UNKNOWN_STATUS) {
rs.code = code;
rs.debug = debug;
icalcomponent_add_property(inner, icalproperty_new_requeststatus(rs));
} else { /* code == ICAL_UNKNOWN_STATUS */
/* Copy all of the request status properties */
icalproperty *p;
for (p = icalcomponent_get_first_property(cinner, ICAL_REQUESTSTATUS_PROPERTY);
p != 0;
p = icalcomponent_get_next_property(cinner, ICAL_REQUESTSTATUS_PROPERTY)) {
icalcomponent_add_property(inner, icalproperty_new_clone(p));
}
}
return reply;
}
void ical_property_RESOURCES(struct exchange2ical *exchange2ical)
{
char *NonSendableBcc = NULL;
icalproperty *prop;
/* Sanity check */
if (!exchange2ical->NonSendableBcc) return;
NonSendableBcc = talloc_strdup(exchange2ical->mem_ctx, exchange2ical->NonSendableBcc);
all_string_sub(NonSendableBcc, ";", ",", 0);
prop = icalproperty_new_resources(NonSendableBcc);
icalcomponent_add_property(exchange2ical->vevent, prop);
talloc_free(NonSendableBcc);
}
void ical_property_CONTACT(struct exchange2ical *exchange2ical)
{
icalproperty *prop;
uint32_t i;
/* Sanity check */
if (!exchange2ical->Contacts) return;
if (!exchange2ical->Contacts->cValues) return;
for (i = 0; i < exchange2ical->Contacts->cValues; i++) {
prop = icalproperty_new_contact(exchange2ical->Contacts->lppszA[i]);
icalcomponent_add_property(exchange2ical->vevent, prop);
}
}
void
scalix_appointment_set (ScalixAppointment * comp,
const char *key, const char *value)
{
icalcomponent *icomp;
icalproperty *icalprop;
e_cal_component_commit_sequence (E_CAL_COMPONENT (comp));
icomp = e_cal_component_get_icalcomponent (E_CAL_COMPONENT (comp));
icalprop = icalproperty_new_x (value);
icalproperty_set_x_name (icalprop, key);
icalcomponent_add_property (icomp, icalprop);
}
