Beispiel #1
0
        /// <summary>
        /// This is implemented to handle properties related to VEvent items
        /// </summary>
        /// <param name="propertyName">The name of the property</param>
        /// <param name="parameters">A string collection containing the parameters and their values.  If empty,
        /// there are no parameters.</param>
        /// <param name="propertyValue">The value of the property.</param>
        protected virtual void VEventParser(string propertyName, StringCollection parameters, string propertyValue)
        {
            StringCollection sc;
            string[] parts, parms;
            int idx;

            // The last entry is always CustomProperty so scan for length minus one
            for(idx = 0; idx < ntvEvent.Length - 1; idx++)
                if(ntvEvent[idx].IsMatch(propertyName))
                    break;

            // An opening BEGIN:VEVENT property must have been seen
            if(vEvent == null)
                throw new PDIParserException(this.LineNumber, LR.GetString("ExParseNoBeginProp", "BEGIN:VEVENT",
                    propertyName));

            // Handle or create the property
            switch(ntvEvent[idx].EnumValue)
            {
                case PropertyType.Begin:    // Handle nested objects
                    priorState.Push(currentState);

                    // Is it an alarm?
                    if(String.Compare(propertyValue.Trim(), "VALARM", StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        vAlarm = new VAlarm();
                        vEvent.Alarms.Add(vAlarm);
                        currentState = VCalendarParserState.VAlarm;
                    }
                    else
                    {
                        // Unknown/custom object
                        currentState = VCalendarParserState.Custom;
                        CustomObjectParser(propertyName, parameters, propertyValue);
                    }
                    break;

                case PropertyType.End:
                    // For this, the value must be VEVENT
                    if(String.Compare(propertyValue.Trim(), "VEVENT", StringComparison.OrdinalIgnoreCase) != 0)
                        throw new PDIParserException(this.LineNumber, LR.GetString("ExParseUnrecognizedTagValue",
                            ntvEvent[idx].Name, propertyValue));

                    // The event is added to the collection when created so we don't have to rely on an END tag
                    // to add it.
                    vEvent = null;
                    currentState = priorState.Pop();
                    break;

                case PropertyType.Class:
                    vEvent.Classification.EncodedValue = propertyValue;
                    break;

                case PropertyType.Categories:
                    // If this is seen more than once, just add the new stuff to the existing property
                    CategoriesProperty cp = new CategoriesProperty();
                    cp.DeserializeParameters(parameters);
                    cp.EncodedValue = propertyValue;

                    foreach(string s in cp.Categories)
                        vEvent.Categories.Categories.Add(s);
                    break;

                case PropertyType.Resources:
                    // If this is seen more than once, just add the new stuff to the existing property
                    ResourcesProperty rp = new ResourcesProperty();
                    rp.DeserializeParameters(parameters);
                    rp.EncodedValue = propertyValue;

                    foreach(string s in rp.Resources)
                        vEvent.Resources.Resources.Add(s);
                    break;

                case PropertyType.Url:
                    vEvent.Url.DeserializeParameters(parameters);
                    vEvent.Url.EncodedValue = propertyValue;
                    break;

                case PropertyType.UniqueId:
                    vEvent.UniqueId.EncodedValue = propertyValue;
                    break;

                case PropertyType.LastModified:
                    vEvent.LastModified.DeserializeParameters(parameters);
                    vEvent.LastModified.EncodedValue = propertyValue;
                    break;

                case PropertyType.GeographicPosition:
                    vEvent.GeographicPosition.EncodedValue = propertyValue;
                    break;

                case PropertyType.DateCreated:
                    vEvent.DateCreated.DeserializeParameters(parameters);
                    vEvent.DateCreated.EncodedValue = propertyValue;
                    break;

                case PropertyType.StartDateTime:
                    vEvent.StartDateTime.DeserializeParameters(parameters);
                    vEvent.StartDateTime.EncodedValue = propertyValue;
                    break;

                case PropertyType.EndDateTime:
                    vEvent.EndDateTime.DeserializeParameters(parameters);
                    vEvent.EndDateTime.EncodedValue = propertyValue;
                    break;

                case PropertyType.TimeStamp:
                    vEvent.TimeStamp.DeserializeParameters(parameters);
                    vEvent.TimeStamp.EncodedValue = propertyValue;
                    break;

                case PropertyType.Summary:
                    vEvent.Summary.DeserializeParameters(parameters);
                    vEvent.Summary.EncodedValue = propertyValue;
                    break;

                case PropertyType.Description:
                    vEvent.Description.DeserializeParameters(parameters);
                    vEvent.Description.EncodedValue = propertyValue;
                    break;

                case PropertyType.Location:
                    vEvent.Location.DeserializeParameters(parameters);
                    vEvent.Location.EncodedValue = propertyValue;
                    break;

                case PropertyType.Priority:
                    vEvent.Priority.DeserializeParameters(parameters);
                    vEvent.Priority.EncodedValue = propertyValue;
                    break;

                case PropertyType.Sequence:
                    vEvent.Sequence.DeserializeParameters(parameters);
                    vEvent.Sequence.EncodedValue = propertyValue;
                    break;

                case PropertyType.Transparency:
                    vEvent.Transparency.DeserializeParameters(parameters);
                    vEvent.Transparency.EncodedValue = propertyValue;
                    break;

                case PropertyType.RecurrenceCount:
                    vEvent.RecurrenceCount.DeserializeParameters(parameters);
                    vEvent.RecurrenceCount.EncodedValue = propertyValue;
                    break;

                case PropertyType.Comment:
                    // If this is seen more than once, just add the new stuff to the existing property
                    if(vEvent.Comment.Value != null)
                    {
                        vEvent.Comment.EncodedValue += "\r\n";
                        vEvent.Comment.EncodedValue += propertyValue;
                    }
                    else
                    {
                        vEvent.Comment.DeserializeParameters(parameters);
                        vEvent.Comment.EncodedValue = propertyValue;
                    }
                    break;

                case PropertyType.Contact:
                    ContactProperty c = new ContactProperty();
                    c.DeserializeParameters(parameters);
                    c.EncodedValue = propertyValue;
                    vEvent.Contacts.Add(c);
                    break;

                case PropertyType.Organizer:
                    vEvent.Organizer.DeserializeParameters(parameters);
                    vEvent.Organizer.EncodedValue = propertyValue;
                    break;

                case PropertyType.Attendee:
                    AttendeeProperty ap = new AttendeeProperty();
                    ap.DeserializeParameters(parameters);
                    ap.EncodedValue = propertyValue;
                    vEvent.Attendees.Add(ap);
                    break;

                case PropertyType.RelatedTo:
                    RelatedToProperty rt = new RelatedToProperty();
                    rt.DeserializeParameters(parameters);
                    rt.EncodedValue = propertyValue;
                    vEvent.RelatedTo.Add(rt);
                    break;

                case PropertyType.Attachment:
                    AttachProperty att = new AttachProperty();
                    att.DeserializeParameters(parameters);
                    att.EncodedValue = propertyValue;
                    vEvent.Attachments.Add(att);
                    break;

                case PropertyType.RecurrenceId:
                    vEvent.RecurrenceId.DeserializeParameters(parameters);
                    vEvent.RecurrenceId.EncodedValue = propertyValue;
                    break;

                case PropertyType.Status:
                    vEvent.Status.DeserializeParameters(parameters);
                    vEvent.Status.EncodedValue = propertyValue;
                    break;

                case PropertyType.RequestStatus:
                    RequestStatusProperty rs = new RequestStatusProperty();
                    rs.DeserializeParameters(parameters);
                    rs.EncodedValue = propertyValue;
                    vEvent.RequestStatuses.Add(rs);
                    break;

                case PropertyType.Duration:
                    vEvent.Duration.DeserializeParameters(parameters);
                    vEvent.Duration.EncodedValue = propertyValue;
                    break;

                case PropertyType.AudioAlarm:
                case PropertyType.DisplayAlarm:
                case PropertyType.EMailAlarm:
                case PropertyType.ProcedureAlarm:
                    // These are converted to a VAlarm object
                    vAlarm = new VAlarm();
                    ParseVCalendarAlarm(ntvEvent[idx].EnumValue, parameters, propertyValue);
                    vEvent.Alarms.Add(vAlarm);
                    vAlarm = null;
                    break;

                case PropertyType.RecurrenceRule:
                    RRuleProperty rr = new RRuleProperty();
                    rr.DeserializeParameters(parameters);
                    rr.EncodedValue = propertyValue;
                    vEvent.RecurrenceRules.Add(rr);
                    break;

                case PropertyType.RecurDate:
                    // There may be more than one date in the value.  If so, split them into separate ones.  This
                    // makes it easier to manage.  They'll get written back out as individual properties but
                    // that's okay.
                    parts = propertyValue.Split(',', ';');

                    // It's important that we retain the same parameters for each one
                    parms = new string[parameters.Count];
                    parameters.CopyTo(parms, 0);

                    foreach(string s in parts)
                    {
                        sc = new StringCollection();
                        sc.AddRange(parms);

                        RDateProperty rd = new RDateProperty();
                        rd.DeserializeParameters(sc);
                        rd.EncodedValue = s;

                        vEvent.RecurDates.Add(rd);
                    }
                    break;

                case PropertyType.ExceptionRule:
                    ExRuleProperty er = new ExRuleProperty();
                    er.DeserializeParameters(parameters);
                    er.EncodedValue = propertyValue;
                    vEvent.ExceptionRules.Add(er);
                    break;

                case PropertyType.ExceptionDate:
                    // There may be more than one date in the value.  If so, split them into separate ones.  This
                    // makes it easier to manage.  They'll get written back out as individual properties but
                    // that's okay.
                    parts = propertyValue.Split(',', ';');

                    // It's important that we retain the same parameters for each one
                    parms = new string[parameters.Count];
                    parameters.CopyTo(parms, 0);

                    foreach(string s in parts)
                    {
                        sc = new StringCollection();
                        sc.AddRange(parms);

                        ExDateProperty ed = new ExDateProperty();
                        ed.DeserializeParameters(sc);
                        ed.EncodedValue = s;

                        vEvent.ExceptionDates.Add(ed);
                    }
                    break;

                case PropertyType.ExcludeStartDateTime:
                    // This is a custom property not defined by the spec
                    vEvent.ExcludeStartDateTime = (propertyValue[0] == '1');
                    break;

                default:    // Anything else is a custom property
                    CustomProperty cust = new CustomProperty(propertyName);
                    cust.DeserializeParameters(parameters);
                    cust.EncodedValue = propertyValue;
                    vEvent.CustomProperties.Add(cust);
                    break;
            }
        }
Beispiel #2
0
        /// <summary>
        /// This is used to parse vCalendar 1.0 alarm properties into a VAlarm object
        /// </summary>
        /// <param name="propertyType">The property type</param>
        /// <param name="parameters">The string collection containing the parameter values</param>
        /// <param name="propertyValue">The value of the property</param>
        /// <remarks>The VAlarm object has the ability to write itself out as a vCalendar 1.0 alarm type property
        /// or an iCalendar 2.0 VALARM component.  As such, individual properties do not exist for the vCalendar
        /// 1.0 AALARM, DALARM, MALARM, and PALARM properties.</remarks>
        protected virtual void ParseVCalendarAlarm(PropertyType propertyType, StringCollection parameters,
          string propertyValue)
        {
            string[] parts = propertyValue.Split(';');

            if(parts.Length != 0 && parts[0].Length > 0)
                vAlarm.Trigger.EncodedValue = parts[0];

            if(parts.Length > 1 && parts[1].Length > 0)
                vAlarm.Duration.EncodedValue = parts[1];

            if(parts.Length > 2 && parts[2].Length > 0)
                vAlarm.Repeat.EncodedValue = parts[2];

            switch(propertyType)
            {
                case PropertyType.AudioAlarm:
                    vAlarm.Action.Action = AlarmAction.Audio;

                    if(parts.Length > 3 && parts[3].Length > 0)
                    {
                        AttachProperty att = new AttachProperty();
                        att.DeserializeParameters(parameters);
                        att.EncodedValue = parts[3];
                        vAlarm.Attachments.Add(att);
                    }
                    break;

                case PropertyType.DisplayAlarm:
                    vAlarm.Action.Action = AlarmAction.Display;

                    if(parts.Length > 3 && parts[3].Length > 0)
                    {
                        vAlarm.Description.DeserializeParameters(parameters);
                        vAlarm.Description.EncodedValue = parts[3];
                    }
                    break;

                case PropertyType.EMailAlarm:
                    vAlarm.Action.Action = AlarmAction.EMail;

                    if(parts.Length > 3 && parts[3].Length > 0)
                    {
                        AttendeeProperty ap = new AttendeeProperty();
                        ap.DeserializeParameters(parameters);
                        ap.EncodedValue = parts[3];
                        vAlarm.Attendees.Add(ap);
                    }

                    if(parts.Length > 4 && parts[4].Length > 0)
                        vAlarm.Description.EncodedValue = parts[4];
                    break;

                case PropertyType.ProcedureAlarm:
                    vAlarm.Action.Action = AlarmAction.Procedure;

                    if(parts.Length > 3 && parts[3].Length > 0)
                    {
                        AttachProperty att = new AttachProperty();
                        att.DeserializeParameters(parameters);
                        att.EncodedValue = parts[3];
                        vAlarm.Attachments.Add(att);
                    }
                    break;
            }
        }
Beispiel #3
0
        /// <summary>
        /// This is implemented to handle properties related to VFreeBusy items
        /// </summary>
        /// <param name="propertyName">The name of the property.</param>
        /// <param name="parameters">A string collection containing the parameters and their values.  If empty,
        /// there are no parameters.</param>
        /// <param name="propertyValue">The value of the property.</param>
        protected virtual void VFreeBusyParser(string propertyName, StringCollection parameters, string propertyValue)
        {
            StringCollection sc;
            string[] parts, parms;
            int idx;

            // The last entry is always CustomProperty so scan for length minus one
            for(idx = 0; idx < ntvFreeBusy.Length - 1; idx++)
                if(ntvFreeBusy[idx].IsMatch(propertyName))
                    break;

            // An opening BEGIN:VFREEBUSY property must have been seen
            if(vFreeBusy == null)
                throw new PDIParserException(this.LineNumber, LR.GetString("ExParseNoBeginProp", "BEGIN:VFREEBUSY",
                    propertyName));

            // Handle or create the property
            switch(ntvFreeBusy[idx].EnumValue)
            {
                case PropertyType.Begin:    // Handle unknown nested objects
                    priorState.Push(currentState);
                    currentState = VCalendarParserState.Custom;
                    CustomObjectParser(propertyName, parameters, propertyValue);
                    break;

                case PropertyType.End:
                    // For this, the value must be VFREEBUSY
                    if(String.Compare(propertyValue.Trim(), "VFREEBUSY", StringComparison.OrdinalIgnoreCase) != 0)
                        throw new PDIParserException(this.LineNumber, LR.GetString("ExParseUnrecognizedTagValue",
                            ntvFreeBusy[idx].Name, propertyValue));

                    // The free/busy item is added to the collection when created so we don't have to rely on an
                    // END tag to add it.
                    vFreeBusy = null;
                    currentState = priorState.Pop();
                    break;

                case PropertyType.Url:
                    vFreeBusy.Url.DeserializeParameters(parameters);
                    vFreeBusy.Url.EncodedValue = propertyValue;
                    break;

                case PropertyType.UniqueId:
                    vFreeBusy.UniqueId.EncodedValue = propertyValue;
                    break;

                case PropertyType.StartDateTime:
                    vFreeBusy.StartDateTime.DeserializeParameters(parameters);
                    vFreeBusy.StartDateTime.EncodedValue = propertyValue;
                    break;

                case PropertyType.EndDateTime:
                    vFreeBusy.EndDateTime.DeserializeParameters(parameters);
                    vFreeBusy.EndDateTime.EncodedValue = propertyValue;
                    break;

                case PropertyType.Duration:
                    vFreeBusy.Duration.DeserializeParameters(parameters);
                    vFreeBusy.Duration.EncodedValue = propertyValue;
                    break;

                case PropertyType.TimeStamp:
                    vFreeBusy.TimeStamp.DeserializeParameters(parameters);
                    vFreeBusy.TimeStamp.EncodedValue = propertyValue;
                    break;

                case PropertyType.Comment:
                    // If this is seen more than once, just add the new stuff to the existing property
                    if(vFreeBusy.Comment.Value != null)
                    {
                        vFreeBusy.Comment.EncodedValue += "\r\n";
                        vFreeBusy.Comment.EncodedValue += propertyValue;
                    }
                    else
                    {
                        vFreeBusy.Comment.DeserializeParameters(parameters);
                        vFreeBusy.Comment.EncodedValue = propertyValue;
                    }
                    break;

                case PropertyType.Contact:
                    vFreeBusy.Contact.DeserializeParameters(parameters);
                    vFreeBusy.Contact.EncodedValue = propertyValue;
                    break;

                case PropertyType.Organizer:
                    vFreeBusy.Organizer.DeserializeParameters(parameters);
                    vFreeBusy.Organizer.EncodedValue = propertyValue;
                    break;

                case PropertyType.Attendee:
                    AttendeeProperty ap = new AttendeeProperty();
                    ap.DeserializeParameters(parameters);
                    ap.EncodedValue = propertyValue;
                    vFreeBusy.Attendees.Add(ap);
                    break;

                case PropertyType.RequestStatus:
                    RequestStatusProperty rs = new RequestStatusProperty();
                    rs.DeserializeParameters(parameters);
                    rs.EncodedValue = propertyValue;
                    vFreeBusy.RequestStatuses.Add(rs);
                    break;

                case PropertyType.FreeBusy:
                    // There may be more than one period in the value.  If so, split them into separate ones.
                    // This makes it easier to manage.  They'll get written back out as individual properties but
                    // that's okay.
                    parts = propertyValue.Split(',', ';');

                    // It's important that we retain the same parameters for each one
                    parms = new string[parameters.Count];
                    parameters.CopyTo(parms, 0);

                    foreach(string s in parts)
                    {
                        sc = new StringCollection();
                        sc.AddRange(parms);

                        FreeBusyProperty fb = new FreeBusyProperty();
                        fb.DeserializeParameters(sc);
                        fb.EncodedValue = s;

                        vFreeBusy.FreeBusy.Add(fb);
                    }
                    break;

                default:    // Anything else is a custom property
                    CustomProperty cust = new CustomProperty(propertyName);
                    cust.DeserializeParameters(parameters);
                    cust.EncodedValue = propertyValue;
                    vFreeBusy.CustomProperties.Add(cust);
                    break;
            }
        }
Beispiel #4
0
        /// <summary>
        /// This is implemented to handle properties related to VAlarm items
        /// </summary>
        /// <param name="propertyName">The name of the property.</param>
        /// <param name="parameters">A string collection containing the parameters and their values.  If empty,
        /// there are no parameters.</param>
        /// <param name="propertyValue">The value of the property.</param>
        protected virtual void VAlarmParser(string propertyName, StringCollection parameters, string propertyValue)
        {
            int idx;

            // The last entry is always CustomProperty so scan for length minus one
            for(idx = 0; idx < ntvAlarm.Length - 1; idx++)
                if(ntvAlarm[idx].IsMatch(propertyName))
                    break;

            // An opening BEGIN:VALARM property must have been seen
            if(vAlarm == null)
                throw new PDIParserException(this.LineNumber, LR.GetString("ExParseNoBeginProp", "BEGIN:VALARM",
                    propertyName));

            // Handle or create the property
            switch(ntvAlarm[idx].EnumValue)
            {
                case PropertyType.Begin:    // Handle unknown nested objects
                    priorState.Push(currentState);
                    currentState = VCalendarParserState.Custom;
                    CustomObjectParser(propertyName, parameters, propertyValue);
                    break;

                case PropertyType.End:
                    // For this, the value must be VALARM
                    if(String.Compare(propertyValue.Trim(), "VALARM", StringComparison.OrdinalIgnoreCase) != 0)
                        throw new PDIParserException(this.LineNumber, LR.GetString("ExParseUnrecognizedTagValue",
                            ntvAlarm[idx].Name, propertyValue));

                    // The alarm is added to the collection when created so we don't have to rely on an END tag
                    // to add it.
                    vAlarm = null;
                    currentState = priorState.Pop();
                    break;

                case PropertyType.Action:
                    vAlarm.Action.DeserializeParameters(parameters);
                    vAlarm.Action.EncodedValue = propertyValue;
                    break;

                case PropertyType.Trigger:
                    vAlarm.Trigger.DeserializeParameters(parameters);
                    vAlarm.Trigger.EncodedValue = propertyValue;
                    break;

                case PropertyType.Repeat:
                    vAlarm.Repeat.DeserializeParameters(parameters);
                    vAlarm.Repeat.EncodedValue = propertyValue;
                    break;

                case PropertyType.Duration:
                    vAlarm.Duration.DeserializeParameters(parameters);
                    vAlarm.Duration.EncodedValue = propertyValue;
                    break;

                case PropertyType.Summary:
                    vAlarm.Summary.DeserializeParameters(parameters);
                    vAlarm.Summary.EncodedValue = propertyValue;
                    break;

                case PropertyType.Description:
                    vAlarm.Description.DeserializeParameters(parameters);
                    vAlarm.Description.EncodedValue = propertyValue;
                    break;

                case PropertyType.Attendee:
                    AttendeeProperty ap = new AttendeeProperty();
                    ap.DeserializeParameters(parameters);
                    ap.EncodedValue = propertyValue;
                    vAlarm.Attendees.Add(ap);
                    break;

                case PropertyType.Attachment:
                    AttachProperty att = new AttachProperty();
                    att.DeserializeParameters(parameters);
                    att.EncodedValue = propertyValue;
                    vAlarm.Attachments.Add(att);
                    break;

                default:    // Anything else is a custom property
                    CustomProperty cust = new CustomProperty(propertyName);
                    cust.DeserializeParameters(parameters);
                    cust.EncodedValue = propertyValue;
                    vAlarm.CustomProperties.Add(cust);
                    break;
            }
        }