/*
* Copyright (c) 2006 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: RLS and Presence XDM, This class represents 'many' identity
* part of a Presence Condition in a rule
*
*/
// Includes
#include <XdmDocumentNode.h>
#include <XdmNodeAttribute.h>
#include <xcapappusagedef.h>
#include <utf.h>
#include "prescondidentitymany.h"
#include "cpresencexdm.h"
#include "rlspresxdmlogger.h"
#include "rlspresxdmconstsint.h"
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::TPresCondIdentityMany()
// ---------------------------------------------------------------------------
//
EXPORT_C TPresCondIdentityMany::TPresCondIdentityMany(): iPresXDM(NULL)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::TPresCondIdentityMany()" ));
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::Init()
// ---------------------------------------------------------------------------
//
EXPORT_C void TPresCondIdentityMany::Init(CPresenceXDM* const aPresXDM)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::Init(%d)" ), aPresXDM);
iPresXDM = aPresXDM;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::AddManyIdentityL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::AddManyIdentityL(const TDesC& aRuleID,
const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::AddManyIdentityL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID = %S, aDomain = %S"),&aRuleID, &aDomain);
TInt err(KErrAlreadyExists);
if(!(IsManyExistsL(aRuleID,aDomain)))
{
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, ETrue, aDomain);
if(manyNode==NULL)
err = KErrNotFound;
else
err = KErrNone;
}
OPENG_DP(D_OPENG_LIT( " return: %d"),err);
return err;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::IsManyExistsL()
// ---------------------------------------------------------------------------
//
EXPORT_C TBool TPresCondIdentityMany::IsManyExistsL(const TDesC& aRuleID,
const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::IsManyExists()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID = %S, aDomain = %S"),&aRuleID, &aDomain);
TBool ret(ETrue);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode==NULL)
ret = EFalse;
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::RemoveManyIdentityL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::RemoveManyIdentityL(const TDesC& aRuleID,
const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::RemoveManyIdentityL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID = %S, aDomain = %S"),&aRuleID, &aDomain);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
TInt ret(KErrNotFound);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode!=NULL)
{
OPENG_DP(D_OPENG_LIT( " Removed"));
iPresXDM->RemoveFromModelL(manyNode);
ret = KErrNone;
}
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::GetManyIdentityElementsL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::GetManyIdentityElementsL(const TDesC& aRuleID,
CDesCArray& aDomains)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::GetManyIdentityElementsL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID = %S" ),&aRuleID);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID,
KXdmIdentity, EFalse);
if(identityNode==NULL)
return 0;
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* domainAttr(NULL);
// finding 'many' nodes
TInt err = identityNode->Find(KXdmMany, nodes);
// extracting entities from id nodes
TInt manyCountInNode = nodes.Count();
OPENG_DP(D_OPENG_LIT( " manyCountInNode = %d" ),manyCountInNode);
for (TInt i=0;i<manyCountInNode;i++)
{ // get the domain attribute
domainAttr = (nodes[i])->Attribute(KXdmDomain);
if(domainAttr)
// push it to given discriptor array
aDomains.AppendL(domainAttr->AttributeValue());
}
nodes.Close();
return manyCountInNode;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::AddIdentityInManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::AddIdentityInManyExceptL(const TDesC& aRuleID,
const TDesC& aId, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::AddIdentityInManyExceptL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S,aId:%S"),
&aRuleID, &aDomain, &aId);
TInt ret(KErrAlreadyExists);
RPointerArray<CXdmDocumentNode> nodes;
CXdmDocumentNode* exceptNode(NULL);
CXdmNodeAttribute* idattr(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode!=NULL)
{
// if id doesnt exists in except
if (!(IsIdentityExistsInManyExceptL(aRuleID, aId, aDomain)))
{
exceptNode = manyNode->CreateChileNodeL(KXdmExcept);
idattr = exceptNode->CreateAttributeL(KXdmId);
idattr->SetAttributeValueL(aId);
ret = KErrNone;
}
}
else
ret = KErrNotFound;
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
nodes.Close();
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::AddIdentitiesInManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::AddIdentitiesInManyExceptL(const TDesC& aRuleID,
const CDesCArray& aIds, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::AddIdentitiesInManyExceptL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S"),
&aRuleID, &aDomain);
TInt ret(KErrNotFound);
RPointerArray<CXdmDocumentNode> nodes;
CXdmDocumentNode* exceptNode(NULL);
CXdmNodeAttribute* idattr(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
TInt entitiesCount = aIds.MdcaCount();
if(manyNode!=NULL)
{
for (TInt i = 0; i<entitiesCount; i++)
{
// if id doesnt exists in except
if (!(IsIdentityExistsInManyExceptL(aRuleID, aIds.MdcaPoint(i), aDomain)))
{
exceptNode = manyNode->CreateChileNodeL(KXdmExcept);
idattr = exceptNode->CreateAttributeL(KXdmId);
idattr->SetAttributeValueL(aIds.MdcaPoint(i));
ret = KErrNone;
}
}
ret = KErrNone;
}
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
nodes.Close();
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::GetIdentitiesFromManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::GetIdentitiesFromManyExceptL(const TDesC& aRuleID,
CDesCArray& aIds, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::GetIdentitiesFromManyExceptL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S"),&aRuleID, &aDomain);
TInt ret(KErrNotFound);
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* attrId(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode!=NULL)
{
TInt err = manyNode->Find(KXdmExcept, nodes);
TInt exceptNodeCount = nodes.Count();
// go through all 'except' nodes
for(TInt i=0;i<exceptNodeCount;i++)
{
attrId = (nodes[i])->Attribute(KXdmId);
// for now we are supposing that except has only 1 id
if(attrId!=NULL)
{
aIds.AppendL(attrId->AttributeValue());
}
attrId = NULL;
}
ret = KErrNone;
}
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
nodes.Close();
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::RemoveIdentityFromManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::RemoveIdentityFromManyExceptL(
const TDesC& aRuleID, const TDesC& aId, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::RemoveIdentityFromManyExceptL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S,aId:%S"),
&aRuleID, &aDomain, &aId);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
TInt ret(KErrNotFound);
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* attrId(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode!=NULL)
{
TInt err = manyNode->Find(KXdmExcept, nodes);
TInt exceptNodeCount = nodes.Count();
//go through all except nodes
for (TInt i=0;i<exceptNodeCount;i++)
{
attrId = (nodes[i])->Attribute(KXdmId);
// for now we are supposing that except has only 1 id
if(attrId!=NULL)
{
if (aId==(attrId->AttributeValue()))
{
OPENG_DP(D_OPENG_LIT( " RemoveFromModelL: i=%d" ),i);
iPresXDM->RemoveFromModelL(attrId);
//if except node is empty after this
if( (nodes[i])->AttributeCount() == 0)
{
// remove except node also
iPresXDM->RemoveFromModelL(nodes[i]);
}
ret = KErrNone;
break;
}
}
attrId = NULL;
}
}
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
nodes.Close();
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::DeleteAllIdentitiesFromManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityMany::DeleteAllIdentitiesFromManyExceptL(
const TDesC& aRuleID, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::DeleteAllIdentitiesFromManyExceptL()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S"),&aRuleID, &aDomain);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
TInt ret(KErrNotFound);
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* attrId(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode!=NULL)
{
TInt err = manyNode->Find(KXdmExcept, nodes);
TInt exceptNodeCount = nodes.Count();
//go through all except nodes
for (TInt i=0;i<exceptNodeCount;i++)
{
attrId = (nodes[i])->Attribute(KXdmId);
// for now we are supposing that except has only 1 id
if(attrId!=NULL)
{
OPENG_DP(D_OPENG_LIT( " RemoveFromModelL: i=%d" ),i);
iPresXDM->RemoveFromModelL(attrId);
//if except node is empty after this
if( (nodes[i])->AttributeCount() == 0)
{
// remove except node also
iPresXDM->RemoveFromModelL(nodes[i]);
}
}
attrId = NULL;
}
ret = KErrNone;
}
OPENG_DP(D_OPENG_LIT( " return: %d"),ret);
nodes.Close();
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::IsIdentityExistsInManyExceptL()
// ---------------------------------------------------------------------------
//
EXPORT_C TBool TPresCondIdentityMany::IsIdentityExistsInManyExceptL(const TDesC& aRuleID,
const TDesC& aId, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( "TPresCondIdentityMany::IsIdentityExistsInManyExcept()" ) );
OPENG_DP(D_OPENG_LIT( " aRuleID:%S,aDomain:%S,aId:%S"),
&aRuleID, &aDomain, &aId);
TBool ret(EFalse);
RPointerArray<CXdmDocumentNode> nodes;
CXdmNodeAttribute* attrId(NULL);
CXdmDocumentNode* manyNode = GetManyNodeL(aRuleID, EFalse, aDomain);
if(manyNode!=NULL)
{
TInt err = manyNode->Find(KXdmExcept, nodes);
TInt exceptNodeCount = nodes.Count();
//go through all except nodes
for (TInt i=0;i<exceptNodeCount;i++)
{
attrId = (nodes[i])->Attribute(KXdmId);
// for now we are supposing that except has only 1 id
if(attrId!=NULL)
{
if (aId==(attrId->AttributeValue()))
{
OPENG_DP(D_OPENG_LIT( " Found: i=%d" ),i);
ret = ETrue;
break;
}
}
attrId = NULL;
}
}
nodes.Close();
return ret;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::GetManyNodeL()
// ---------------------------------------------------------------------------
//
CXdmDocumentNode* TPresCondIdentityMany::GetManyNodeL(const TDesC& aRuleID,
TBool aCreate, const TDesC& aDomain)
{
OPENG_DP(D_OPENG_LIT( " TPresCondIdentityMany::GetManyNodeL()" ) );
OPENG_DP(D_OPENG_LIT( " GetManyNodeL aRuleID:%S, aDomain:%S, aCreate:%d"),
&aRuleID, &aDomain, aCreate);
__ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID,
KXdmIdentity, aCreate);
if (identityNode==NULL)
return NULL;
RPointerArray<CXdmDocumentNode> nodes;
CXdmDocumentNode* manyNode(NULL);
CXdmNodeAttribute* domainNameAttr(NULL);
// Finding many node
identityNode->Find(KXdmMany, nodes);
TInt manyNodesCount = nodes.Count();
OPENG_DP(D_OPENG_LIT( " manyNodesCount = %d"), manyNodesCount);
TBool found(EFalse);
if(manyNodesCount) // if some nodes exists
{
for (TInt i=0;i<manyNodesCount;i++)
{
domainNameAttr = (nodes[i])->Attribute(KXdmDomain);
// for the case when no domain specified
if (aDomain==KNullDesC)
{
if(domainNameAttr == NULL)
{
found = ETrue;
manyNode = nodes[i];
break;
}
}
// for the case when domain is specified
else if(domainNameAttr!=NULL)
{
if( (domainNameAttr->AttributeValue()) == aDomain)
{
found = ETrue;
manyNode = nodes[i];
break;
}
}
}
}
if (aCreate && (!found)) // if asked to create and still doesnt found
{
manyNode = identityNode->CreateChileNodeL(KXdmMany);
if(aDomain!=KNullDesC)
{
domainNameAttr = manyNode->CreateAttributeL(KXdmDomain);
domainNameAttr->SetAttributeValueL(aDomain);
}
}
nodes.Close();
return manyNode;
}
// ---------------------------------------------------------------------------
// TPresCondIdentityMany::IsEntityExistInNodeArray()
// ---------------------------------------------------------------------------
//
TBool TPresCondIdentityMany::IsEntityExistInNodeArray(
const RPointerArray<CXdmDocumentNode>& nodes,
const TDesC& aId)
{
OPENG_DP(D_OPENG_LIT( " TPresCondIdentityMany::IsEntityExistInNodeArray()" ) );
OPENG_DP(D_OPENG_LIT( " IsEntityExistInNodeArray aId = %S"), &aId);
TInt idsCountInNode = nodes.Count();
CXdmNodeAttribute* idAttr(NULL);
for (TInt i=0;i<idsCountInNode;i++)
{ // get the id attribute
idAttr = (nodes[i])->Attribute(KXdmEntity);
if (aId==(idAttr->AttributeValue()))
{
OPENG_DP(D_OPENG_LIT( " IsEntityExistInNodeArray True"));
return ETrue;
}
}
return EFalse;
}
// end of file