void CPluginUtils::AddUrlParamL( RBuf& aBuf, const TDesC& aParam, const TDesC& aValue, TBool aLast)
{
aBuf.ReAllocL( aBuf.Length() + 1 + aParam.Length() + aValue.Length() );
aBuf.Append( aParam );
aBuf.Append( _L("=") );
aBuf.Append( aValue );
if( !aLast )
{
aBuf.ReAllocL( aBuf.Length() + 1 );
aBuf.Append( _L("&") );
}
}
void CPluginUtils::AddUrlParamL( RBuf& aBuf, const TDesC& aParam, TInt aValue, TBool aLast )
{
TBuf<12> t;
t.Format( _L("%d"), aValue );
aBuf.ReAllocL( aBuf.Length() + 1 + aParam.Length() + t.Length() );
aBuf.Append( aParam );
aBuf.Append( _L("=") );
aBuf.Append( t );
if( !aLast )
{
aBuf.ReAllocL( aBuf.Length() + 1 );
aBuf.Append( _L("&") );
}
}
void CQueueEntry::InternalizeL( RReadStream& aStream )
{
TInt size;
RBuf text;
CleanupClosePushL( text );
RBuf8 text8;
CleanupClosePushL( text8 );
size = aStream.ReadInt32L( );
text.ReAllocL( size );
aStream.ReadL( text, size );
SetUrlL(text);
size = aStream.ReadInt32L( );
if( size > text.Length() ) text.ReAllocL( size );
aStream.ReadL( text, size );
SetTitleL(text);
size = aStream.ReadInt32L( );
if( size > text.Length() ) text.ReAllocL( size );
aStream.ReadL( text, size );
SetTagsL(text);
size = aStream.ReadInt32L( );
if( size > text.Length() ) text.ReAllocL( size );
aStream.ReadL( text, size );
SetDescriptionL( text );
size = aStream.ReadInt32L( );
if( size > text.Length() ) text.ReAllocL( size );
aStream.ReadL( text, size );
SetFilename( text );
CleanupStack::PopAndDestroy( &text8 );
CleanupStack::PopAndDestroy( &text );
iType = (TEntryType) aStream.ReadInt32L( );
iStatus = (TEntryStatus) aStream.ReadInt32L( );
iCategory = (TMovieCategory) aStream.ReadInt32L( );
iPublic = aStream.ReadInt32L( );
iSize = aStream.ReadInt32L( );
iUid = aStream.ReadInt32L( );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CaSqlQueryCreator::CreateGetParentsIdsQueryL(
const RArray<TInt>& aEntryIdArray, CCaSqlQuery* aSqlQuery,
const RArray<TInt>& aParentIdArray )
{
DEBUG(("_CA_:CASqlQueryCreator::CreateGetParentsIdsQueryL"));
RBuf entryIdList;
entryIdList.CleanupClosePushL();
CreateIdListL( aEntryIdArray.Count(), entryIdList, KSQLGEEntryId );
RBuf parentIdList;
parentIdList.CleanupClosePushL();
CreateIdListL( aParentIdArray.Count(), parentIdList, KSQLGEIdGroup );
RBuf query;
query.CleanupClosePushL();
query.CreateL( KSQLGetParentIds().Length() + entryIdList.Length() );
query.AppendFormat( KSQLGetParentIds, &entryIdList );
if( aParentIdArray.Count() > 0 )
{
query.ReAllocL( query.Length() + parentIdList.Length()
+ KSQLNotINIds().Length() );
query.AppendFormat( KSQLNotINIds, &parentIdList );
}
aSqlQuery->SetQueryL( query );
CleanupStack::PopAndDestroy( &query );
CleanupStack::PopAndDestroy( &parentIdList );
CleanupStack::PopAndDestroy( &entryIdList );
}
HBufC* CPluginUtils::ConvertUtfToUnicodeL( const TDesC8& aUtf7 )
{
RBuf output;
CleanupClosePushL( output );
TBuf16<20> outputBuffer;
TPtrC8 remainderOfUtf7( aUtf7 );
for(;;)
{
const TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(outputBuffer, remainderOfUtf7);
if (returnValue==CnvUtfConverter::EErrorIllFormedInput)
return NULL;
else if (returnValue<0)
return NULL;
output.ReAllocL( output.Length() + outputBuffer.Length() );
output.Append( outputBuffer );
if (returnValue == 0)
break;
remainderOfUtf7.Set(remainderOfUtf7.Right(returnValue));
}
HBufC* ret = output.AllocL();
CleanupStack::PopAndDestroy( &output );
return ret;
}
/*
* Save Form data, function to be executed when save option is selected.
* Creates the second form which allows for selecting the category.
*/
TBool CYPagesForm1::SaveFormDataL()
{
CAknPopupFieldText* popupFieldText = static_cast <CAknPopupFieldText*> (ControlOrNull(EYPagesPopup));
if (popupFieldText) {
TInt categoryIndex = popupFieldText->CurrentValueIndex();
TBuf <30> KMyTextFile;
KMyTextFile.Format(_L("D:\\YPages\\%d%d.txt"), iColor, categoryIndex);
RFs fileServer;
User :: LeaveIfError (fileServer.Connect());
RFile file;
User::LeaveIfError(file.Open(fileServer, KMyTextFile, EFileRead|EFileStreamText));
CleanupClosePushL(file);
TFileText fileText;
fileText.Set(file);
TBuf<100> buffer;
buffer = _L("");
RBuf rBuf;
rBuf.Create(buffer);
rBuf.CleanupClosePushL();
TInt err = KErrNone;
while(err != KErrEof) {
err = fileText.Read(buffer);
if ((err != KErrNone) && (err != KErrEof)) {
User :: Leave(err);
}
if (KErrNone == err) {
rBuf.ReAllocL(rBuf.Length() + buffer.Length()+2);
rBuf.Append(buffer);
rBuf.Append(_L("\n"));
}
}
CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL(rBuf);
dlg->PrepareLC(R_ABOUT_HEADING_PANE);
dlg->SetHeaderTextL(_L(""));
dlg->RunLD();
CleanupStack::PopAndDestroy(&rBuf);
CleanupStack::PopAndDestroy(&file);
fileServer.Close();
}
return ETrue;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CaSqlQueryCreator::CreateUpdateIconQueryL(
const CCaInnerEntry* aEntry, CCaSqlQuery* aQuery )
{
DEBUG(("_CA_:CASqlQueryCreator::CreateUpdateIconQueryL"));
RBuf query;
query.CleanupClosePushL();
query.CreateL( KSQLUpdateIcon().Length() );
query.Append( KSQLUpdateIcon );
if( aEntry->Icon()->FileName().Compare( KNullDesC ) )
{
query.ReAllocL( query.Length() + KSQLUpdateIconFileName().Length()
+ KComma().Length() );
query.Append( KSQLUpdateIconFileName );
query.Append( KComma );
}
if( aEntry->Icon()->SkinId().Compare( KNullDesC ) )
{
query.ReAllocL( query.Length() + KSQLUpdateIconSkinId().Length()
+ KComma().Length() );
query.Append( KSQLUpdateIconSkinId );
query.Append( KComma );
}
if( aEntry->Icon()->ApplicationId().Compare(KNullDesC) )
{
query.ReAllocL( query.Length() + KSQLUpdateIconAppId().Length()
+ KComma().Length() );
query.Append( KSQLUpdateIconAppId );
}
if( !query.Right( KComma().Length() ).Compare( KComma ) )
{
query.Delete( query.Length() - KComma().Length(), KComma().Length() );
}
// add WHERE expr
query.ReAllocL( query.Length() + KSQLUpdateIconWhere().Length() );
query.Append( KSQLUpdateIconWhere );
aQuery->SetQueryL( query );
aQuery->SetTableType( CCaSqlQuery::EIconTable );
CleanupStack::PopAndDestroy( &query );
}
// ----------------------------------------------------------
// CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndCompleteL
// Shows the notifier in backround
// ----------------------------------------------------------
//
void CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndCompleteL()
{
FLOG(_L("[BTNOTIF]\t CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndComplete()"));
//get full path to the DCMO resource file
TParse* parser = new (ELeave) TParse;
parser->Set(KDcmoResourceFileName(), &KDC_RESOURCE_FILES_DIR, NULL);
CleanupStack::PushL(parser);
TFileName* fileName = new (ELeave) TFileName;
*fileName = parser->FullName();
CleanupStack::PopAndDestroy(parser);
CleanupStack::PushL(fileName);
//create the resource reader object that we need to use several times
CTulStringResourceReader* reader = CTulStringResourceReader::NewL(*fileName);
CleanupStack::PushL(reader);
//get pointer to the message part of the notifier
TPtrC resourceString;
resourceString.Set(reader->ReadResourceString(R_DM_RUN_TIME_VAR_DISABLE));
//create descriptor with a max length to fit the localised "disabled" text + new line + "Bluetooth"
RBuf content;
content.CreateL(resourceString.Length() + KNewLine().Length() + KDefaultBluetoothStringLength);
CleanupClosePushL(content);
//add resource string and new line character to the content descriptor
content.Append(resourceString);
content.Append(KNewLine());
//get pointer to the Bluetooth name part of the notifier (can't assume this is actually "Bluetooth" in all languages)
resourceString.Set(reader->ReadResourceString(R_DM_RUN_TIME_VAR_BLUETOOTH));
//check that the resource string will fit into the content descriptor
TInt requiredLength = content.Length() + resourceString.Length();
if (requiredLength > content.MaxLength())
{
//allocate more space in the content descriptor
content.ReAllocL(requiredLength);
}
//add resource string to the content descriptor
content.Append(resourceString);
//display the notifier and complete
iNotifUiUtil->ShowInfoNoteL(content, ECmdBTnotifUnavailable);
CompleteMessage(KErrNone);
//pop and destroy the content descriptor, resource reader and file name
CleanupStack::PopAndDestroy(3, fileName);
FLOG(_L("[BTNOTIF]\t CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndComplete() complete"));
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CaSqlQueryCreator::CreateFindIconQueryL( CCaInnerEntry* aEntry,
CCaSqlQuery* aQuery)
{
RBuf iconQuery;
iconQuery.CleanupClosePushL();
iconQuery.CreateL( KSQLGetIconIdWhere );
if( aEntry->Icon()->FileName().Compare( KNullDesC ) )
{
iconQuery.ReAllocL( iconQuery.Length() + KSQLUpdateIconFileName().Length()
+ KAnd().Length() );
iconQuery.Append( KSQLUpdateIconFileName );
iconQuery.Append( KAnd );
}
else
{
iconQuery.ReAllocL( iconQuery.Length() + KSQLEmptyIconFileName().Length()
+ KAnd().Length() );
iconQuery.Append( KSQLEmptyIconFileName );
iconQuery.Append( KAnd );
}
if( aEntry->Icon()->SkinId().Compare( KNullDesC ) )
{
iconQuery.ReAllocL( iconQuery.Length() + KSQLUpdateIconSkinId().Length()
+ KAnd().Length() );
iconQuery.Append( KSQLUpdateIconSkinId );
iconQuery.Append( KAnd );
}
else
{
iconQuery.ReAllocL( iconQuery.Length() + KSQLEmptyIconSkinId().Length()
+ KAnd().Length() );
iconQuery.Append( KSQLEmptyIconSkinId );
iconQuery.Append( KAnd );
}
if( aEntry->Icon()->ApplicationId().Compare( KNullDesC ) )
{
iconQuery.ReAllocL( iconQuery.Length() + KSQLUpdateIconAppId().Length()
+ KAnd().Length() );
iconQuery.Append( KSQLUpdateIconAppId );
iconQuery.Append( KAnd );
}
else
{
iconQuery.ReAllocL( iconQuery.Length() + KSQLEmptyIconAppId().Length()
+ KAnd().Length() );
iconQuery.Append( KSQLEmptyIconAppId );
iconQuery.Append( KAnd );
}
if (!iconQuery.Right(KAnd().Length()).Compare(KAnd))
{
iconQuery.Delete( iconQuery.Length() - KAnd().Length(), KAnd().Length() );
}
aQuery->SetQueryL( iconQuery );
CleanupStack::PopAndDestroy( &iconQuery );
}
void CPluginUtils::AddMultipartParamL( RBuf& aBuf, const TDesC& aParam, const TDesC& aValue )
{
aBuf.ReAllocL( aBuf.Length() + KBoundary().Length() + aParam.Length() + aValue.Length() + 2 + 2 + 2 + 2 + 2 + 1 + KDisposition().Length() );
aBuf.Append( _L("--") );
aBuf.Append( KBoundary() );
aBuf.Append( KCrLf );
aBuf.Append( KDisposition() );
aBuf.Append( aParam );
aBuf.Append( _L("\"") );
aBuf.Append( KCrLf );
aBuf.Append( KCrLf );
aBuf.Append( aValue );
aBuf.Append( KCrLf );
}
void CPluginUtils::AddMultipartParamL( RBuf& aBuf, const TDesC& aParam, TInt aValue )
{
TBuf<12> t;
t.Format( _L("%d"), aValue );
aBuf.ReAllocL( aBuf.Length() + KBoundary().Length() + aParam.Length() + t.Length() + 2 + 2 + 2 + 2 + 2 + 1 + KDisposition().Length() );
aBuf.Append( _L("--") );
aBuf.Append( KBoundary() );
aBuf.Append( KCrLf );
aBuf.Append( KDisposition() );
aBuf.Append( aParam );
aBuf.Append( _L("\"") );
aBuf.Append( KCrLf );
aBuf.Append( KCrLf );
aBuf.Append( t );
aBuf.Append( KCrLf );
}
EXPORT_C void SoftwareTypeRegInfoUtils::SerializeUniqueSwTypeNamesL(const RPointerArray<Usif::CSoftwareTypeRegInfo>& aSwTypeRegInfoArray, RBuf& aSerializedNames)
{
const TInt numNames = aSwTypeRegInfoArray.Count();
TInt bufLen = 0;
for (TInt i=0; i<numNames; ++i)
{
const Usif::CSoftwareTypeRegInfo& info = *aSwTypeRegInfoArray[i];
bufLen += info.UniqueSoftwareTypeName().Length() + sizeof(TChar);
}
aSerializedNames.ReAllocL(aSerializedNames.Length()+bufLen);
for (TInt i=0; i<numNames; ++i)
{
const Usif::CSoftwareTypeRegInfo& info = *aSwTypeRegInfoArray[i];
aSerializedNames.Append(info.UniqueSoftwareTypeName());
aSerializedNames.Append(static_cast<TChar>(KUniqueNameSeparator));
}
}
void AppendL(RBuf& aBuf, const TDesC& aDes, TBool aQuote)
{
const TInt requiredSpace = aDes.Length() + ((aBuf.Length() == 0) ? 0 : KEnumSeparator().Length()) + (aQuote ? 2 : 0);
if ((aBuf.Length() + requiredSpace) > aBuf.MaxLength())
{
aBuf.ReAllocL(Max(aBuf.Length() * 2, aBuf.Length() + requiredSpace));
}
if (aBuf.Length() > 0)
{
aBuf.Append(KEnumSeparator);
}
if (aQuote)
{
aBuf.Append(KEnumQuote);
}
aBuf.Append(aDes);
if (aQuote)
{
aBuf.Append(KEnumQuote);
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CaSqlQueryCreator::ModifyQueryForSortOrderL(
const CCaInnerQuery::TSortAttribute aSortType, RBuf& aQuery,
TBool aSortByGroup )
{
DEBUG(("_CA_:CASqlQueryCreator::ModifyQueryForSortOrderL"));
switch ( aSortType )
{
case CCaInnerQuery::Name:
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderNameAsc().Length() );
aQuery.Append( KSQLSortOrderNameAsc );
break;
}
case CCaInnerQuery::NameDesc:
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderNameDesc().Length() );
aQuery.Append( KSQLSortOrderNameDesc );
break;
}
case CCaInnerQuery::CreatedTimestamp:
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderCreatedTimestampAsc().Length() );
aQuery.Append( KSQLSortOrderCreatedTimestampAsc );
break;
}
case CCaInnerQuery::CreatedTimestampDesc:
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderCreatedTimestampDesc().Length() );
aQuery.Append( KSQLSortOrderCreatedTimestampDesc );
break;
}
case CCaInnerQuery::MostUsed:
case CCaInnerQuery::MostUsedDesc:
case CCaInnerQuery::LastUsed:
case CCaInnerQuery::LastUsedDesc:
{
ModifyQueryForSortOrderLastMostUsedL( aSortType, aQuery );
break;
}
case CCaInnerQuery::DefaultDesc:
{
if( aSortByGroup )
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderDefaultDesc().Length() );
aQuery.Append( KSQLSortOrderDefaultDesc );
}
else
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderIdDesc().Length() );
aQuery.Append( KSQLSortOrderIdDesc );
}
break;
}
case CCaInnerQuery::Default:
default:
{
if( aSortByGroup )
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderDefault().Length() );
aQuery.Append( KSQLSortOrderDefault );
}
else
{
aQuery.ReAllocL( aQuery.Length()
+ KSQLSortOrderIdAsc().Length() );
aQuery.Append( KSQLSortOrderIdAsc );
}
break;
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CaSqlQueryCreator::CreateGetEntriesQueryByQueryL(
const CCaInnerQuery* aQuery, CCaSqlQuery* aSqlQuery )
{
DEBUG(("_CA_:CASqlQueryCreator::CreateGetEntriesQueryByQueryL"));
RBuf whereStatement;
whereStatement.CleanupClosePushL();
TUint flagsOn = aQuery->GetFlagsOn();
if( flagsOn != 0 )
{
whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length()
+ KSQLGetEntryFlagsOn().Length() );
whereStatement.Append( KAnd );
whereStatement.Append( KSQLGetEntryFlagsOn );
}
TUint flagsOff = aQuery->GetFlagsOff();
if( flagsOff != 0 )
{
whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length()
+ KSQLGetEntryFlagsOff().Length() );
whereStatement.Append( KAnd );
whereStatement.Append( KSQLGetEntryFlagsOff );
}
TInt role = aQuery->GetRole();
if( role != 0 )
{
whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length()
+ KSQLGetEntryRole().Length() );
whereStatement.Append( KAnd );
whereStatement.Append( KSQLGetEntryRole );
}
TUint uid = aQuery->GetUid();
if( uid != 0 )
{
whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length()
+ KSQLGetEntryUid().Length() );
whereStatement.Append( KAnd );
whereStatement.Append( KSQLGetEntryUid );
}
const CDesC16ArrayFlat* typeNames = aQuery->GetEntryTypeNames();
if( typeNames && typeNames->MdcaCount() > 0 )
{
RBuf typeNameWhereStatement;
typeNameWhereStatement.CleanupClosePushL();
for( TInt i = 0; i < typeNames->MdcaCount(); i++ )
{
typeNameWhereStatement.ReAllocL(
typeNameWhereStatement.Length()
+ typeNames->MdcaPoint( i ).Length()
+ KSingleQuotes().Length() * 2 + KComma().Length() );
typeNameWhereStatement.Append( KSingleQuotes );
typeNameWhereStatement.Append( typeNames->MdcaPoint( i ) );
typeNameWhereStatement.Append( KSingleQuotes );
if( i != typeNames->MdcaCount() - 1 )
{
typeNameWhereStatement.Append( KComma );
}
}
whereStatement.ReAllocL( KAnd().Length()
+ KSQLGetEntryTypeNames().Length()
+ typeNameWhereStatement.Length()
+ whereStatement.Length() );
whereStatement.Append( KAnd );
whereStatement.AppendFormat( KSQLGetEntryTypeNames,
&typeNameWhereStatement );
CleanupStack::PopAndDestroy( &typeNameWhereStatement );
}
if( aQuery->GetAttributes().Count() )
{
RBuf whereAttributes;
whereAttributes.CleanupClosePushL();
whereAttributes.CreateL( KEmpty );
for( TInt j=1; j <= aQuery->GetAttributes().Count(); j++ )
{
// at1.AT_NAME = 'Attribute_Name_1' AND at1.AT_VALUE = 'Attribute_VALUE_1'
TPtrC atrName( aQuery->GetAttributes().operator [](j-1)->Name() );
TPtrC atrValue( aQuery->GetAttributes().operator [](j-1)->Value() );
whereAttributes.ReAllocL( whereAttributes.Length() + 2 * KAnd().Length() +
4 * KSingleQuotes().Length() +
2 * KMaxIntNumLength +
2 * KAt().Length() + 2 * KDot().Length() + 2 * KEqual().Length() +
KColumnAttrName().Length() + KColumnAttrValue().Length() +
atrName.Length() + atrValue.Length() );
whereAttributes.Append( KAnd );
whereAttributes.Append( KAt );
whereAttributes.AppendNum( j );
whereAttributes.Append( KDot );
whereAttributes.Append( KColumnAttrName );
whereAttributes.Append( KEqual );
whereAttributes.Append( KSingleQuotes );
whereAttributes.Append( atrName );
whereAttributes.Append( KSingleQuotes );
whereAttributes.Append( KAnd );
whereAttributes.Append( KAt );
whereAttributes.AppendNum( j );
whereAttributes.Append( KDot );
whereAttributes.Append( KColumnAttrValue );
whereAttributes.Append( KEqual );
whereAttributes.Append( KSingleQuotes );
whereAttributes.Append( atrValue );
whereAttributes.Append( KSingleQuotes );
}
whereStatement.ReAllocL( whereStatement.Length() + whereAttributes.Length() );
whereStatement.Append( whereAttributes );
CleanupStack::PopAndDestroy( &whereAttributes );
}
RBuf leftJoins;
leftJoins.CleanupClosePushL();
leftJoins.CreateL( KEmpty );
if( aQuery->GetAttributes().Count() )
{
for( TInt j=1; j <= aQuery->GetAttributes().Count(); j++ )
{
// LEFT JOIN CA_ATTRIBUTE as at1 ON ENTRY_ID = at1.AT_ENTRY_ID
leftJoins.ReAllocL( leftJoins.Length() +
KLeftJoinCaAttrubute1().Length() + KMaxIntNumLength +
KLeftJoinCaAttrubute2().Length() + KMaxIntNumLength +
KLeftJoinCaAttrubute3().Length()
);
leftJoins.Append( KLeftJoinCaAttrubute1 );
leftJoins.AppendNum( j );
leftJoins.Append( KLeftJoinCaAttrubute2 );
leftJoins.AppendNum( j );
leftJoins.Append( KLeftJoinCaAttrubute3 );
}
}
whereStatement.ReAllocL( whereStatement.Length() +
KGroupBy().Length() + KColumnEntryId().Length() );
whereStatement.Append( KGroupBy );
whereStatement.Append( KColumnEntryId );
TInt groupId = aQuery->GetParentId();
RBuf query;
query.CleanupClosePushL();
if( groupId > 0 )
{
RBuf getListByParentId2withWhere;
getListByParentId2withWhere.CleanupClosePushL();
getListByParentId2withWhere.CreateL( KSQLGetListByParentId2().Length() + whereStatement.Length() );
getListByParentId2withWhere.AppendFormat( KSQLGetListByParentId2, &whereStatement );
query.ReAllocL( KSQLGetListByParentId1().Length() + leftJoins.Length() +
getListByParentId2withWhere.Length() );
query.Append( KSQLGetListByParentId1 );
query.Append( leftJoins );
query.Append( getListByParentId2withWhere );
CleanupStack::PopAndDestroy( &getListByParentId2withWhere );
}
else if ( aQuery->GetChildId() > 0 )
{
RBuf getListByCildIdwithWhere;
getListByCildIdwithWhere.CleanupClosePushL();
getListByCildIdwithWhere.CreateL( KSQLGetListByChildId().Length() + whereStatement.Length() );
getListByCildIdwithWhere.AppendFormat( KSQLGetListByChildId, &whereStatement );
query.ReAllocL( KSQLGetListByParentId1().Length() + leftJoins.Length() +
getListByCildIdwithWhere.Length() );
query.Append( KSQLGetListByParentId1 );
query.Append( leftJoins );
query.Append( getListByCildIdwithWhere );
CleanupStack::PopAndDestroy( &getListByCildIdwithWhere );
}
else
{
query.CreateL( KSQLGetList1().Length() );
query.Append( KSQLGetList1 );
query.ReAllocL( query.Length() + leftJoins.Length() + KSQLGetList2().Length() );
query.Append( leftJoins );
query.Append( KSQLGetList2 );
if( whereStatement.Length() >= KAnd().Length() )
{
TPtrC ptrWhereStatement( whereStatement.Right(
whereStatement.Length() - KAnd().Length() ) );
query.ReAllocL( query.Length() + KWhere().Length()
+ ptrWhereStatement.Length() );
query.Append( KWhere );
query.Append( ptrWhereStatement );
}
}
CCaInnerQuery::TSortAttribute sort = aQuery->GetSort();
ModifyQueryForSortOrderL( sort, query, groupId > 0 );
if( aQuery->GetCount() > 0 )
{
query.ReAllocL( query.Length() + KLimit().Length()
+ KMaxIntNumLength );
query.Append( KLimit );
TInt limitCount = aQuery->GetCount();
query.AppendNum( limitCount );
}
aSqlQuery->SetQueryL( query );
CleanupStack::PopAndDestroy( &query );
CleanupStack::PopAndDestroy( &leftJoins );
CleanupStack::PopAndDestroy( &whereStatement );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CaSqlQueryCreator::CreateUpdateQueryEntryL(
const CCaInnerEntry* aEntry, CCaSqlQuery* aQuery )
{
DEBUG( ("_CA_:CASqlQueryCreator::CreateUpdateQueryEntryL") );
RBuf query;
query.CleanupClosePushL();
query.CreateL( KSQLUpdateEntry().Length() );
query.Append( KSQLUpdateEntry );
// text
if( aEntry->GetText().Length() != 0 )
{
query.ReAllocL( query.Length() + KSQLUpdateEntryText().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryText );
query.Append( KComma );
}
// description
query.ReAllocL( query.Length() + KSQLUpdateEntryDescription().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryDescription );
query.Append( KComma );
// role
query.ReAllocL( query.Length() + KSQLUpdateEntryRole().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryRole );
query.Append( KComma );
// type_name
if( aEntry->GetEntryTypeName().Length() != 0 )
{
query.ReAllocL( query.Length() + KSQLUpdateEntryTypeName().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryTypeName );
query.Append( KComma );
}
// id_icon
TIconType iconType = CaSqlQueryCreator::CheckIconType( aEntry );
if( iconType == ENullIconToRemove || iconType == ENullIcon )
{
query.ReAllocL( query.Length( ) +
KSQLUpdateEntryIdIconNull().Length() + KComma().Length() );
query.Append( KSQLUpdateEntryIdIconNull );
}
else
{
query.ReAllocL( query.Length( ) + KSQLUpdateEntryIdIcon().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryIdIcon );
}
query.Append( KComma );
// check if entry's Uid was set
if( aEntry->GetUid() )
{
query.ReAllocL( query.Length() + KSQLUpdateEntryUid().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryUid );
query.Append( KComma );
}
else
{
query.ReAllocL( query.Length() + KSQLUpdateEntryUidNULL().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryUidNULL );
query.Append( KComma );
}
//flags
query.ReAllocL( query.Length() + KSQLUpdateEntryFlags().Length()
+ KComma().Length() );
query.Append( KSQLUpdateEntryFlags );
query.ReAllocL( query.Length() + KSQLUpdateWhere().Length() );
query.Append( KSQLUpdateWhere );
aQuery->SetQueryL( query );
CleanupStack::PopAndDestroy( &query );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CaSqlQueryCreator::CreateAddQueryL( CCaInnerEntry* aEntry,
RPointerArray<CCaSqlQuery>& aSqlQuery, RSqlDatabase& aSqlDb )
{
DEBUG(("_CA_:CASqlQueryCreator::CreateAddQueryL"));
CCaSqlQuery* queryIcon = CCaSqlQuery::NewLC( aSqlDb );
TIconType iconType = CaSqlQueryCreator::CheckIconType( aEntry );
if( iconType == EProperIcon )
{
CreateAddIconQueryL( aEntry, queryIcon, aSqlDb );
//add new icon to DB
aSqlQuery.AppendL( queryIcon );
CleanupStack::Pop( queryIcon );
}
else
{
// icon added to DB by another entry or not added
CleanupStack::PopAndDestroy( queryIcon );
queryIcon = NULL;
}
if( aEntry->GetId() != -1 )
{
// check if entry is new and has to be added to DB or just updated
CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb );
if( aEntry->GetId() > 0 )
{
//Update query is faster than replace query
CreateUpdateQueryEntryL( aEntry, query );
}
else
{
// check if entry's Uid was set
if( aEntry->GetUid() == 0 )
{
if( ( aEntry->GetIconId() == 0 ) && ( queryIcon == NULL ) )
{
query->SetQueryL(
KSQLInsertToEntryUniqueUidWithoutIcon );
}
else
{
query->SetQueryL( KSQLInsertToEntryUniqueUid );
}
}
else
{
if( ( aEntry->GetIconId() == 0 ) && ( queryIcon == NULL ) )
{
query->SetQueryL( KSQLInsertToEntryWithoutIcon );
}
else
{
query->SetQueryL( KSQLInsertToEntry );
}
}
}
query->SetTableType( CCaSqlQuery::EEntryTable );
aSqlQuery.AppendL( query );
CleanupStack::Pop( query );
}
// remove all entry's attributs from DB
CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb );
query->SetQueryL( KSQLDeleteAttribute );
aSqlQuery.Append( query );
query->SetTableType( CCaSqlQuery::EAttributeTable );
CleanupStack::Pop( query );
if( aEntry->GetAttributes().Count() > 0 )
{
CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb );
query->SetQueryL( KSQLInsertToAttribute );
aSqlQuery.AppendL( query );
query->SetTableType( CCaSqlQuery::EAttributeTable );
CleanupStack::Pop( query );
}
if( iconType == ENullIconToRemove )
{
RBuf queryRemoveIcon;
queryRemoveIcon.CleanupClosePushL();
queryRemoveIcon.CreateL( KSQLDeleteIconWhereIconId().Length() );
queryRemoveIcon.Append( KSQLDeleteIconWhereIconId );
queryRemoveIcon.ReAllocL( KSQLDeleteIconWhereIconId().Length() + KMaxIntNumLength );
queryRemoveIcon.AppendNum( aEntry->GetIconId() );
CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb );
query->SetQueryL( queryRemoveIcon );
aSqlQuery.AppendL( query );
query->SetTableType( CCaSqlQuery::EIconTable );
CleanupStack::Pop( query );
CleanupStack::PopAndDestroy( &queryRemoveIcon );
}
}