/*
* Copyright (c) 2007-2007 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 contains implementation of iCal parser which parses
* the recurrence rule of iCal entry.
*
*/
#include "AgnParseRRule.h"
#include "calendarengines_debug.h"
#include <calrrule.h>
#include "ICalValue.h" // For CICalValue
/**
Constructor
@param aAgnImpUtil AgnVersit2Importer utility functions
*/
CAgnParseRRule::CAgnParseRRule( MAgnImpUtil& aAgnImpUtil ) :
iAgnImpUtil( aAgnImpUtil ),
iSetSegs( 0 )
{
TRACE_ENTRY_POINT;
TRACE_EXIT_POINT;
}
/**
Destructor
*/
CAgnParseRRule::~CAgnParseRRule()
{
TRACE_ENTRY_POINT;
TRACE_EXIT_POINT;
}
//=========================================================================================
// Parsing functions
//=========================================================================================
/**
Parse the keywords and update RRule
@param aRule recurrence rules
@param aRecRules array of recurrence rule value segments.
@param aStartTime The DTSTART of the parent component.
@param aUid Entry Uid
@param aRulevalues array of CICalValues
@return True if parsed the keyword successfully
*/
TBool CAgnParseRRule::ParseL( TCalRRule& aRule, RPointerArray<CICalRuleSegment>& aRecRules,
const TCalTime& aStartTime, const TDesC8& aUid,
const RPointerArray<CICalValue>& aRulevalues )
{
TRACE_ENTRY_POINT;
aRule.SetDtStart( aStartTime );
TInt recCount = aRecRules.Count();
TBool parsed = EFalse;
//Loop through the CICalRuleSegments
for (TInt rnum = 0; rnum < aRecRules.Count(); ++rnum)
{
parsed = EFalse;
CICalRuleSegment* segment = aRecRules[rnum];
if (segment->Values().Count() < 1)
{
iAgnImpUtil.ReportErrorL( MAgnImportObserver::EImpErrorMissingData, aUid,
aRulevalues[0]->TextL() );
// On continue, all we have is FREQ=DAILY.
}
//Try to parse it with specific parser
TRAPD( error, parsed = DoParseL( *segment, aRule ) );
//if the keyword was not parsed, try to parse it
if( error == KErrNone && !parsed )
{
//Update aRule with CICalRuleSegment
switch (segment->Type())
{
case CICalRuleSegment::ESegFreq :
break;
//Set Until
case CICalRuleSegment::ESegUntil :
{
SetRRuleUntilL( *segment, aRule );
break;
}
//Set Count
case CICalRuleSegment::ESegCount :
{
aRule.SetCount(segment->Values()[0]->IntegerL());
break;
}
//Set Interval
case CICalRuleSegment::ESegInterval :
{
aRule.SetInterval(segment->Values()[0]->IntegerL());
break;
}
//Not supported keywords by freq, report error
case CICalRuleSegment::ESegByPos : // not supported by freq, fall through
case CICalRuleSegment::ESegBySecond : // not supported by freq, fall through
case CICalRuleSegment::ESegByMinute : // not supported by freq, fall through
case CICalRuleSegment::ESegByHour : // not supported by freq, fall through
case CICalRuleSegment::ESegByYearDay : // not supported by freq, fall through
case CICalRuleSegment::ESegByWeekNo : // not supported by freq, fall through
case CICalRuleSegment::ESegExtension : // not supported by freq, fall through
case CICalRuleSegment::ESegWkSt : // not supported by freq, fall through
case CICalRuleSegment::ESegByDay : // not supported by freq, fall through
case CICalRuleSegment::ESegByMonthDay : // not supported by freq, fall through
case CICalRuleSegment::ESegByMonth : // not supported by freq, fall through
default:
{
iAgnImpUtil.ReportErrorL( MAgnImportObserver::EImpErrorNotSupported, aUid,
aRulevalues[0]->TextL() );
}
}
}
//TRAP returned error
else if( error != KErrNone )
{
if( error == KErrAbort )//KErrAbort, report error and stop parsing
{
TRACE_EXIT_POINT;
iAgnImpUtil.ReportErrorL( MAgnImportObserver::EImpErrorNotSupported, aUid,
aRulevalues[0]->TextL(), EFalse );
}
else //Otherwise leave with error
{
TRACE_EXIT_POINT;
User::Leave( error );
}
}
}//for end
//Finalize parsing
parsed = FinalizeParsingL( aRule, aStartTime );
TRACE_EXIT_POINT;
return parsed;
}
/**
Parse the keywords and update RRule
@param aSegment recurrence rule value segment.
@param aRule recurrence rules
@return true if parsed the keyword successfully
*/
TBool CAgnParseRRule::DoParseL( CICalRuleSegment& /*aSegment*/, TCalRRule& /*aRule*/ )
{
TRACE_ENTRY_POINT;
return EFalse;
TRACE_EXIT_POINT;
}
/**
Finalize the parsing
@param aRule recurrence rules
@param aStartTime The DTSTART of the parent component.
@return true if finalized parsing successfully
*/
TBool CAgnParseRRule::FinalizeParsingL( TCalRRule& aRule, const TCalTime& /*aStartTime*/ )
{
TRACE_ENTRY_POINT;
TBool finalized = ETrue;
// Agenda requires that all RRULES have an interval of some sort.
// An interval of 1 is the default.
if (aRule.Interval() < 1)
{
aRule.SetInterval(1);
}
TRACE_EXIT_POINT;
return finalized;
}
//=========================================================================================
// Following functions updates the TCalRRule
//=========================================================================================
/**
Update TCalRRule with Until value
@param aSegment recurrence rule value segment.
@param aRule recurrence rules
@return true if aRule updated successfully
*/
TBool CAgnParseRRule::SetRRuleUntilL( const CICalRuleSegment& aSegment, TCalRRule& aRule )
{
TRACE_ENTRY_POINT;
TTime time;
TCalTime calTime;
// adding time and date information to the Repeat Until field
CICalValue::TTimeZoneType type = CICalValue::EUtcTime;
aSegment.Values()[0]->GetDateTimeL(time, type);
calTime.SetTimeUtcL(time);
aRule.SetUntil(calTime);
TRACE_EXIT_POINT;
return ETrue;
}
/**
Update TCalRRule with week start value
@param aSegment recurrence rule value segment.
@param aRule recurrence rules
@return true if aRule updated successfully
*/
TBool CAgnParseRRule::SetRRuleWkStL( const CICalRuleSegment& aSegment, TCalRRule& aRule )
{
TRACE_ENTRY_POINT;
TDay dayval;
TInt daypos;
aSegment.Values()[0]->GetDayL(dayval, daypos);
aRule.SetWkSt(dayval);
//iSetSegs |= ESegFlagByWkSt; <-- Does not exist, a bug?
TRACE_EXIT_POINT;
return ETrue;
}
/**
Update TCalRRule with by days
@param aSegment recurrence rule value segment.
@param aRule recurrence rules
@return true if aRule updated successfully
*/
TBool CAgnParseRRule::SetRRuleByDayL( const CICalRuleSegment& aSegment, TCalRRule& aRule )
{
TRACE_ENTRY_POINT;
RArray<TCalRRule::TDayOfMonth> daysOfMonth;
CleanupClosePushL(daysOfMonth);
const RPointerArray<CICalValue>& values = aSegment.Values();
TInt valCount = values.Count();
TDay dayval = EMonday;
TInt daypos = 0;
for (TInt day = 0; day < valCount; ++day)
{
values[day]->GetDayL(dayval, daypos);
if ((daypos == -1) || ((daypos >= 1) && (daypos <= KMaxWeekDayNum)))
{
User::LeaveIfError(daysOfMonth.Append(TCalRRule::TDayOfMonth(dayval, daypos)));
}
else if (daypos == 0)
//BYDAY applies to every day in month
{
User::LeaveIfError(daysOfMonth.Append(TCalRRule::TDayOfMonth(dayval, 1)));
User::LeaveIfError(daysOfMonth.Append(TCalRRule::TDayOfMonth(dayval, 2)));
User::LeaveIfError(daysOfMonth.Append(TCalRRule::TDayOfMonth(dayval, 3)));
User::LeaveIfError(daysOfMonth.Append(TCalRRule::TDayOfMonth(dayval, 4)));
User::LeaveIfError(daysOfMonth.Append(TCalRRule::TDayOfMonth(dayval, -1)));
}
else
{
//Invalid day - unrecoverable
User::Leave( KErrAbort );
}
}
aRule.SetByDay(daysOfMonth);
CleanupStack::PopAndDestroy(&daysOfMonth);
iSetSegs |= ESegFlagByDay;
TRACE_EXIT_POINT;
return ETrue;
}
/**
Update TCalRRule with by month
@param aSegment recurrence rule value segment.
@param aRule recurrence rules
@return true if aRule updated successfully
*/
TBool CAgnParseRRule::SetRRuleByMonthL( const CICalRuleSegment& aSegment, TCalRRule& aRule )
{
TRACE_ENTRY_POINT;
RArray<TMonth> theMonths;
CleanupClosePushL(theMonths);
const RPointerArray<CICalValue>& values = aSegment.Values();
TInt valCount = values.Count();
for (TInt month = 0; month < valCount; ++month)
{
User::LeaveIfError(theMonths.Append(values[month]->MonthL()));
}
iSetSegs |= ESegFlagByMonth;
aRule.SetByMonth(theMonths);
CleanupStack::PopAndDestroy(&theMonths);
TRACE_EXIT_POINT;
return ETrue;
}
/**
Update TCalRRule with by month day
@param aSegment recurrence rule value segment.
@param aRule recurrence rules
@return true if aRule updated successfully
*/
TBool CAgnParseRRule::SetRRuleByMonthDayL( const CICalRuleSegment& aSegment, TCalRRule& aRule )
{
TRACE_ENTRY_POINT;
RArray<TInt> days;
CleanupClosePushL(days);
const RPointerArray<CICalValue>& values = aSegment.Values();
TInt valCount = values.Count();
for (TInt day = 0; day < valCount; ++day)
{
//dates are represented as day - 1 (0 = 1) in TDateTime
User::LeaveIfError(days.Append(values[day]->IntegerL() - 1 ));
}
aRule.SetByMonthDay(days);
CleanupStack::PopAndDestroy(&days);
iSetSegs |= ESegFlagByMonthDay;
TRACE_EXIT_POINT;
return ETrue;
}