/*
* 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 'one' identity part
*                 of a Presence Condition in a rule
*
*/




// Includes
#include <XdmDocumentNode.h>
#include <XdmNodeAttribute.h>
#include <xcapappusagedef.h>
#include <utf.h>

#include "prescondidentityone.h"
#include "cpresencexdm.h"
#include "rlspresxdmlogger.h"
#include "rlspresxdmconstsint.h"


// ---------------------------------------------------------------------------
// TPresCondIdentityOne::TPresCondIdentityOne()
// ---------------------------------------------------------------------------
//	
EXPORT_C TPresCondIdentityOne::TPresCondIdentityOne(): iPresXDM(NULL)
    {
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::TPresCondIdentityOne()" ));
    }

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::Init()
// ---------------------------------------------------------------------------
//    
EXPORT_C void TPresCondIdentityOne::Init(CPresenceXDM* const aPresXDM)
    {
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::Init(%d)" ), aPresXDM);
    iPresXDM = aPresXDM;
    }

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::AddIdentitiesL()
// ---------------------------------------------------------------------------
//
EXPORT_C TInt TPresCondIdentityOne::AddIdentitiesL(const TDesC& aRuleID,
                                                const MDesCArray& aIds)
	{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::AddIdentitiesL()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S, aIdsCount = %d" ),&aRuleID, 
                                                        aIds.MdcaCount() );
    
    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));                                                    
    
	CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID, 
	                                                KXdmIdentity, ETrue);
	if(identityNode==NULL)
	    {
	    OPENG_DP(D_OPENG_LIT( "     return: KErrNotFound" ));
	    return KErrNotFound;
	    }
	    
    CXdmDocumentNode* oneNode(NULL);
    CXdmNodeAttribute* idAttr(NULL);
  	RPointerArray<CXdmDocumentNode> nodes;
  	
	// finding 'one' nodes
    TInt err = identityNode->Find(KXdmOne, nodes);
    OPENG_DP(D_OPENG_LIT( "     nodesCount = %d" ),nodes.Count());

    // putting ids to identity node
    TInt entitiesCount = aIds.MdcaCount();
    for(TInt i=0;i<entitiesCount;i++)
        {
        // find whether its already exist
        if(IsIdExistInNodeArray(nodes, aIds.MdcaPoint(i)) )
            continue;    
        oneNode = identityNode->CreateChileNodeL(KXdmOne);
        idAttr = oneNode->CreateAttributeL(KXdmId);
        idAttr->SetAttributeValueL(aIds.MdcaPoint(i));
        }
    
    nodes.Close();
    OPENG_DP(D_OPENG_LIT( "     return: KErrNone" ));    
    return KErrNone;
	}

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::GetIdentitiesL()
// ---------------------------------------------------------------------------
//	
EXPORT_C void TPresCondIdentityOne::GetIdentitiesL(const TDesC& aRuleID, 
                                                    CDesCArray& aIds)
	{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::GetIdentitiesL()" ) );
    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;
	
	RPointerArray<CXdmDocumentNode> nodes;
    CXdmNodeAttribute* idAttr(NULL);
	
	// finding 'one' nodes
    TInt err = identityNode->Find(KXdmOne, nodes);
    OPENG_DP(D_OPENG_LIT( "     nodesCount = %d" ),nodes.Count());

    // extracting ids from ones nodes
    TInt idsCountInNode = nodes.Count();
    for (TInt i=0;i<idsCountInNode;i++)
        { // get the id attribute
        idAttr = (nodes[i])->Attribute(KXdmId);
        // push it to given discriptor array
        aIds.AppendL(idAttr->AttributeValue());
        }

    nodes.Close();    
    return;
	}

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::DeleteIdentitiesL()
// ---------------------------------------------------------------------------
//	
EXPORT_C void TPresCondIdentityOne::DeleteIdentitiesL(const TDesC& aRuleID,
                                                    const MDesCArray& aIds)
	{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::DeleteIdentitiesL()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S, aIdsCount = %d" ),&aRuleID, 
                                                        aIds.MdcaCount() );
	
    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));                                                    
	
	CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID, 
	                                                KXdmIdentity, EFalse);
	if(identityNode==NULL)
	    return;
	
	RPointerArray<CXdmDocumentNode> nodes;
    CXdmNodeAttribute* idAttr(NULL);
	
	// finding 'one' nodes
    TInt err = identityNode->Find(KXdmOne, nodes);

    // extracting ids from ones nodes
    TInt idsCountInNode = nodes.Count();
    OPENG_DP(D_OPENG_LIT( "     nodesCount = %d" ),idsCountInNode);

    TInt entitiesCount = aIds.MdcaCount();
    for (TInt i=0;i<idsCountInNode;i++)
        { // get the id attribute
        idAttr = (nodes[i])->Attribute(KXdmId);
        // match it with all given entries
        for (TInt j=0;j<entitiesCount ; j++)
            {
            if ((aIds.MdcaPoint(j))==(idAttr->AttributeValue()))
                {
                OPENG_DP(D_OPENG_LIT( "     RemoveFromModelL i=%d,j=%d" ),i,j);
                iPresXDM->RemoveFromModelL(nodes[i]);
                break;               
                }
            }
        }

    nodes.Close();    
    return;
	}

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::DeleteAllIdentitiesL()
// ---------------------------------------------------------------------------
//
EXPORT_C void TPresCondIdentityOne::DeleteAllIdentitiesL(const TDesC& aRuleID)
	{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::DeleteAllIdentitiesL()" ) );
    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;
	
	RPointerArray<CXdmDocumentNode> nodes;
	
	// finding 'one' nodes
    TInt err = identityNode->Find(KXdmOne, nodes);
    
    // extracting ids from ones nodes
    TInt idsCountInNode = nodes.Count();
    OPENG_DP(D_OPENG_LIT( "     nodesCount = %d" ),idsCountInNode);
    
    for (TInt i=0;i<idsCountInNode;i++)
        {
        iPresXDM->RemoveFromModelL(nodes[i]);
        }

    nodes.Close();    
    return;
	}

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::AddIdentityL()
// ---------------------------------------------------------------------------
//	
EXPORT_C TInt TPresCondIdentityOne::AddIdentityL(const TDesC& aRuleID, 
                                                        const TDesC& aId)
	{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::AddIdentityL()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S, aId = %S"),&aRuleID, &aId);
	
    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
	
	CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID, 
	                                                KXdmIdentity, ETrue);
	if(identityNode==NULL)
	    return KErrNotFound;
	
	if(IsIdentityExistL(aRuleID,aId))
	    return KErrAlreadyExists;
	
    CXdmDocumentNode* oneNode(NULL);
    CXdmNodeAttribute* idAttr(NULL);
   
    oneNode = identityNode->CreateChileNodeL(KXdmOne);
    idAttr = oneNode->CreateAttributeL(KXdmId);
    idAttr->SetAttributeValueL(aId);
    
    OPENG_DP(D_OPENG_LIT( "     return: KErrNone"));
    return KErrNone;
	}

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::DeleteIdentityL()
// ---------------------------------------------------------------------------
//	
EXPORT_C TInt TPresCondIdentityOne::DeleteIdentityL(const TDesC& aRuleID, 
                                                        const TDesC& aId)
	{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::DeleteIdentityL()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S, aId = %S"),&aRuleID, &aId);
	
    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));
	
	TInt ret(KErrNotFound);
	
	CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID, 
	                                                KXdmIdentity, EFalse);
	if(identityNode==NULL)
	    return ret;

	RPointerArray<CXdmDocumentNode> nodes;
    CXdmNodeAttribute* idAttr(NULL);
	
	// finding 'one' nodes
    if ( (identityNode->Find(KXdmOne, nodes))==KErrNone)
        {
        // extracting ids from ones nodes
        TInt idsCountInNode = nodes.Count();
        OPENG_DP(D_OPENG_LIT( "     nodesCount = %d" ),idsCountInNode);
       
        for (TInt i=0;i<idsCountInNode;i++)
            { // get the id attribute
            idAttr = (nodes[i])->Attribute(KXdmId);
            if (aId==(idAttr->AttributeValue()))
                {
                OPENG_DP(D_OPENG_LIT( "     RemoveFromModelL: i=%d" ),i);
                iPresXDM->RemoveFromModelL(nodes[i]);
                ret = KErrNone;
                break;               
                }
            }
        }
    nodes.Close();    
    return ret;
	}

