// -----------------------------------------------------------------------------
// CPIMAgnToDoAdapter::ConvertStringToAgnL
// Makes string conversion from framework PIM item data field to To-do item field
// -----------------------------------------------------------------------------
//
void CPIMAgnToDoAdapter::ConvertStringToAgnL(TPIMToDoField aField, // String field to be converted
TInt aIndex, // Index of the date field
CCalEntry& aEntry, // The Agenda Model entry
const MPIMItemData& aItem) // The PIM item to read the field from
{
JELOG2(EPim);
const TPIMFieldData fieldData = aItem.ValueL(aField, aIndex);
const TDesC& string = fieldData.StringValue();
// Check that string is not too long
__ASSERT_ALWAYS(string.Length() <= KPIMToDoStringValueMaxLength,
User::Leave(KErrTooBig));
switch (aField)
{
case EPIMToDoSummary:
{
aEntry.SetSummaryL(string);
break;
}
case EPIMToDoNote:
{
aEntry.SetDescriptionL(string);
break;
}
default:
{
// Should not happen
}
}
}
// -----------------------------------------------------------------------------
// CPIMAgnToDoAdapter::ExportItemL
// (other items were commented in a header)
// -----------------------------------------------------------------------------
//
void CPIMAgnToDoAdapter::ExportItemL(const MPIMToDoItem& aItem,
CCalEntry& aEntry, TBool aResetEntry)
{
JELOG2(EPim);
if (aResetEntry)
{
// Reset native entry for exporting new data
aEntry.SetSummaryL(KNullDesC());
aEntry.SetDescriptionL(KNullDesC());
aEntry.SetPriorityL(0);
aEntry.SetCompletedL(EFalse, aEntry.CompletedTimeL());
}
// Export item data to the native ToDo calendar entry
const MPIMItemData& itemData = aItem.ItemData();
CArrayFix<TPIMField>* fields = itemData.FieldsLC();
// Add default values to the calendar entry
AddDefaultValuesToEntryL(itemData, aEntry);
// Convert each field to the native ToDo calendar entry
TInt count = fields->Count();
for (TInt i = 0; i < count; i++)
{
TPIMToDoField field = static_cast<TPIMToDoField>(fields->At(i));
ConvertToAgnL(field, aEntry, itemData);
}
CleanupStack::PopAndDestroy(fields);
}
void CMultiThreadTestApp::AddEntryL(CCalEntryView& aView, const TInt aNumToAdd)
{
// Add Entries for Test
RTest test(KTestName);
test.Next(_L("Adding entries"));
TBuf<50> summary;
TBuf<50> location;
TBuf<50> description;
RPointerArray<CCalEntry> entriesToStore;
CleanupResetAndDestroyPushL(entriesToStore);
for (TInt index = 0; index < aNumToAdd; ++index)
{
CCalEntry* entry;
HBufC8* guid = HBufC8::NewL(255);
TPtr8 uidP = guid->Des();
RandomText8(uidP);
if( (index %2) == 0 )
{
entry = CreateCalEntryL(CCalEntry::ETodo, guid);
}
else
{
entry = CreateCalEntryL(CCalEntry::EAppt, guid);
}
TInt err = entriesToStore.Append(entry);
test(err == KErrNone);
SetEntryStartAndEndTimeL(entry);
RandomText(summary);
entry->SetSummaryL(summary);
RandomText(location);
entry->SetLocationL(location);
RandomText(description);
entry->SetDescriptionL(description);
}
TInt entriesStored(0);
aView.StoreL(entriesToStore, entriesStored); //temp
test(entriesStored == aNumToAdd);
test.Close();
CleanupStack::PopAndDestroy(&entriesToStore);
}
void CDummyCalendarApp::RepeatExceptedEntryCreateL()
{
test.Next(_L("Add entry, repeat twice, set excepted and delete"));
iEntries.ResetAndDestroy();
// Create new calendar entry.
CCalEntry* entry = NULL;
HBufC8* guid = KGUIDInc081869().AllocLC();
entry = CreateCalEntryL(CCalEntry::EAppt, guid);
CleanupStack::Pop(guid);
iEntries.AppendL(entry);
// Set start and end date.
TTime start(TDateTime(2006, EMarch, 6, 10, 0, 0, 0));
TTime end(TDateTime(2006, EMarch, 6, 14, 0, 0, 0));
SetEntryStartAndEndTimeL(entry, start, end);
TBuf<50> summary;
RandomText(summary);
entry->SetSummaryL(summary);
TBuf<50> location;
RandomText(location);
entry->SetLocationL(location);
TBuf<50> description;
RandomText(description);
entry->SetDescriptionL(description);
// Create a daily repeating rule that occurs for 2 days.
TCalRRule rpt(TCalRRule::EDaily);
rpt.SetInterval(1);
rpt.SetCount(2);
// Make sure the repeat time is within the delete time range.
TCalTime repeatStart;
TCalTime repeatEnd;
repeatStart.SetTimeLocalL(TDateTime(2006, EMarch, 6, 0, 0, 0, 0));
repeatEnd.SetTimeLocalL(TDateTime(2006, EMarch, 8, 0, 0, 0, 0));
rpt.SetDtStart(repeatStart);
rpt.SetUntil(repeatEnd);
entry->SetRRuleL(rpt);
// Store the entry. Because it repeats over 2 days, there will
// be 2 entries.
TInt entriesStored(0);
SynCGetEntryViewL().StoreL(iEntries, entriesStored);
test(entriesStored == iEntries.Count());
}
// -----------------------------------------------------------------------------
// CNSmlNotepadDatabase::AddNoteL
// -----------------------------------------------------------------------------
//
void CNSmlNotepadDatabase::AddNoteL(CNpdItem& aNote, TInt &aKey)
{
_NOTEPAD_DBG_FILE("CNSmlNotepadDatabase::AddNoteL(): begin");
TInt successCount = 0;
CCalenInterimUtils2* interimUtils = CCalenInterimUtils2::NewL();
CleanupStack::PushL(interimUtils);
HBufC8* guid = interimUtils->GlobalUidL();
CleanupStack::PopAndDestroy(interimUtils);
CleanupStack::PushL(guid);
CCalEntry* entry = CCalEntry::NewL(CCalEntry::ENote, guid,
CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(entry);
// set the description
TDesC* noteContent(aNote.Content());
entry->SetDescriptionL(*noteContent);
// store the entry in to calendar file
RPointerArray<CCalEntry> array;
CleanupRPtrArrayPushL(array);
array.AppendL(entry);
CleanupStack::Pop(entry);
iEntryView->StoreL(array, successCount);
if(successCount)
{
HBufC* content = HBufC::NewL(entry->DescriptionL().Length());
content->Des().Copy(entry->DescriptionL());
aNote.Set(entry->LocalUidL(),entry->LastModifiedDateL().TimeUtcL(), content);
aKey = entry->LocalUidL();
CleanupStack::PopAndDestroy(&array);
_NOTEPAD_DBG_FILE("CNSmlNotepadDatabase::AddNoteL(): inside if(successCount) after array");
}
else
{
User::Leave(KErrGeneral);
}
_NOTEPAD_DBG_FILE("CNSmlNotepadDatabase::AddNoteL(): end");
User::Leave(KErrNone);
}
// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ClearPIMFieldsL
// Clears the fields supported by PIM API from this Agenda Model entry.
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ClearPIMFieldsL(CCalEntry& aEntry,
const TPIMField aSupportedFields[], // Array of supported field types
TInt aSize) // Size of the array of supported fields
{
JELOG2(EPim);
for (int i = 0; i < aSize; i++)
{
switch (aSupportedFields[i])
{
case EPIMEventSummary:
{
aEntry.SetSummaryL(KNullDesC);
break;
}
case EPIMEventLocation:
{
aEntry.SetLocationL(KNullDesC);
break;
}
case EPIMEventNote:
{
aEntry.SetDescriptionL(KNullDesC);
break;
}
case EPIMEventAlarm:
{
aEntry.SetAlarmL(NULL);
break;
}
case EPIMEventStart: // Fallthrough
case EPIMEventEnd: // Fallthrough
case EPIMEventUid: // Fallthrough
case EPIMEventClass: // Fallthrough
case EPIMEventRevision:
{
break; // For these fields there is no need to do anything
}
default:
{
User::Leave(KErrArgument);
}
}
}
}
CCalAlarm* CCalAlarmAttachTest::StoreEntryWithAlarmContentLC(const TDesC8& aUid)
{
test.Printf(_L("Store an alarmed entry with alarm content\n"));
// Create an attachment to the alarm.
CCalAlarm* alarm = CCalAlarm::NewL();
CleanupStack::PushL(alarm);
alarm->SetTimeOffset(1);
CCalContent* almContent = CCalContent::NewL();
CleanupStack::PushL(almContent);
// Add content and mimetype for the alarm.
HBufC8* content = KContent().AllocLC();
HBufC8* mimetype = KMimeType().AllocLC();
almContent->SetContentL(content, mimetype, CCalContent::EDispositionInline);
CleanupStack::Pop(mimetype);
CleanupStack::Pop(content);
alarm->SetAlarmAction(almContent); // Takes ownership of almContent.
CleanupStack::Pop(almContent);
//Create the entry with the alarm and store it
RPointerArray<CCalEntry> entries;
CleanupResetAndDestroyPushL(entries);
HBufC8* guid = aUid.AllocLC();
CCalEntry* entry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(entry);
entries.AppendL(entry);
CleanupStack::Pop(entry);
TCalTime calTime;
calTime.SetTimeUtcL(TDateTime(2007,EFebruary,15, 13, 30, 0, 0));
entry->SetStartAndEndTimeL(calTime, calTime);
entry->SetSummaryL(KSummary());
entry->SetDescriptionL(KDescription());
entry->SetAlarmL(alarm);
TInt entriesStored = 0;
iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);
CleanupStack::PopAndDestroy(&entries);
return alarm;
}
// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ConvertStringFieldToAgnL
// Makes string conversion from framework PIM item data field to Appt item field
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ConvertStringFieldToAgnL(const MPIMEventItem& aItem,
CCalEntry& aEntry, const TPIMEventField aField) const
{
JELOG2(EPim);
const MPIMItemData& itemData = aItem.ItemData();
TInt amount = itemData.CountValues(aField);
for (TInt i = 0; i < amount; i++)
{
const TPIMFieldData fieldData = itemData.ValueL(aField, i);
const TDesC& stringValue = fieldData.StringValue();
EnsureValidStringValueL(stringValue);
// Add correct data to the field
switch (aField)
{
case EPIMEventNote:
{
aEntry.SetDescriptionL(stringValue);
break;
}
case EPIMEventSummary:
{
aEntry.SetSummaryL(stringValue);
break;
}
case EPIMEventLocation:
{
aEntry.SetLocationL(stringValue);
break;
}
default:
{
__ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory,
EPIMPanicUnsupportedStringField));
break;
}
}
}
}
void CDummyCalendarApp::AddEntryL(TInt aNumToAdd, TBool isParent, TBool isRepeat)
{
test.Next(_L("Adding entries"));
TBuf<50> summary;
TBuf<50> location;
TBuf<50> description;
iEntries.ResetAndDestroy();
for (TInt index=0; index<aNumToAdd; index++)
{
TBuf8<255> buf;
buf.Append(_L("GuidId"));
buf.AppendNum(index);
HBufC8* guid = buf.AllocLC(); // need to be pushed to ...
CCalEntry::TType entryType=(index%2==0)?CCalEntry::ETodo:CCalEntry::EAppt;
CCalEntry* entry = NULL;
if(isParent)
{
entry = CreateCalEntryL(entryType, guid);
}
else
{
TTime localTime(KRecurrIdLocalTime);
TCalTime recurrenceId;
recurrenceId.SetTimeLocalL(localTime);
entry = CCalEntry::NewL(entryType, guid, CCalEntry::EMethodAdd, 1, recurrenceId, CalCommon::EThisAndFuture);
}
CleanupStack::Pop(guid);
iEntries.AppendL(entry);
TInt year = -1;
TInt month = -1;
TInt day = -1;
if (isParent)
{
year = index % 5 + 2001; // Any year in the range: 2001 - 2005
month = index % 12;
day = index % 28;
}
else
{
// if this is a child entry, use the recurrence local time as the entry start time
// so it won't be out of range
TCalTime recurrId = entry->RecurrenceIdL();
TDateTime localTime = recurrId.TimeLocalL().DateTime();
year = localTime.Year();
month = localTime.Month();
day = localTime.Day();
}
TTime start(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0));
TTime end(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0));
end += TTimeIntervalDays(1);
SetEntryStartAndEndTimeL(entry,start,end);
RandomText(summary);
entry->SetSummaryL(summary);
RandomText(location);
entry->SetLocationL(location);
RandomText(description);
entry->SetDescriptionL(description);
if(isRepeat)
{
//create a daily repeat rule and make sure its repeat start\end date is within the deleting time range
TCalRRule rpt(TCalRRule::EDaily);
rpt.SetInterval(1);
TCalTime repeatStart;
TCalTime repeatend;
if(isParent)
{
//make sure the repeat time is within the delete time range
repeatStart.SetTimeLocalL(TDateTime(2000, EJune, 0, 0, 0, 0, 0));
repeatend.SetTimeLocalL(TDateTime(2006, EJune, 0, 0, 0, 0, 0));
}
else if (index<aNumToAdd/2)
{
// if this is a child entry, use the entry's recurrance time as repeating rule
// start time
TCalTime recurrId = entry->RecurrenceIdL();
// make sure the repeat time is within the delete time range for the first half entries
repeatStart.SetTimeLocalL(recurrId.TimeLocalL()); // June 1, 2003 00:00:00
repeatend.SetTimeLocalL(recurrId.TimeLocalL() + TTimeIntervalMonths(1)); // July 1, 2003 00:00:00
}
else
{
//make sure the repeat time is out of the delete time range for the second half entries
repeatStart.SetTimeLocalL(TDateTime(2003, EJune, 0, 0, 0, 0, 0));
repeatend.SetTimeLocalL(TDateTime(2007, EJune, 0, 0, 0, 0, 0));
}
rpt.SetDtStart(repeatStart);
rpt.SetUntil(repeatend);
entry->SetRRuleL(rpt);
}
}
TInt entriesStored(0);
iLocalEntryView->StoreL(iEntries, entriesStored); //temp
test(entriesStored == iEntries.Count());
}
void CTestCalIndexFileModifyEntryStep::ModifyEntryL()
{
TPtrC entryString;
TBool readRes = EFalse;
readRes = GetStringFromConfig(ConfigSection(), KModifyEntry, entryString);
if (!readRes)
{
INFO_PRINTF1(_L("Error in CTestCalIndexFileModifyEntryStep::ModifyEntryL - entrytomodify not found in config file"));
User::Leave(KErrNotFound);
}
CConfigTestEntryInfo* inf = new(ELeave)CConfigTestEntryInfo();
CleanupStack::PushL(inf);
ParseEntryStringL(*inf, entryString);
// see if we can find a match in the database using an instance view
CCalProgress* progress = new(ELeave)CCalProgress;
CleanupStack::PushL(progress);
CCalInstanceView* view = CCalInstanceView::NewL(*iSession, *progress);
CleanupStack::PushL(view);
CActiveScheduler::Start();
CalCommon::TCalViewFilter filter = CalCommon::EIncludeAppts;
switch (inf->iType)
{
case (CCalEntry::EAppt):
filter = CalCommon::EIncludeAppts;
break;
case (CCalEntry::ETodo):
filter = CalCommon::EIncludeCompletedTodos | CalCommon::EIncludeIncompletedTodos;
break;
case (CCalEntry::EEvent):
filter = CalCommon::EIncludeEvents;
break;
case (CCalEntry::EReminder):
filter = CalCommon::EIncludeReminder;
break;
case (CCalEntry::EAnniv):
filter = CalCommon::EIncludeAnnivs;
break;
default:
User::Leave(KErrCorrupt);
break;
}
RPointerArray<CCalInstance> instances;
CleanupClosePushL(instances);
// look for instances between (startdate -1 day) and
// (enddate + 1 day)
TTimeIntervalDays oneDay(1);
TTime beginTTime = (inf->iStartTime) - oneDay;
TTime endTTime = (inf->iEndTime) + oneDay;
TCalTime begin;
begin.SetTimeUtcL(beginTTime);
TCalTime end;
end.SetTimeUtcL(endTTime);
CalCommon::TCalTimeRange timerange(begin, end);
view->FindInstanceL(instances, filter, timerange);
TInt counter = 0;
TInt max = instances.Count();
INFO_PRINTF2(_L("%d instances to compare against"),max);
TBool found = EFalse;
while ((found == EFalse) && (counter < max))
{
INFO_PRINTF2(_L("compare modify info to entry %d"), (counter+1));
if (inf->CompareToEntryL((instances[counter])->Entry()))
{
INFO_PRINTF2(_L("Entry info matched instance %d"), (counter+1));
found = ETrue;
CCalProgress* progress1 = new(ELeave)CCalProgress;
CleanupStack::PushL(progress1);
CCalEntryView* eView = CCalEntryView::NewL(*iSession, *progress);
CleanupStack::PushL(eView);
CActiveScheduler::Start();
CCalEntry* eEntry = &((instances[counter])->Entry());
eEntry->SetDescriptionL(KTCIModifiedText());
RPointerArray<CCalEntry> eList;
CleanupResetAndDestroyPushL(eList);
eList.Reset();
TInt numChanged = 0;
eList.Append(eEntry);
eView->UpdateL(eList, numChanged);
if (numChanged != 1)
{
INFO_PRINTF1(_L("Error modifiying entry"));
User::Leave(KErrGeneral);
}
CleanupStack::PopAndDestroy(&eList);
CleanupStack::PopAndDestroy(2);
}
else
{
counter++;
}
}
CleanupStack::PopAndDestroy(&instances);
CleanupStack::PopAndDestroy(view);
CleanupStack::PopAndDestroy(progress);
CleanupStack::PopAndDestroy(inf);
if (!found)
{
INFO_PRINTF1(_L("Could not find entrytomodify in database"));
User::Leave(KErrNotFound);
}
}
