diff -r 000000000000 -r 8466d47a6819 meetingrequest/mragnversit2/src/cesmragnversit2importer.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/meetingrequest/mragnversit2/src/cesmragnversit2importer.cpp	Thu Dec 17 08:39:21 2009 +0200
@@ -0,0 +1,1860 @@
+/*
+* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: This file implements classes CTzNamedRules, CESMRAgnVersit2Importer. 
+*
+*/
+
+
+// Class include.
+#include "emailtrace.h"
+#include "cesmragnversit2importer.h"
+#include "cesmragnversit2exporter.h"
+
+//debug
+//<cmail>
+
+// Agenda includes.
+#include <calalarm.h>           // For CCalAlarm
+#include <calcategory.h>        // For CCalCategory
+#include <calentry.h>           // For CCalEntry
+#include <calrrule.h>           // For CCalRRule
+#include <caltime.h>            // For CCalTime
+#include <caluser.h>            // For CCalUser
+#include <tzdefines.h>          // For TTzRuleDay
+#include <vtzrules.h>           // For CTzRules and TTzRule
+
+// Versit includes.
+#include "cesmrical.h"              // for cical
+#include "cesmricalcomponent.h"     // for cicalcomponent
+#include "esmricalkeywords.h"       // for cicalkeywords
+#include "cesmricalparser.h"            // for cicalparser
+#include "cesmricalproperty.h"      // for cicalproperty
+#include "cesmricalpropertyparam.h" // for cicalpropertyparam
+#include "cesmricalrulesegment.h"   // for cicalrulesegment
+#include "cesmricalvalue.h"         // for cicalvalue
+
+// ESMRAgnVersit2 includes.
+#include "mesmragnimportobserver.h"         // For MESMRAgnImportObserver
+#include "cesmragnversit2stringprovider.h"  // For CESMRAgnVersit2StringProvider
+#include "esmrcleanuppointerarray.h"        // For TCleanupPointerArray
+
+#include "cesmragnrruleimporter.h"           // For CESMRAgnRRuleImporter
+#include "esmrhelper.h"
+
+// MRUI includes
+#include "esmrdef.h"
+//</cmail>
+
+// Constants.
+
+//
+//    CTzNamedRules
+//    =============
+//
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::CTzNamedRules::CTzNamedRules
+// ---------------------------------------------------------------------------
+//
+CESMRAgnVersit2Importer::CTzNamedRules::CTzNamedRules()
+    {
+    FUNC_LOG;
+    //do nothing
+    }
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::CTzNamedRules::~CTzNamedRules
+// ---------------------------------------------------------------------------
+//
+CESMRAgnVersit2Importer::CTzNamedRules::~CTzNamedRules()
+    {
+    FUNC_LOG;
+
+    delete iRules;
+    delete iName;
+
+    }
+
+//
+//     CESMRAgnVersit2Importer
+//     ===================
+//
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::NewL
+// ---------------------------------------------------------------------------
+//
+CESMRAgnVersit2Importer* CESMRAgnVersit2Importer::NewL(CESMRAgnVersit2StringProvider& aStringProvider)
+    {
+    FUNC_LOG;
+
+    CESMRAgnVersit2Importer* self = CESMRAgnVersit2Importer::NewLC(aStringProvider);
+    CleanupStack::Pop(self);
+
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::NewLC
+// ---------------------------------------------------------------------------
+//
+CESMRAgnVersit2Importer* CESMRAgnVersit2Importer::NewLC(CESMRAgnVersit2StringProvider& aStringProvider)
+    {
+    FUNC_LOG;
+
+    CESMRAgnVersit2Importer* self = new (ELeave) CESMRAgnVersit2Importer(aStringProvider);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::NewL
+// ---------------------------------------------------------------------------
+//
+CESMRAgnVersit2Importer::~CESMRAgnVersit2Importer()
+    {
+    FUNC_LOG;
+
+    iTzRules.ResetAndDestroy();
+
+    }
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::ImportL
+// ---------------------------------------------------------------------------
+//
+void CESMRAgnVersit2Importer::ImportL( RPointerArray<CCalEntry>& aEntries,
+                                   RReadStream& aReadStream,
+                                   MESMRAgnImportObserver& aObserver )
+    {
+    FUNC_LOG;
+
+    iImportObserver = &aObserver;
+
+    CESMRICalParser* parser = CESMRICalParser::NewLC();
+    parser->InternalizeL(aReadStream);
+
+    const TInt count = parser->CalCount();
+
+    for (TInt cal = 0; cal < count; ++cal)
+        {
+        CESMRICal& calendar = parser->Cal(cal);
+        TRAPD(err, ImportICalL(aEntries, calendar));
+        iTzRules.ResetAndDestroy();
+        User::LeaveIfError(err);
+        }
+
+    CleanupStack::PopAndDestroy(parser);
+    }
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::CESMRAgnVersit2Importer
+// ---------------------------------------------------------------------------
+//
+CESMRAgnVersit2Importer::CESMRAgnVersit2Importer(CESMRAgnVersit2StringProvider& aStringProvider)
+    : iStringProvider(aStringProvider)
+    {
+    FUNC_LOG;
+    //do nothing
+    }
+
+// ---------------------------------------------------------------------------
+// CESMRAgnVersit2Importer::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CESMRAgnVersit2Importer::ConstructL()
+    {
+    FUNC_LOG;
+    //do nothing
+    }
+
+/**
+ * Takes a calendar object from Versit2 and converts it into a set of CCalEntry
+ * objects.
+ * @param aEntries The array to append entries to.
+ * @param aCal An object of type CESMRICal from which to obtain data.
+ * @leave KErrAbort, or any other system wide error code.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportICalL(RPointerArray<CCalEntry>& aEntries, CESMRICal& aCal)
+    {
+    FUNC_LOG;
+
+    const RPointerArray<CESMRICalComponent>& components = aCal.Components();
+
+    // Run through the timezones so that we know what other components are referring to:
+    iTzRules.ResetAndDestroy();
+    TInt com; // current component number
+    TInt comCount = components.Count();
+    for (com = 0; com < comCount && iResponse == MESMRAgnImportObserver::EImpResponseContinue; ++com)
+        {
+        CESMRICalComponent* component = components[com];
+
+        // We are only interested in timezones:
+        if (component->Type() == CESMRICalBase::EICalTimeZone)
+            {
+            TRAPD(err, ImportTimezoneL(*component));
+            if (err)
+                {
+                // If there isn't a response, then it isn't a recoverable leave:
+                if (iResponse == MESMRAgnImportObserver::EImpResponseContinue)
+                    {
+                    User::Leave(err);
+                    }
+                // If there is a response, then we threw this after reporting an
+                // error to the observer, and we may be able to continue:
+                else if(iResponse == MESMRAgnImportObserver::EImpResponseSkip)
+                    {
+                    iResponse = MESMRAgnImportObserver::EImpResponseContinue;
+                    }
+                }
+            }
+        }
+
+    // Run through the other components:
+    for (com = 0; com < comCount && iResponse == MESMRAgnImportObserver::EImpResponseContinue; ++com)
+        {
+        CESMRICalComponent* component = components[com];
+
+        // We aren't interested in timezones:
+        if (component->Type() != CESMRICalBase::EICalTimeZone)
+            {
+            TRAPD(err, ImportComponentL(aCal, *component, aEntries));
+            if (err)
+                {
+                // If there isn't a response, then it isn't a recoverable leave:
+                if (iResponse == MESMRAgnImportObserver::EImpResponseContinue)
+                    {
+                    User::Leave(err);
+                    }
+                // If there is a response, then we threw this after reporting an
+                // error to the observer, and we may be able to continue:
+                else if(iResponse == MESMRAgnImportObserver::EImpResponseSkip)
+                    {
+                    iResponse = MESMRAgnImportObserver::EImpResponseContinue;
+                    }
+                }
+            }
+        }
+
+    // If we have been asked to leave after an error, do so:
+    if (iResponse == MESMRAgnImportObserver::EImpResponseLeave)
+        {
+        User::Leave(KErrAbort);
+        }
+
+    }
+
+/**
+*     IMPORT COMPONENT FUNCTIONS
+*     ==========================
+*/
+
+/**
+ * Handles the importing of a single component, other than a timezone.
+ * @param aCal The calendar object from which we are importing
+ * @param aComponent The specific component we are importing
+ * @param aEntries The agenda entries onto which this component is to be appended.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportComponentL( const CESMRICal& aCal,
+                                            const CESMRICalComponent& aComponent,
+                                            RPointerArray<CCalEntry>& aEntries )
+    {
+    FUNC_LOG;
+
+    // Get the UID:
+    HBufC8* entryUid = NULL;
+    const CESMRICalProperty* propUid = aComponent.FindProperty(KICalUid());
+
+
+    if (!propUid)//(propUid && propUid->Values().Count() < 1)
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorInvalidData, KNullDesC8, KICalUid, EFalse);
+        // We do not continue without a UID.
+        }
+
+    //if (propUid)
+    else
+        {
+        entryUid = propUid->Values()[0]->BinaryLC();
+
+        // Import entry-type specific data:
+        switch (aComponent.Type())
+            {
+            case CESMRICalBase::EICalEvent :
+                {
+                CCalEntry::TType eventType = CCalEntry::EEvent;
+
+                //Check if we have a DTEND or DURATION
+                if (aComponent.FindProperty(KICalDtend()) || aComponent.FindProperty(KICalDuration()))
+                    {
+                    eventType = CCalEntry::EAppt;
+                    }
+
+                else
+                    {
+                    //Check if we have a DTSTART
+                    if (aComponent.FindProperty(KICalDtstart()))
+                        {
+                        eventType = CCalEntry::EReminder;
+                        }
+
+                    //Check if this is a yearly repeat
+                    if (aComponent.FindProperty(KICalRRule()))
+                        {
+                        const CESMRICalProperty* rrule = aComponent.FindProperty(KICalRRule());
+                        const RPointerArray<CESMRICalValue>& rulevalues = rrule->Values();
+
+                        if (rulevalues.Count() >= 1)
+                            {
+                            CESMRICalRuleSegment::TFreq freq = CESMRICalRuleSegment::EFreqDaily;
+                            RPointerArray<CESMRICalRuleSegment> recRules;
+                            CleanupPointerArrayPushL(recRules);
+
+                            // At this point we take ownership of the things which rules contains:
+                            rulevalues[0]->GetRecurrenceRuleL(recRules);
+
+                            // An RRule must have a frequency.
+                            TInt pos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegFreq);
+                            if (pos != KErrNotFound)
+                                {
+                                ASSERT(recRules.Count() >= pos + 1);
+                                freq = recRules[pos]->FreqL();
+                                }
+
+                            // Find the interval.
+                            pos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegInterval);
+                            TInt interval = 1; //default value if no INTERVAL specified
+                            if (pos != KErrNotFound)
+                                {
+                                ASSERT(recRules[pos]->Values().Count() >= 0);
+                                interval = recRules[pos]->Values()[0]->IntegerL();
+                                }
+
+                            if ((freq == CESMRICalRuleSegment::EFreqYearly) && (interval == 1))
+                                {
+                                //Anniversary repeats once a year
+                                eventType = CCalEntry::EAnniv;
+                                }
+
+                            CleanupStack::PopAndDestroy(&recRules);
+                            }
+                        }
+                    }
+                CleanupStack::Pop(entryUid);
+                // Passing ownership of entryUid
+                ImportEntryL(aCal, aComponent, aEntries, entryUid, eventType);
+
+                break;
+                }
+            case CESMRICalBase::EICalTodo :
+                CleanupStack::Pop(entryUid);
+                // Passing ownership of entryUid
+                ImportEntryL(aCal, aComponent, aEntries, entryUid, CCalEntry::ETodo);
+                break;
+            case CESMRICalBase::EICalJournal :
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, *entryUid, KICalJournal, EFalse);
+                // Continue equates to skip in this instance.
+                break;
+            case CESMRICalBase::EICalAlarm :
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorInvalidData, *entryUid, KICalAlarm, EFalse);
+                // Continue equates to skip in this instance.
+                break;
+            case CESMRICalBase::EICalFreeBusy :
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, *entryUid, KICalFreeBusy, EFalse);
+                // Continue equates to skip in this instance.
+                break;
+            case CESMRICalBase::EICalInvalid :  // not valid here, fall through
+            case CESMRICalBase::EICalCalendar : // not valid here, fall through
+            case CESMRICalBase::EICalTimeZone : // not valid here, fall through
+            case CESMRICalBase::EICalStandard : // not valid here, fall through
+            case CESMRICalBase::EICalDaylight : // not valid here, fall through
+            default :
+                ReportErrorL( MESMRAgnImportObserver::EImpErrorInvalidData,
+                              *entryUid,
+                              aComponent.TypeStringL(),
+                              EFalse );
+                // Continue equates to skip in this instance.
+                break;
+            }
+        }
+    }
+
+/**
+ * Checks for a VALARM in a component. If a valid one is found, it is added to the
+ * specified entry.
+ * @param aComponent Component to search for a VALARM in.
+ * @param aEntry Alarm is added to this calendar entry.
+ * @param aUid UID of the component.
+ * @param aStartTime A pointer to the DTSTART of the parent component, if it has
+ * one, or NULL if it does not. This does not take ownership.
+ * @return MESMRAgnImportObserver::TImpResponse indicating application response to errors, if any.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportAlarmL( const CESMRICalComponent& aComponent,
+                                        CCalEntry& aEntry,
+                                        const HBufC8& aUid,
+                                        const TCalTime* aStartTime )
+    {
+    FUNC_LOG;
+
+    if (aComponent.ComponentExists(CESMRICalBase::EICalAlarm))
+        {
+        // Check the outer component is a VEVENT or a VTODO
+        if (aComponent.Type() == CESMRICalBase::EICalEvent || aComponent.Type() == CESMRICalBase::EICalTodo)
+            {
+            const RPointerArray<CESMRICalComponent>& nestedComponents = aComponent.Components();
+            // Iterate through all the nested components and create a new alarm for each VALARM component
+            TInt nestedComCount = nestedComponents.Count();
+            for (TInt i = 0; i < nestedComCount; i++)
+                {
+                if (nestedComponents[i]->Type() == CESMRICalBase::EICalAlarm)
+                    {
+                    CCalAlarm* alarm = CCalAlarm::NewL();
+                    CleanupStack::PushL(alarm);
+                    const RPointerArray<CESMRICalProperty>& nestedProperties = nestedComponents[i]->Properties();
+                    // Go through all the nested properties until we find the TRIGGER
+                    // Ignore REPEAT and DURATION + any others
+                    TBool foundTrigger=EFalse;
+                    TInt nestedPropCount = nestedProperties.Count();
+                    for (TInt j = 0; j < nestedPropCount; j++)
+                        {
+                        if (nestedProperties[j]->Type() == KICalTrigger)
+                            {
+                            const RPointerArray<CESMRICalValue>& values = nestedProperties[j]->Values();
+                            // There should only be one value, don't try to add the alarm if there are more
+                            if (values.Count() == 1)
+                                {
+                                const CESMRICalPropertyParam* valueType = nestedProperties[j]->FindParam(KICalValue);
+                                TTimeIntervalMinutes duration;
+                                if (valueType) // Only DATE-TIME is legal here - assume it's that one.
+                                    {
+                                    if (!aStartTime)
+                                        {
+                                        ReportErrorL( MESMRAgnImportObserver::EImpErrorMissingData,
+                                                      aUid,
+                                                      iStringProvider.StringL(EICalErrValarmNoStart),
+                                                      EFalse );
+                                        // On continue, we skip the alarm.
+                                        }
+                                    else
+                                        {
+                                        TCalTime absTime;
+                                        GetCalTimeL(*nestedProperties[j], absTime, EDateTime);
+                                        aStartTime->TimeUtcL().MinutesFrom(absTime.TimeUtcL(), duration);
+                                        }
+                                    }
+                                else
+                                    {
+                                    duration = values[0]->DurationL().Int() / KSecondsInOneMinute;
+                                    }
+
+                                // Only negative durations are allowed (the alarm must be *before* the event).
+                                if (duration.Int() > 0)
+                                    {
+                                    ReportErrorL( MESMRAgnImportObserver::EImpErrorNotSupported,
+                                                  aUid,
+                                                  iStringProvider.StringL(EICalErrAlarmAfterEvent) );
+                                    // On continue, the duration will be made "negative".
+                                    }
+
+                                // Agenda expects a positive duration - convert the sign.
+                                if (duration.Int() < 0)
+                                    {
+                                    duration = -(duration.Int());
+                                    }
+
+                                alarm->SetTimeOffset(duration);
+                                foundTrigger=ETrue;
+                                }
+                            }
+                        }
+                    if (foundTrigger)
+                        {
+                        aEntry.SetAlarmL(alarm);// Doesn't take ownership
+                        }
+                    else
+                        {
+                        ReportErrorL( MESMRAgnImportObserver::EImpErrorMissingData,
+                                      aUid,
+                                      iStringProvider.StringL(EICalErrValarmNoTrigger),
+                                      EFalse );
+                        // On continue, the alarm will be skipped.
+                        }
+                    CleanupStack::PopAndDestroy(alarm);
+                    }
+                }
+            }
+        else
+            {
+            ReportErrorL( MESMRAgnImportObserver::EImpErrorInvalidData,
+                          aUid,
+                          iStringProvider.StringL(EICalErrValarmNotAllowed),
+                          EFalse );
+            // On continue, the alarm will be skipped.
+            }
+        }
+
+    }
+
+
+/**
+ * Performs most of the work of importing a component from an iCalendar, provided
+ * that the component is one which can be handled as a CCalEntry. Timezone and
+ * Alarm components are not imported in this manner.
+ * @param aCal The calendar object containing the component.
+ * @param aComponent The component to be imported.
+ * @param aEntries The array onto which to append the new entry.
+ * @param aUid The UID of the component (takes ownership).
+ * @param aType The type of entry being imoported
+ * @return MESMRAgnImportObserver::TImpResponse indicating application response to errors, if any.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportEntryL( const CESMRICal& aCal,
+                                        const CESMRICalComponent& aComponent,
+                                        RPointerArray<CCalEntry>& aEntries,
+                                        HBufC8* aUid,
+                                        CCalEntry::TType aType )
+    {
+    FUNC_LOG;
+
+    // Create a basic entry to add properties to.
+    CCalEntry* entry = CreateEntryLC(aCal, aComponent, aUid, aType); // takes ownership of aUid
+
+    iNeedsTzRules = (EFalse);
+    iCurrentTzRules = NULL;
+
+    // set the entry properties:
+    CESMRICalProperty* rruleproperty = NULL;
+    CESMRICalProperty* startproperty = NULL;
+    CESMRICalProperty* endproperty = NULL;
+    CESMRICalProperty* durationproperty = NULL;
+    RPointerArray<CESMRICalProperty> exDateProperties;
+    CleanupClosePushL(exDateProperties);
+    RPointerArray<CESMRICalProperty> rDateProperties;
+    CleanupClosePushL(rDateProperties);
+
+    const RPointerArray<CESMRICalProperty>& properties = aComponent.Properties();
+    TInt propCount = properties.Count();
+    for (TInt pnum = 0; pnum < propCount; ++pnum)
+        {
+        CESMRICalProperty* property = properties[pnum];
+
+        // DTSTART, DTEND, DURATION, EXDATE, RDATE and RRULE need special handling,
+        //as they affect one another.
+        if (property->Type().CompareF(KICalRRule) == 0)
+            {
+            rruleproperty = property;
+            }
+        else if (property->Type().CompareF(KICalDtstart) == 0)
+            {
+            startproperty = property;
+            }
+        else if (property->Type().CompareF(KICalDtend) == 0)
+            {
+            endproperty = property;
+            }
+        else if (property->Type().CompareF(KICalDuration) == 0)
+            {
+            durationproperty = property;
+            }
+        else if (property->Type().CompareF(KICalExdate) == 0)
+            {
+            // It is valid to have more than one EXDATE property. We store them all in an array.
+            User::LeaveIfError(exDateProperties.Append(property));
+            }
+        else if (property->Type().CompareF(KICalRdate) == 0)
+            {
+            // It is valid to have more than one RDATE property. We store them all in an array.
+            User::LeaveIfError(rDateProperties.Append(property));
+            }
+        else
+            {
+            ImportPropertyL(*entry, *property);
+            }
+        }
+
+    // We cannot handle a DTSTART, DTEND or DURATION field on its own, so we have saved them up
+    // and will sort them out here.
+    // In theory, some methods allow an event to specify an end time but no start time.
+    // We have no way of dealing with this so we discard it.  When we get a start time
+    // with no end time, we assume a duration of 0 seconds.
+    TCalTime start;
+    TCalTime end;
+    if (startproperty)
+        {
+        GetCalTimeL(*startproperty, start, EDateTime);
+        end = start;
+        if (endproperty)
+            {
+            GetCalTimeL(*endproperty, end, EDateTime);
+            }
+        else if (durationproperty && startproperty)
+            {
+            if (durationproperty->Values().Count() < 1)
+                {
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, *aUid, KICalDuration);
+                // On continue use the start time as the end time (a duration of 0 seconds)
+                }
+            else
+                {
+                end.SetTimeUtcL(start.TimeUtcL() + durationproperty->Values()[0]->DurationL());
+                }
+            }
+        entry->SetStartAndEndTimeL(start, end);
+        }
+
+    // We must have a start time before we can interpret some alarms:
+    TRAPD(alarmerr, ImportAlarmL(aComponent, *entry, *aUid, startproperty?&start:0));
+    // If we fail and elect to skip whilst importing the alarm, continue
+    // with the current component.
+    if (alarmerr && iResponse == MESMRAgnImportObserver::EImpResponseSkip)
+        {
+        iResponse = MESMRAgnImportObserver::EImpResponseContinue;
+        }
+    else
+        {
+        User::LeaveIfError(alarmerr);
+        }
+
+    // We cannot put an rrule property into the agenda model format until we
+    // have properties such as dtstart already stored, so we do this last:
+    if (rruleproperty)
+        {
+        if (startproperty)
+            {
+            if (ImportRRuleL(*rruleproperty, *entry, start))
+                {
+                // APINOTE: In the Cal Interim API EXDATE is only valid with an RRULE.
+                // This is not necessarily so for iTIP updates.
+                for (TInt i = 0; i < exDateProperties.Count(); i++)
+                    {
+                    ImportPropertyL(*entry, *(exDateProperties[i]));
+                    }
+                }
+            else if (exDateProperties.Count() > 0)
+                {
+                // Cannot process an EXDATE without an RRULE.
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, *aUid, KICalExdate);
+                }
+            }
+        else
+            {
+            // Cannot process an RRULE without a DTSTART
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, *aUid, KICalDtstart);
+            }
+        }
+
+
+    // RDATE does not neccessary need an RRULE.
+    for (TInt i = 0; i < rDateProperties.Count(); i++)
+        {
+        ImportPropertyL(*entry, *(rDateProperties[i]));
+        }
+
+    CleanupStack::PopAndDestroy(&rDateProperties);
+    CleanupStack::PopAndDestroy(&exDateProperties);
+
+    // APINOTE: When setting the RRULE, the API overwrites the DTEND field.
+    // This block sets it back to what it should be.
+    if (startproperty)
+        {
+        // We don't need to check for an end time as it gets initialised when the
+        // start time gets set.
+        entry->SetStartAndEndTimeL(start, end);
+        }
+
+    // If we have set up a timezone, add this to the entry.
+    // Only entries with RDATES, EXDATES, RRULES or EXRULES will have this.
+    if (iNeedsTzRules)
+        {
+        if (iCurrentTzRules)
+            {
+            entry->SetTzRulesL(*iCurrentTzRules);
+            }
+        }
+
+    //Set the last modified date to current time
+    entry->SetLastModifiedDateL();
+    // Store the entry:
+    User::LeaveIfError(aEntries.Append(entry)); // Takes ownership if successful
+    CleanupStack::Pop(entry);
+
+    }
+
+/**
+ * Creates a new entry and pushes it onto the cleanup stack.
+ * @param aCal The calendar object containing the component.
+ * @param aComponent The component to be imported.
+ * @param aUid The UID of the component (takes ownership).
+ * @param aType The type of entry being imoported
+ * @return A new CCalEntry, or zero if a recoverable error occurs and the observer
+ * elects not to continue from it.
+ * @internalTechnology
+ */
+CCalEntry * CESMRAgnVersit2Importer::CreateEntryLC( const CESMRICal& aCal,
+                                                const CESMRICalComponent& aComponent,
+                                                HBufC8* aUid,
+                                                CCalEntry::TType aType )
+    {
+
+    CleanupStack::PushL(aUid);
+
+    const CESMRICalProperty* propSeq = aComponent.FindProperty(KICalSequence);
+
+    // Find the sequence number, but accept a default of 0 if there isn't one:
+    TUint entrySeq = 0;
+    if (propSeq && propSeq->Values().Count() > 0)
+        {
+        entrySeq = propSeq->Values()[0]->IntegerL();
+        }
+
+    // Find the method, but accept a default of EMethodNone if there isn't one:
+    CCalEntry::TMethod method = CCalEntry::EMethodNone;
+    const CESMRICalProperty* prop = aCal.FindProperty(KICalMethod);
+    if (prop && prop->Values().Count() > 0)
+        {
+        TPtrC val;
+        val.Set(prop->Values()[0]->TextL());
+        if (val.CompareF(KICalPublish) == 0)
+            {
+            method = CCalEntry::EMethodPublish;
+            }
+        else if (val.CompareF(KICalRequest) == 0)
+            {
+            method = CCalEntry::EMethodRequest;
+            }
+        else if (val.CompareF(KICalReply) == 0)
+            {
+            method = CCalEntry::EMethodReply;
+            }
+        else if (val.CompareF(KICalAdd) == 0)
+            {
+            method = CCalEntry::EMethodAdd;
+            }
+        else if (val.CompareF(KICalCancel) == 0)
+            {
+            method = CCalEntry::EMethodCancel;
+            }
+        else if (val.CompareF(KICalRefresh) == 0)
+            {
+            method = CCalEntry::EMethodRefresh;
+            }
+        else if (val.CompareF(KICalCounter) == 0)
+            {
+            method = CCalEntry::EMethodCounter;
+            }
+        else if (val.CompareF(KICalDeclineCounter) == 0)
+            {
+            method = CCalEntry::EMethodDeclineCounter;
+            }
+        else
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorInvalidData, *aUid, val);
+            // On continue, use EMethodNone.
+            }
+        }
+
+    CCalEntry* entry = NULL;
+    // Find the recurrence information, if there is any:
+    const CESMRICalProperty* propRecurrenceId = aComponent.FindProperty(KICalRecurrenceId);
+    if (propRecurrenceId)
+        {
+        TCalTime entryRecId;
+        GetCalTimeL(*propRecurrenceId, entryRecId, EDateTime);
+
+        const CESMRICalPropertyParam* range = propRecurrenceId->FindParam(KICalRange);
+        CalCommon::TRecurrenceRange entryRange = CalCommon::EThisOnly;
+        if (range && range->Values().Count() > 0)
+            {
+            if (range->Values()[0]->TextL().CompareF(KICalThisAndPrior) == 0)
+                {
+                entryRange = CalCommon::EThisAndPrior;
+                }
+            else if (range->Values()[0]->TextL().CompareF(KICalThisAndFuture) == 0)
+                {
+                entryRange = CalCommon::EThisAndFuture;
+                }
+            else
+                {
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorInvalidData, *aUid, range->Values()[0]->TextL());
+                // On continue, assume this instance only.
+                }
+            }
+        // Create an entry with recurrence data:
+        // Passing ownership of aUid
+        CleanupStack::Pop(aUid);
+        entry = CCalEntry::NewL(aType, aUid, method, entrySeq, entryRecId, entryRange);
+        CleanupStack::PushL(entry);
+        }
+    else
+        {
+        // Create an entry without recurrence data:
+        // Passing ownership of aUid
+        CleanupStack::Pop(aUid);
+        entry = CCalEntry::NewL(aType, aUid, method, entrySeq);
+        CleanupStack::PushL(entry);
+        }
+
+    return entry;
+    }
+
+/**
+ * Imports an individual property and adds it to an entry.
+ * @param aEntry The entry to which the property is to be added.
+ * @param aProperty The property to add.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportPropertyL(CCalEntry& aEntry, const CESMRICalProperty& aProperty)
+    {
+    FUNC_LOG;
+
+    if (aProperty.Type().CompareF(KICalAttendee) == 0)
+        {
+        // Find the paramaters we need:
+        CESMRICalValue* address = aProperty.Values()[0];
+        const CESMRICalPropertyParam* sentBy = aProperty.FindParam(KICalSentBy);
+        const CESMRICalPropertyParam* role = aProperty.FindParam(KICalRole);
+        const CESMRICalPropertyParam* status = aProperty.FindParam(KICalPartStat);
+        const CESMRICalPropertyParam* rsvp = aProperty.FindParam(KICalRsvp);
+        const CESMRICalPropertyParam* cn = aProperty.FindParam(KICalCn);
+        // The role:
+        CCalAttendee::TCalRole roleVal = CCalAttendee::EReqParticipant;
+        if (role && role->Values().Count() > 0)
+            {
+            CESMRICalValue* theVal = role->Values()[0];
+            if (theVal->TextL().CompareF(KICalChair) == 0)
+                {
+                roleVal = CCalAttendee::EChair;
+                }
+            else if (theVal->TextL().CompareF(KICalOptParticipant) == 0)
+                {
+                roleVal = CCalAttendee::EOptParticipant;
+                }
+            else if (theVal->TextL().CompareF(KICalNonParticipant) == 0)
+                {
+                roleVal = CCalAttendee::ENonParticipant;
+                }
+
+            }
+        // The status:
+        CCalAttendee::TCalStatus statusVal = CCalAttendee::ENeedsAction;
+        if (status && status->Values().Count() > 0)
+            {
+            CESMRICalValue* theVal = status->Values()[0];
+            if (theVal->TextL().CompareF(KICalAccepted) == 0)
+                {
+                statusVal = CCalAttendee::EAccepted;
+                }
+            else if (theVal->TextL().CompareF(KICalDeclined) == 0)
+                {
+                statusVal = CCalAttendee::EDeclined;
+                }
+            else if (theVal->TextL().CompareF(KICalTentative) == 0)
+                {
+                statusVal = CCalAttendee::ETentative;
+                }
+            else if (theVal->TextL().CompareF(KICalDelegated) == 0)
+                {
+                statusVal = CCalAttendee::EDelegated;
+                }
+            else if (theVal->TextL().CompareF(KICalCompleted) == 0)
+                {
+                statusVal = CCalAttendee::ECompleted;
+                }
+            else if (theVal->TextL().CompareF(KICalInProcess) == 0)
+                {
+                statusVal = CCalAttendee::EInProcess;
+                }
+            }
+        // The RSVP:
+        TBool rsvpVal = EFalse;
+        if (rsvp && rsvp->Values().Count() > 0)
+            {
+            rsvpVal = rsvp->Values()[0]->BooleanL();
+            }
+
+        // The complete attendee:
+        CCalAttendee* attendee;
+        if (sentBy && sentBy->Values().Count() > 0)
+            {
+            attendee = CCalAttendee::NewL(
+                            address->TextL(),
+                            sentBy->Values()[0]->TextL());
+            }
+        else
+            {
+            HBufC* buf =
+                    ESMRHelper::AddressWithoutMailtoPrefix(
+                            address->TextL() ).AllocLC();
+
+            attendee = CCalAttendee::NewL( buf->Des() );
+            CleanupStack::PopAndDestroy( buf );
+            buf = NULL;
+            }
+        CleanupStack::PushL(attendee);
+        if (cn && cn->Values().Count() > 0)
+            {
+            attendee->SetCommonNameL(cn->Values()[0]->TextL());
+            }
+        attendee->SetRoleL(roleVal);
+        attendee->SetStatusL(statusVal);
+        attendee->SetResponseRequested(rsvpVal);
+        // Add the attendee:
+        CleanupStack::Pop(attendee);
+        // Passing ownership of attendee
+        aEntry.AddAttendeeL(attendee);
+        }
+    else if (aProperty.Type().CompareF(KICalCategories) == 0)
+        {
+        ImportCategoriesL(aProperty, aEntry);
+        }
+    else if (aProperty.Type().CompareF(KICalClass) == 0)
+        {
+        ImportClassL(aProperty, aEntry);
+        }
+    else if (aProperty.Type().CompareF(KICalDescription) == 0)
+        {
+        if (aProperty.Values().Count() < 1)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);
+            // On continue ignore the description.
+            }
+        else
+            {
+            aEntry.SetDescriptionL(aProperty.Values()[0]->TextL());
+            }
+        }
+    else if (aProperty.Type().CompareF(KICalLocation) == 0)
+        {
+        // CCalEntry only supports one location, so bundle them all
+        // together into one descriptor.
+        TInt numLocations = aProperty.Values().Count();
+
+        if (numLocations > 0)
+            {
+            HBufC* loc (aProperty.Values()[0]->TextL().AllocLC());
+
+            for (TInt i = 1; i < numLocations; i++)
+                {
+                HBufC* oldLoc = loc;
+                loc = loc->ReAllocL(loc->Length() + aProperty.Values()[i]->TextL().Length() + 1);
+                CleanupStack::Pop(oldLoc); // location of loc has changed, cleanupstack needs updating
+                CleanupStack::PushL(loc);
+                loc->Des().Append(KICalComma);
+                loc->Des().Append(aProperty.Values()[i]->TextL());
+                }
+
+            aEntry.SetLocationL(*loc);
+            CleanupStack::PopAndDestroy(loc);
+            }
+        }
+    else if (aProperty.Type().CompareF(KICalOrganizer) == 0)
+        {
+        if (aProperty.Values().Count() < 1)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalOrganizer);
+            // On continue ignore the organizer.
+            }
+        else
+            {
+            CESMRICalValue* address = aProperty.Values()[0];
+            const CESMRICalPropertyParam* sentBy = aProperty.FindParam(KICalSentBy);
+            const CESMRICalPropertyParam* cn = aProperty.FindParam(KICalCn);
+            CCalUser* user = NULL;
+            if (sentBy && sentBy->Values().Count() > 0)
+                {
+                user = CCalAttendee::NewL(address->TextL(), sentBy->Values()[0]->TextL());
+                }
+            else
+                {
+                HBufC* buf = ESMRHelper::AddressWithoutMailtoPrefix(
+                                address->TextL() ).AllocLC();
+                
+                user = CCalAttendee::NewL( buf->Des() );
+                CleanupStack::PopAndDestroy( buf );
+                buf = NULL;
+                }
+            CleanupStack::PushL(user);
+            if (cn && cn->Values().Count() > 0)
+                {
+                user->SetCommonNameL(cn->Values()[0]->TextL());
+                }
+            CleanupStack::Pop(user);
+            // Passing ownership of user
+            aEntry.SetOrganizerL(user);
+            }
+        }
+    else if (aProperty.Type().CompareF(KICalRdate) == 0)
+        {
+        iNeedsTzRules = ETrue;
+        RArray<TCalTime> dates;
+        CleanupClosePushL(dates);
+        aEntry.GetRDatesL(dates);
+        TInt valCount = aProperty.Values().Count();
+        for (TInt dnum = 0; dnum < valCount; ++dnum)
+            {
+            TCalTime time;
+            GetCalTimeL(aProperty, time, EDateTime, dnum);
+            User::LeaveIfError(dates.Append(time));
+            }
+        aEntry.SetRDatesL(dates);
+        CleanupStack::PopAndDestroy(&dates);
+        }
+    else if (aProperty.Type().CompareF(KICalExdate) == 0)
+        {
+        iNeedsTzRules = ETrue;
+        RArray<TCalTime> dates;
+        CleanupClosePushL(dates);
+        aEntry.GetExceptionDatesL(dates);
+        TInt valCount = aProperty.Values().Count();
+        for (TInt dnum = 0; dnum < valCount; ++dnum)
+            {
+            TCalTime time;
+            GetCalTimeL(aProperty, time, EDateTime, dnum);
+            User::LeaveIfError(dates.Append(time));
+            }
+        aEntry.SetExceptionDatesL(dates);
+        CleanupStack::PopAndDestroy(&dates);
+        }
+    else if (aProperty.Type().CompareF(KICalStatus) == 0)
+        {
+        if (aProperty.Values().Count() < 1)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);
+            // On continue ignore the status.
+            }
+        else
+            {
+            TPtrC statstr(aProperty.Values()[0]->TextL());
+            if (statstr.CompareF(KICalTentative) == 0)
+                {
+                aEntry.SetStatusL(CCalEntry::ETentative);
+                }
+            else if (statstr.CompareF(KICalConfirmed) == 0)
+                {
+                aEntry.SetStatusL(CCalEntry::EConfirmed);
+                }
+            else if (statstr.CompareF(KICalCancelled) == 0)
+                {
+                aEntry.SetStatusL(CCalEntry::ECancelled);
+                }
+            else if (statstr.CompareF(KICalNeedsAction) == 0)
+                {
+                aEntry.SetStatusL(CCalEntry::ETodoNeedsAction);
+                }
+            else if (statstr.CompareF(KICalCompleted) == 0)
+                {
+                aEntry.SetStatusL(CCalEntry::ETodoCompleted);
+                }
+            else if (statstr.CompareF(KICalInProcess) == 0)
+                {
+                aEntry.SetStatusL(CCalEntry::ETodoInProcess);
+                }
+            else
+                {
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, aEntry.UidL(), statstr);
+                // On continue ignore the status.
+                }
+            }
+        }
+    else if (aProperty.Type().CompareF(KICalSummary) == 0)
+        {
+        if (aProperty.Values().Count() < 1)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);
+            // On continue ignore the summary.
+            }
+        else
+            {
+            aEntry.SetSummaryL(aProperty.Values()[0]->TextL());
+            }
+        }
+    else if (aProperty.Type().CompareF(KICalPriority) == 0)
+        {
+        if (aProperty.Values().Count() < 1)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);
+            // On continue ignore the priority.
+            }
+        else
+            {
+            TInt priority = aProperty.Values()[0]->IntegerL();
+
+            //Pirorites are saved always in vcal format
+            //so they are mapped the following way
+            //iCal 1 - 4 = vCal 1
+            //iCal 5     = vCal 2
+            //iCal 6 - 9 = vCal 3
+
+            // MRUI always uses iCal format
+            //Pirorites are saved always in vcal format
+            //so they are mapped the following way
+            //vCal 1 = iCal 1
+            //vCal 2 = iCal 5
+            //vCal 3 = iCal 9
+
+            if ( priority != EFSCalenMRPriorityLow &&
+                 priority != EFSCalenMRPriorityNormal &&
+                 priority != EFSCalenMRPriorityHigh )
+                {
+                priority = EFSCalenMRPriorityNormal;
+                }
+            /*if( priority < 5 )
+                {
+                priority = 1;
+                }
+
+            else if( priority == 5 )
+                {
+                priority = 2;
+                }
+
+            else
+                {
+                priority = 3;
+                }*/
+
+            aEntry.SetPriorityL( priority );
+            }
+        }
+
+    else if (aProperty.Type().CompareF(KICalDtstamp) == 0)
+        {
+        TCalTime timeStamp;
+        GetCalTimeL(aProperty, timeStamp, EDateTime);
+        aEntry.SetDTStampL(timeStamp);
+        }
+    else if ((aProperty.Type().CompareF(KICalUid) == 0) ||
+             (aProperty.Type().CompareF(KICalSequence) == 0) ||
+             (aProperty.Type().CompareF(KICalRecurrenceId) == 0) ||
+             (aProperty.Type().CompareF(KICalLastmodified) == 0))
+        {
+        //Already been handled when constructing the entry :- do nothing
+        }
+    else if (aProperty.Type().Find(KICalXProperty) == 0)
+        {
+        // Quietly swallow X- properties, instead of reporting "NotSupported"
+        }
+    else
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, aEntry.UidL(), aProperty.Type());
+        }
+
+    }
+
+/**
+ * Performs most of the work of importing a timezone component. Timezones are not
+ * stored as separate entities within Agenda, but as CTzRules objects within
+ * individual entries, and so this maintains an array of all timezone components
+ * for any given calendar, to be accessed later as required.
+ * @param aTimezone The timezone to convert into CTzRules format.
+ * @return MESMRAgnImportObserver::TImpResponse indicating application response to errors, if any.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportTimezoneL(const CESMRICalComponent& aTimezone)
+    {
+    FUNC_LOG;
+
+    CTzRules* rules = NULL;
+    // Get the TZID:
+    TPtrC tzid;
+    const CESMRICalProperty* propUid = aTimezone.FindProperty(KICalTzid());
+    if (propUid && propUid->Values().Count() > 0)
+        {
+        tzid.Set(propUid->Values()[0]->TextL());
+        }
+    else
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorInvalidData, KNullDesC8, KICalUid, EFalse);
+        // A Timezone with no ID is completely pointless, so on continue skip.
+        }
+
+    // Create somewhere to store the data we are parsing:
+    rules = CTzRules::NewL();
+    CleanupStack::PushL(rules);
+
+    // We don't care about any of the timezones properties except the tzid - we go straight
+    // onto the standard and daylight values.
+    const RPointerArray<CESMRICalComponent>& tzComponents = aTimezone.Components();
+    if (tzComponents.Count() < 1)
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, KNullDesC8, KICalTimeZone, EFalse);
+        // A Timezone without atleast 1 value is meaningless so on continue skip.
+        }
+    else
+        {
+        // Agenda expects a set of month+day definitions, which repeat every year between start and end years.
+        // iCalendar provides a set of year+month+day definitions, which cannot always be represented.
+        // We will try, and hope for the best, using the first rules start and end to define the overall duration,
+        // effectively overwriting all the other rules.
+        rules->SetInitialStdTimeOffset(0);
+
+        TInt tzCount = tzComponents.Count();
+        for (TInt tznum = 0; tznum < tzCount; ++tznum)
+            {
+            // Find the properties for this component:
+            CESMRICalComponent* tzinterval = tzComponents[tznum];
+            ImportTimezoneIntervalL(*tzinterval, *rules);
+            }
+        }
+
+    CTzNamedRules* namedRules = new (ELeave) CTzNamedRules;
+    CleanupStack::Pop(rules);
+    namedRules->iRules = rules;
+    CleanupStack::PushL(namedRules);
+    namedRules->iName = tzid.AllocL();
+    User::LeaveIfError(iTzRules.Append(namedRules));
+    CleanupStack::Pop(namedRules);
+
+    }
+
+/**
+ * Performs most of the work of translating a DAYLIGHT or STANDARD section of a
+ * VTIMEZONE into the equivalent TTzRule for Agenda.
+ * @param aInterval The DAYLIGHT or STANDARD component.
+ * @param aRules The CTzRules into which the TTzRule will be placed.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportTimezoneIntervalL( const CESMRICalComponent& aInterval,
+                                                   CTzRules& aRules )
+    {
+    FUNC_LOG;
+
+    // Find the properties:
+    const CESMRICalProperty* from = aInterval.FindProperty(KICalTzoffsetfrom);
+    const CESMRICalProperty* to = aInterval.FindProperty(KICalTzoffsetto);
+    const CESMRICalProperty* start = aInterval.FindProperty(KICalDtstart);
+    const CESMRICalProperty* rdate = aInterval.FindProperty(KICalRdate);
+    const CESMRICalProperty* rrule = aInterval.FindProperty(KICalRRule);
+
+    // Set the time offsets it implies:
+    TTzRule tzrule;
+    tzrule.iOldLocalTimeOffset = from->Values()[0]->UtcOffsetL().Int() / KSecondsInOneMinute;
+    tzrule.iNewLocalTimeOffset = to->Values()[0]->UtcOffsetL().Int() / KSecondsInOneMinute;
+    tzrule.iTimeReference = ETzUtcTimeReference;
+
+    RPointerArray<CESMRICalRuleSegment> recRules;
+    CleanupPointerArrayPushL(recRules);
+
+    // If this has an rdate with more than one value we can only represent it by
+    // creating a seperate tzrule for each date.  Not only that, but because the rdate
+    // specifies years, we need separate CTzRules for each year, which we can't actually
+    // do in Agenda. This is unsupported.
+    if (rdate)
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalRdate);
+        // On continue we ignore the rdate.
+        }
+
+    // Start date
+    // Agenda has a start year and end year for the entire timezone.
+    // iCalendar has a start date for each interval and an end date for each rrule within the interval.
+    // This means we are trying to map N starts and M ends to 1 start and 1 end.
+    // We will just use whatever we find - it's not going to work and it can't be made to work.
+    TDateTime dateTime;
+    if (start)
+        {
+        TTime startTime;
+        CESMRICalValue::TTimeZoneType type;
+        start->Values()[0]->GetDateTimeL(startTime, type);
+        dateTime = startTime.DateTime();
+        aRules.SetStartYear(dateTime.Year());
+        tzrule.iFrom = TTimeWithReference( dateTime );
+        // Put the max TTimeWithReference value to iTo as default.
+        // Normally it is not set in the VCALENDAR object,
+        // but it is required for CTzRules API.
+        tzrule.iTo = TTimeWithReference::Max();
+        // We cannot set the day of the month on which this timezone rule starts being applied
+        // because Agenda does not support it. We just have to make do without it; the field
+        // gets set to the first day of the month by default.
+        }
+    else
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, KNullDesC8, KICalDtstart, EFalse);
+        // We cannot continue without a start, so skip.
+        }
+
+    // If this has an rrule we may be able to represent it.
+    if (rrule && rrule->Values().Count() > 0)
+        {
+        // One thing we cannot do is handle multiple RRules.
+        if (rrule->Values().Count() > 1)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8,
+                        iStringProvider.StringL(EICalErrRruleNumRules));
+            // On continue ignore all but the first RRule.
+            }
+        CESMRICalRuleSegment::TFreq freq;
+        rrule->Values()[0]->GetRecurrenceRuleL(recRules);
+
+        // Find the frequency first - if there is no frequency it is an error, and if the
+        // frequency is anything other than yearly we can't handle it anyway.
+        TInt pos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegFreq);
+        if (pos != KErrNotFound)
+            {
+            ASSERT(recRules.Count() >= pos + 1);
+            freq = recRules[pos]->FreqL();
+            if (freq != CESMRICalRuleSegment::EFreqYearly)
+                {
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8,
+                        iStringProvider.StringL(EICalErrRruleNotYearly));
+                // On continue assume yearly.
+                freq = CESMRICalRuleSegment::EFreqYearly;
+                }
+            }
+        else
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, KNullDesC8,
+                        rrule->Values()[0]->TextL());
+            // On continue assume yearly.
+            freq = CESMRICalRuleSegment::EFreqYearly;
+            }
+
+        // Find the interval.  We can only handle an interval of 1.
+        TInt thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegInterval);
+        if (thePos != KErrNotFound)
+            {
+            ASSERT(recRules.Count() >= thePos + 1);
+            ASSERT(recRules[thePos]->Values().Count() >= 0);
+            if (recRules[thePos]->Values()[0]->IntegerL() != 1)
+                {
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalInterval);
+                // On continue assume the interval is 1.
+                }
+            }
+
+        // Find the count, and interpret it as an end year.
+        // See the comment above about start date for the problems with this.
+        thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegCount);
+        if (thePos != KErrNotFound)
+            {
+            ASSERT(recRules.Count() >= thePos + 1);
+            ASSERT(recRules[thePos]->Values().Count() >= 0);
+            TInt count = recRules[thePos]->Values()[0]->IntegerL();
+            aRules.SetEndYear(aRules.StartYear() + count);
+            }
+
+        // Find the until, and interpret it as an end year.
+        // See the comment above about start date for the problems with this.
+        thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegUntil);
+        if (thePos != KErrNotFound)
+            {
+            ASSERT(recRules.Count() >= thePos + 1);
+            ASSERT(recRules[thePos]->Values().Count() >= 0);
+            TTime endTime;
+            recRules[thePos]->Values()[0]->GetDateL(endTime);
+            aRules.SetEndYear(endTime.DateTime().Year());
+            }
+
+        // WKST (which defines the day on which a week starts) is not
+        // supported by the agenda timezones.
+        thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegUntil);
+        if (thePos != KErrNotFound)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalWkSt);
+            // On continue ignore the WKST.
+            }
+
+        // BySecond, ByMinute, ByHour, ByYearDay, ByWeekNo are not
+        // supported by the agenda timezones.
+        thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegBySecond);
+        if (thePos == KErrNotFound)
+            {
+            thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByMinute);
+            }
+        if (thePos == KErrNotFound)
+            {
+            thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByHour);
+            }
+        if (thePos == KErrNotFound)
+            {
+            thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByYearDay);
+            }
+        if (thePos == KErrNotFound)
+            {
+            thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByWeekNo);
+            }
+        if (thePos != KErrNotFound)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalRRule);
+            // On continue ignore the unsupported field.
+            }
+
+        // ByMonth
+        TBool haveMonth = EFalse;
+        thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByMonth);
+        if (thePos != KErrNotFound)
+            {
+            if (recRules[thePos]->Values().Count() > 0)
+                {
+                TMonth month = recRules[thePos]->Values()[0]->MonthL();
+                haveMonth = ETrue;
+                tzrule.iMonth = month;
+                if (recRules[thePos]->Values().Count() > 1)
+                    {
+                    ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalByMonth);
+                    // On continue ignore the additional months.
+                    }
+                }
+            }
+
+        if (!haveMonth)
+            {
+            tzrule.iMonth = dateTime.Month();
+            }
+
+        // ByDay
+        TBool haveDay = EFalse;
+        TInt daypos;
+        thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByDay);
+        if (thePos != KErrNotFound)
+            {
+            if (recRules[thePos]->Values().Count() > 0)
+                {
+                TDay day;
+                recRules[thePos]->Values()[0]->GetDayL(day, daypos);
+                haveDay = ETrue;
+                tzrule.iDayOfWeek = day;
+                if (recRules[thePos]->Values().Count() > 1)
+                    {
+                    ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalByDay);
+                    // On continue ignore extra days.
+                    }
+                }
+            }
+
+        if (haveDay)
+            {
+            if (daypos == 0)
+                {
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalByDay, EFalse);
+                // We cannot handle this - on continue skip.
+                }
+            else if (daypos < 0)
+                {
+                // We cant handle -2,-3 etc, so we assume -1
+                tzrule.iDayRule = ETzDayInLastWeekOfMonth;
+                tzrule.iDayOfMonth = 0;
+                }
+            else
+                {
+                if (daypos > KMaxWeekDayNum)
+                    {
+                    ReportErrorL(MESMRAgnImportObserver::EImpErrorInvalidData, KNullDesC8, KICalByDay);
+                    // On continue, assume the KMaxWeekDayNum.
+                    daypos = KMaxWeekDayNum;
+                    }
+                tzrule.iDayRule = ETzDayAfterDate;
+                tzrule.iDayOfMonth = (daypos - 1) * KDaysPerWeek;
+                }
+            }
+        else
+            {
+            tzrule.iDayRule = ETzFixedDate;
+            tzrule.iDayOfMonth = dateTime.Day();
+            }
+
+        // ByMonthDay and BySetPos can in theory be supported under
+        // some circumstances, but right now they aren't.
+        thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByMonthDay);
+        if (thePos == KErrNotFound)
+            {
+            thePos = FindRuleSegment(recRules, CESMRICalRuleSegment::ESegByPos);
+            }
+        if (thePos != KErrNotFound)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalRRule);
+            // On continue ignore both fields.
+            }
+
+        tzrule.iTimeOfChange = dateTime.Hour() * KMinutesInOneHour + dateTime.Minute();
+        aRules.AddRuleL(tzrule);
+        }
+    else // no rrule
+        {
+        tzrule.iDayRule = ETzFixedDate;
+        tzrule.iMonth = dateTime.Month();
+        tzrule.iDayOfMonth = dateTime.Day();
+        tzrule.iTimeOfChange = dateTime.Hour() * KMinutesInOneHour + dateTime.Minute();
+        aRules.AddRuleL(tzrule);
+        }
+    CleanupStack::PopAndDestroy(&recRules);
+
+    }
+
+/**
+*     IMPORT PROPERTY FUNCTIONS
+*     =========================
+*/
+
+/**
+ * Helper function for translating categories from the pure text format of
+ * iCalendar to the enumerated type of Agenda.
+ * @param aProperty A category property.
+ * @param aEntry An entry into which to put the categories.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportCategoriesL( const CESMRICalProperty& aProperty,
+                                             CCalEntry& aEntry ) const
+    {
+    FUNC_LOG;
+
+    TInt valCount = aProperty.Values().Count();
+    for (TInt pnum = 0; pnum < valCount; ++pnum)
+        {
+        TPtrC name(aProperty.Values()[pnum]->TextL());
+        CCalCategory* cat = NULL;
+        if (name.CompareF(iStringProvider.StringL(EICalAppointment)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalAppointment);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalBusiness)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalBusiness);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalEducation)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalEducation);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalHoliday)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalHoliday);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalMeeting)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalMeeting);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalMisc)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalMiscellaneous);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalPersonal)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalPersonal);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalPhoneCall)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalPhoneCall);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalSick)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalSickDay);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalSpecial)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalSpecialOccasion);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalTravel)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalTravel);
+            }
+        else if (name.CompareF(iStringProvider.StringL(EICalVacation)) == 0)
+            {
+            cat = CCalCategory::NewL(CCalCategory::ECalVacation);
+            }
+        else
+            {
+            cat = CCalCategory::NewL(name);
+            }
+        aEntry.AddCategoryL(cat);
+        }
+    }
+
+/**
+ * A function to import a CLASS property into a format suitable for Agenda.
+ * @param aProperty The CLASS property to translate.
+ * @param aEntry The entry to add the rules to.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ImportClassL(const CESMRICalProperty& aProperty, CCalEntry& aEntry)
+    {
+    FUNC_LOG;
+
+    if (aProperty.Values().Count() > 0)
+        {
+        // Ignore any values after the first one
+        TPtrC name(aProperty.Values()[0]->TextL());
+        if (name.CompareF(KICalPublic) == 0)
+            {
+            aEntry.SetReplicationStatusL(CCalEntry::EOpen);
+            }
+        else if (name.CompareF(KICalPrivate) == 0)
+            {
+            aEntry.SetReplicationStatusL(CCalEntry::EPrivate);
+            }
+        else if (name.CompareF(KICalConfidential) == 0)
+            {
+            aEntry.SetReplicationStatusL(CCalEntry::ERestricted);
+            }
+        else
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, aEntry.UidL(), name);
+            // On continue ignore the class.
+            }
+        }
+    else
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalRRule);
+        // On continue ignore the class.
+        }
+    }
+
+/**
+ * A function to translate an RRULE property into a TCalRRule for Agenda.
+ * @param aProperty The RRULE property to translate.
+ * @param aEntry The entry to add the rules to.
+ * @param aStartTime The DTSTART of the parent component.
+ * @return ETrue if the rule is imported, else EFalse.
+ * @internalTechnology
+ */
+TBool CESMRAgnVersit2Importer::ImportRRuleL( const CESMRICalProperty& aProperty,
+                                         CCalEntry& aEntry,
+                                         const TCalTime& aStartTime )
+    {
+    FUNC_LOG;
+
+    //Create a new recurrence rule importer
+    CESMRAgnRRuleImporter *importer = CESMRAgnRRuleImporter::NewLC( *this );
+
+    //import the recurrence rule
+    TBool importRRule = importer->ImportL( aProperty, aEntry, aStartTime );
+
+    if( importRRule )
+        {
+        iNeedsTzRules = ETrue;
+        }
+
+    CleanupStack::PopAndDestroy( importer );
+
+
+    //return true if the rule is imported
+    return importRRule;
+    }
+
+
+
+//
+//     HELPER FUNCTIONS
+//     ================
+//
+
+
+/**
+ * Takes a property, a TCalTime, and an index into the set of values of the
+ * property, and populates the TCalTime from the value, performing any required
+ * timezone conversions first.
+ * @param aProperty A property which has a date or date-time type.
+ * @param aTime The time to put the resulting UTC time into.
+ * @param aDefaultType Enumeration of the type of value being passed.
+ * @param aValue The index of the property value to use, for properties which have
+ * more than one.
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::GetCalTimeL( const CESMRICalProperty& aProperty,
+                                       TCalTime& aTime,
+                                       TValueType aValueType,
+                                       TInt aValue )
+    {
+    FUNC_LOG;
+
+    // Find the property value, value parameter and tzid parameter:
+    if (aProperty.Values().Count() < aValue)
+        {
+        ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, KNullDesC8, aProperty.Type(), EFalse);
+        // We cannot continue - we interpret continue as skip.
+        }
+
+    const CESMRICalPropertyParam* valuetype = aProperty.FindParam(KICalValue);
+    if (valuetype)
+        {
+        if (valuetype->Values().Count() < 1)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData, KNullDesC8, KICalValue);
+            // On continue, use the default type passed in the function arguments.
+            }
+        else
+            {
+            TPtrC vt(valuetype->Values()[0]->TextL());
+            if (vt.CompareF(KICalDate) == 0)
+                {
+                aValueType = EDate;
+                }
+            else if (vt.CompareF(KICalDateTime) == 0)
+                {
+                aValueType = EDateTime;
+                }
+            else
+                {
+                ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, vt, EFalse);
+                // We can't continue - skip instead.
+                }
+            }
+        }
+
+    TTime dateAndTime;
+    CESMRICalValue::TTimeZoneType tzType = CESMRICalValue::EUtcTime;
+
+    CESMRICalValue* value = aProperty.Values()[aValue];
+
+    switch (aValueType)
+        {
+        case EDate :
+            value->GetDateL(dateAndTime);
+            break;
+        case EDateTime :
+            value->GetDateTimeL(dateAndTime, tzType);
+            break;
+        case ETime :
+            value->GetTimeL(dateAndTime, tzType);
+            break;
+        case EDefault :     // fall through..
+        case EDuration :    // not supported, fall through
+        case EPeriod :      // not supported, fall through
+        default :
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorNotSupported, KNullDesC8, KICalPeriod, EFalse);
+            // We can't continue - skip instead.
+            break;
+            }
+        }
+
+    const CESMRICalPropertyParam* tzid = aProperty.FindParam(KICalTzid);
+
+    // Handle timezone information:
+    if (tzType == CESMRICalValue::EUtcTime)
+        {
+        // A trailing Z means UTC:
+        aTime.SetTimeUtcL(dateAndTime);
+        }
+    else if (!tzid || tzid->Values().Count() < 1)
+        {
+        // No trailing Z and no timezone ID.
+        // This is a floating time.
+        aTime.SetTimeLocalFloatingL(dateAndTime);
+        }
+    else
+        {
+        // Find the name of the timezone, and the timezone with that name:
+        const CTzRules* rules = FindTzRule(tzid->Values()[0]->TextL());
+
+        if (!rules)
+            {
+            ReportErrorL(MESMRAgnImportObserver::EImpErrorMissingData,KNullDesC8, aProperty.Type());
+            // On continue, assume UTC.
+            }
+        else
+            {
+            // Remember the timezone:
+            iCurrentTzRules = rules;
+            // All times are stored in Agenda in UTC, and the timezone
+            // applied by Agenda where appropriate:
+            rules->ConvertToUtcL(dateAndTime);
+            }
+
+        // Set the time:
+        aTime.SetTimeUtcL(dateAndTime);
+        }
+    }
+
+/**
+ * Searches through a set of rule segments and finds the segment corresponding to
+ * a particular type.
+ * @param aRules The array of rules to search.
+ * @param aType The type of segment to search for from CESMRICalRuleSegment::TSegmentType.
+ * @see CESMRICalRuleSegment::TSegmentType
+ * @return The index of the rule within the array, or KErrNotFound
+ * @internalTechnology
+ */
+TInt CESMRAgnVersit2Importer::FindRuleSegment( const RPointerArray<CESMRICalRuleSegment>& aRules,
+                                           CESMRICalRuleSegment::TSegmentType aType ) const
+    {
+    FUNC_LOG;
+
+    for (TInt r = aRules.Count() - 1; r > -1; --r)
+        {
+        if (aRules[r]->Type() == aType)
+            {
+            return r;
+            }
+        }
+    return KErrNotFound;
+    }
+
+/**
+ * Searches through the internally stored array of time zone rules looking for one
+ * with a particular name, and returns its address. This does not transfer
+ * ownership of the rule.
+ * @param aName The name of the timezone rule to find (corresponding to TZID)
+ * @return A pointer to the rule, or zero if no matching rule is found.
+ * @internalTechnology
+ */
+const CTzRules* CESMRAgnVersit2Importer::FindTzRule(const TDesC& aName) const
+    {
+    FUNC_LOG;
+
+    TInt tzCount = iTzRules.Count();
+    for (TInt r = 0; r < tzCount; ++r)
+        {
+        if (iTzRules[r]->iName->CompareF(aName) == 0)
+            {
+            return iTzRules[r]->iRules;
+            }
+        }
+
+    return NULL;
+    }
+
+/**
+ * Reports an error through the MESMRAgnImportObserver interface, and then leaves if
+ * the return value is anything other than
+ * MESMRAgnImportObserver::EImpResponseContinue. The return value is stored in
+ * iResponse.
+ * @param aType The type of error which occurred
+ * @param aUid The Uid of the entry in which it occurred, if known, or KNullDesC
+ * if not.
+ * @param aContext A textual indication of where the error occurred.
+ * @param aCanContinue If this is not ETrue (default = ETrue) then a response of
+ * EImpResponseContinue will be handled as an EImpResponseSkip
+ * @leave KErrAbort
+ * @internalTechnology
+ */
+void CESMRAgnVersit2Importer::ReportErrorL( MESMRAgnImportObserver::TImpError aType,
+                                        const TDesC8& aUid,
+                                        const TDesC& aContext,
+                                        TBool aCanContinue )
+    {
+    FUNC_LOG;
+
+    iResponse = iImportObserver->AgnImportErrorL(aType, aUid, aContext);
+    if (iResponse != MESMRAgnImportObserver::EImpResponseContinue)
+        {
+        User::Leave(KErrAbort);
+        }
+    else if (!aCanContinue)
+        {
+        iResponse = MESMRAgnImportObserver::EImpResponseSkip;
+
+        User::Leave(KErrAbort);
+        }
+
+    }
+
+// End of file.
+