// ---------------------------------------------------------------------------
// TPresCondIdentityOne::IsIdentityExistL()
// ---------------------------------------------------------------------------
//	
EXPORT_C TBool TPresCondIdentityOne::IsIdentityExistL(const TDesC& aRuleID, 
                                                    const TDesC& aId)
	{
    OPENG_DP(D_OPENG_LIT( "TPresCondIdentityOne::IsIdentityExist()" ) );
    OPENG_DP(D_OPENG_LIT( "     aRuleID = %S, aId = %S"),&aRuleID, &aId);

    __ASSERT_ALWAYS(iPresXDM, User::Leave(KErrNotReady));

	CXdmDocumentNode* identityNode = iPresXDM->GetConditionChildNodeL(aRuleID, 
	                                                KXdmIdentity, EFalse);
	if(identityNode==NULL)
	    return EFalse;

	RPointerArray<CXdmDocumentNode> nodes;
    CXdmNodeAttribute* idAttr(NULL);
	
	// finding 'one' nodes
    TInt err = identityNode->Find(KXdmOne, nodes);
    
    // extracting ids from ones nodes
    TInt idsCountInNode = nodes.Count();
    OPENG_DP(D_OPENG_LIT( "     nodesCount = %d" ),idsCountInNode);
    
    for (TInt i=0;i<idsCountInNode;i++)
        { // get the id attribute
        idAttr = (nodes[i])->Attribute(KXdmId);
        if (aId==(idAttr->AttributeValue()))
            {
            OPENG_DP(D_OPENG_LIT( "     ETrue"));
            nodes.Close();
            return ETrue;               
            }
        }

    nodes.Close();    
    return EFalse;
	}
	
// ---------------------------------------------------------------------------
// TPresCondIdentityOne::IsIdExistInNodeArray()
// ---------------------------------------------------------------------------
//
TBool TPresCondIdentityOne::IsIdExistInNodeArray(
                        const RPointerArray<CXdmDocumentNode>& nodes, 
                                                    const TDesC& aId)
    {
    OPENG_DP(D_OPENG_LIT( " TPresCondIdentityOne::IsIdExistInNodeArray()" ) );
    OPENG_DP(D_OPENG_LIT( "     IsIdExistInNodeArray 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(KXdmId);
        if (aId==(idAttr->AttributeValue()))
            {
            OPENG_DP(D_OPENG_LIT( "     IsIdExistInNodeArray True"));
            return ETrue;               
            }
        }
    return EFalse;  
    }
    
// end of file