/*

* Copyright (c) 2005 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:  DM tree etc.

*

*/

#include "nsmldmcommandbuffer.h"

#include "nsmldmtreeconstants.h"

#include "nsmldmddf.h"

#include "nsmldmuri.h"

// ===========================================================================

// CNSmlDmCommandBuffer

// ===========================================================================

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::~CNSmlDmCommandBuffer()

// ---------------------------------------------------------------------------

CNSmlDmCommandBuffer::~CNSmlDmCommandBuffer()

	{

	if(iCommandBuffer !=0 )

	    {

	    CNSmlDmCommands* tmp=iCommandBuffer;

    	    while(tmp!=0)

    		{

        		tmp=iCommandBuffer->iNext;

        		delete iCommandBuffer;

        		iCommandBuffer = tmp;

    		}

	    }

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::CNSmlDmCommandBuffer()

// ---------------------------------------------------------------------------

CNSmlDmCommandBuffer::CNSmlDmCommandBuffer(CNSmlDmModule& aDmModule)

	:iDmModule(aDmModule)

	{

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer* CNSmlDmCommandBuffer::NewL()

// ---------------------------------------------------------------------------

CNSmlDmCommandBuffer* CNSmlDmCommandBuffer::NewL(CNSmlDmModule& aDmModule)

	{

	CNSmlDmCommandBuffer* self = new (ELeave) CNSmlDmCommandBuffer(aDmModule);

	return self;

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::AddObjectL()

// Adds an Add command to the command buffer. The command is executed

// in Commit

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::AddObjectL(const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	TInt aStatusRef )

	{

	CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands;

	CleanupStack::PushL(cmd);

	cmd->iURI = aURI.AllocL();

	cmd->iObject = aObject.AllocL();

	cmd->iType = aType.AllocL();

	cmd->iStatusRef = aStatusRef;

	cmd->iCmdType = EAclAdd;

	if(iCommandBuffer==0)

		{

		iCommandBuffer = cmd;

		}

	else

		{

		CNSmlDmCommands* tmp=iCommandBuffer;

		while(tmp->iNext!=0)

			{

			tmp=tmp->iNext;

			}

		tmp->iNext = cmd;

		}

	CleanupStack::Pop(); //cmd

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::UpdateObjectL()

// Adds an Update command to the command buffer. The command is executed

// in Commit

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::UpdateObjectL( const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	TInt aStatusRef)

	{

	CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands;

	CleanupStack::PushL(cmd);

	cmd->iURI = aURI.AllocL();

	cmd->iObject = aObject.AllocL();

	cmd->iType = aType.AllocL();

	cmd->iStatusRef = aStatusRef;

	cmd->iCmdType = EAclReplace;

	if(iCommandBuffer==0)

		{

		iCommandBuffer = cmd;

		}

	else

		{

		CNSmlDmCommands* tmp=iCommandBuffer;

		while(tmp->iNext!=0)

			{

			tmp=tmp->iNext;

			}

		tmp->iNext = cmd;

		}

	CleanupStack::Pop();

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::FetchObjectL()

// Adds an Fetch command to the command buffer. The command is executed in Commit

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::FetchObjectL(const TDesC8& aURI,

	const TDesC8& aType,

	TInt aResultsRef,

	TInt aStatusRef )

	{

	CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands;

	CleanupStack::PushL(cmd);

	cmd->iURI = aURI.AllocL();

	cmd->iType = aType.AllocL();

	cmd->iStatusRef = aStatusRef;

	cmd->iCmdType = EAclGet;

	cmd->iResultsRef = aResultsRef;

	if(iCommandBuffer==0)

		{

		iCommandBuffer = cmd;

		}

	else

		{

		CNSmlDmCommands* tmp=iCommandBuffer;

		while(tmp->iNext!=0)

			{

			tmp=tmp->iNext;

			}

		tmp->iNext = cmd;

		}

	CleanupStack::Pop(); //cmd

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::DeleteObjectL()

// Adds an Delete command to the command buffer. The command is executed

// in Commit

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::DeleteObjectL( const TDesC8& aURI, TInt aStatusRef)

	{

	CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands;

	CleanupStack::PushL(cmd);

	cmd->iURI = aURI.AllocL();

	cmd->iStatusRef = aStatusRef;

	cmd->iCmdType = EAclDelete;

	if(iCommandBuffer==0)

		{

		iCommandBuffer = cmd;

		}

	else

		{

		CNSmlDmCommands* tmp=iCommandBuffer;

		while(tmp->iNext!=0)

			{

			tmp=tmp->iNext;

			}

		tmp->iNext = cmd;

		}

	CleanupStack::Pop(); //cmd

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::ExecuteObjectL()

// Adds an Execute command to the command buffer. The command is executed

// in Commit

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::ExecuteObjectL( const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	TInt aStatusRef)

	{

	CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands;

	CleanupStack::PushL(cmd);

	cmd->iURI = aURI.AllocL();

	cmd->iObject = aObject.AllocL();

	cmd->iType = aType.AllocL();

	cmd->iStatusRef = aStatusRef;

	cmd->iCmdType = EAclExecute;

	if(iCommandBuffer==0)

		{

		iCommandBuffer = cmd;

		}

	else

		{

		CNSmlDmCommands* tmp=iCommandBuffer;

		while(tmp->iNext!=0)

			{

			tmp=tmp->iNext;

			}

		tmp->iNext = cmd;

		}

	CleanupStack::Pop(); //cmd

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::CopyObjectL()

// Adds an Copy command to the command buffer. The command is executed

// in Commit

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::CopyObjectL( const TDesC8& aTargetURI,

	const TDesC8& aSourceURI,

	const TDesC8& aType,

	TInt aStatusRef)

	{

	CNSmlDmCommands* cmd = new (ELeave) CNSmlDmCommands;

	CleanupStack::PushL(cmd);

	cmd->iURI = aSourceURI.AllocL();

	cmd->iTargetURI = aTargetURI.AllocL();

	cmd->iType = aType.AllocL();

	cmd->iStatusRef = aStatusRef;

	cmd->iCmdType = EAclCopy;

	if(iCommandBuffer==0)

		{

		iCommandBuffer = cmd;

		}

	else

		{

		CNSmlDmCommands* tmp=iCommandBuffer;

		while(tmp->iNext!=0)

			{

			tmp=tmp->iNext;

			}

		tmp->iNext = cmd;

		}

	CleanupStack::Pop(); //cmd

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::IsGetWithAtomic()

// Checks whether nested Get command is there inside atomic command

// ---------------------------------------------------------------------------

TBool CNSmlDmCommandBuffer::IsGetWithAtomic()

{ TBool isget(EFalse);

	TInt  isnested = -1;

 CNSmlDmCommands* cmd=iCommandBuffer;

 while(cmd !=0)

 {

 	if(cmd->iCmdType == EAclGet)

    {  

    	isget =ETrue;

    }

  isnested++;

  cmd=cmd->iNext;

 }

if(isnested > 0 && isget)

    {

    	  return ETrue;

    } 

 return EFalse;   

 }

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::CommitL()

// Executes the commands in commandbuffer. If some of commands fails,

// the rest of commands are deleted without execution

// (NotExecuted status is returned)

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::CommitL(  CNSmlDmDDF& aDDF )

	{

	aDDF.StartAtomicL();

	CNSmlDmCommands* cmd=iCommandBuffer;

	while(cmd!=0)

		{

		if(!cmd->iGotStatus)

			{

			//check the access from the ddf (not acl)

			CNSmlDmDDF::TAccess access = aDDF.CheckURIL(

				NSmlDmURI::RemoveProp(cmd->iURI->Des()),cmd->iCmdType);

			if(access == CNSmlDmDDF::EOk ) //access ok

				{

				TInt offset = cmd->iURI->Find(KNSmlDmProperty);

				if(offset==KErrNotFound) //not property asked

					{

					switch(cmd->iCmdType)

						{

						case EAclAdd:

						aDDF.AddObjectL(*cmd->iURI,*cmd->iObject,

							*cmd->iType,cmd->iStatusRef);

						break;

						case EAclReplace:

						aDDF.UpdateObjectL(*cmd->iURI,*cmd->iObject,

							*cmd->iType,cmd->iStatusRef);

						break;

						case EAclGet:

						if(IsGetWithAtomic())

						{

							cmd->iStatusCode = KNSmlDmStatusCommandFailed;

				        cmd->iGotStatus = ETrue;

						}

						else

						aDDF.FetchObjectL(*cmd->iURI,*cmd->iType,

							cmd->iResultsRef,cmd->iStatusRef);

						break;

						case EAclDelete:

						aDDF.DeleteObjectL(*cmd->iURI,cmd->iStatusRef);

						break;

						case EAclExecute:

						// FOTA

						aDDF.ExecuteObjectL(*cmd->iURI,*cmd->iObject,

							*cmd->iType,cmd->iStatusRef, KNullDesC8);

						// FOTA end							

						break;

						case EAclCopy:

						aDDF.CopyObjectL(*cmd->iTargetURI,*cmd->iURI,

							*cmd->iType,cmd->iStatusRef);

						break;

						default:

						User::Panic ( KNSmlTxtPanicDmModule, KErrArgument );

						break;

						}

					}

				else //property

					{

					switch(cmd->iCmdType)

						{

						case EAclReplace:

						iDmModule.UpdatePropertyL(*cmd->iURI,*cmd->iObject,

							*cmd->iType,offset+KNSmlDmProperty().Length(),

							cmd->iStatusRef);

						break;

						case EAclGet:

						iDmModule.GetPropertyL(*cmd->iURI,*cmd->iType,

							KNSmlDmProperty().Length()+offset,

							cmd->iResultsRef,cmd->iStatusRef);

						break;

						default:

						cmd->iStatusCode = KNSmlDmStatusCommandNotAllowed;

						cmd->iGotStatus = ETrue;

						break;

						}

					} //end else

				} //end if(CheckURIL())

			else if(access == CNSmlDmDDF::ENotAccess )

				{

				cmd->iStatusCode = KNSmlDmStatusCommandNotAllowed;

				cmd->iGotStatus = ETrue;

				}

			else

				{

				SetStatus(cmd->iStatusRef,KNSmlDmStatusNotFound);

				}

			}

		cmd=cmd->iNext;

		} //end while

	aDDF.EndMessageL();

	if(AtomicFailed())

		{

		aDDF.RollbackAtomicL();

		RollBackL(aDDF);

		}

	else

		{

		aDDF.CommitAtomicL();		

		}

	ChangeAtomicStatuses();

	SendStatusAndResultCodesL();

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::RollBackL()

// Returns status NotExecuted to the commands in commandbuffer

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::RollBackL(CNSmlDmDDF& aDDF)

	{

	CNSmlDmCommands* cmd=iCommandBuffer;

	TBool loopAgain = EFalse;

	while(cmd!=0)

		{

		if(cmd->iGotStatus &&

			cmd->iStatusCode==KNSmlDmStatusOK &&

			cmd->iURI->Find(KNSmlDmProperty)==KErrNotFound)

			{

			if(cmd->iCmdType==EAclAdd)

				{

				loopAgain=ETrue;

				delete cmd->iCallback;

				cmd->iCallback=0;

				cmd->iCallback = CNSmlDmLinkCallback::NewL();

				iDmModule.DeleteInTransactionL(*cmd->iURI,cmd->iCallback);

				}

			if(cmd->iCmdType!=EAclGet)

				{

				cmd->iStatusCode = KNSmlDmStatusAtomicRollBackFailed;

				}

			}

			else if(cmd->iStatusCode != KNSmlDmStatusOK)

			{	

				cmd->iStatusCode = KNSmlDmStatusCommandFailed;

			}

		cmd=cmd->iNext;

		}

	if(loopAgain)

		{

		cmd=iCommandBuffer;

		while(cmd!=0)

			{

			if(cmd->iCmdType==EAclAdd&&cmd->iCallback)

				{

				TInt status = cmd->iCallback->GetStatusL();

				if(status==KNSmlDmStatusOK || ParentNodeDeletedL(*cmd->iURI) ||

					(status==KNSmlDmStatusNotFound&&

					aDDF.CheckURIL(*cmd->iURI,EAclAdd)==CNSmlDmDDF::EOk) )

					{

					cmd->iStatusCode = KNSmlDmStatusAtomicRollBackOK;

					}

				}

			else if(cmd->iCmdType==EAclReplace)

				{

				if(ParentNodeDeletedL(*cmd->iURI))

					{

					cmd->iStatusCode = KNSmlDmStatusAtomicRollBackOK;

					}

				}

			cmd=cmd->iNext;

			}

		}

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::ChangeAtomicStatuses()

// Changes all statuses so that they matches to atomic statuses

// ---------------------------------------------------------------------------

void CNSmlDmCommandBuffer::ChangeAtomicStatuses()

	{

	CNSmlDmCommands* cmd=iCommandBuffer;

	if(iAtomicFailed)

		{

		while(cmd!=0)

			{

			if(cmd->iCmdType==EAclReplace &&

				cmd->iURI->Find(KNSmlDmProperty) &&

				cmd->iStatusCode == KNSmlDmStatusOK)

				{

				cmd->iStatusCode = KNSmlDmStatusAtomicRollBackOK;

				}

			if( cmd->iStatusCode<KNSmlDmStatusLargestOK)

				{

				cmd->iStatusCode = KNSmlDmStatusAtomicRollBackFailed;

				}

			cmd=cmd->iNext;

			}		

		}

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::CheckResultsRef()

// Check if this fetch has came inside atomc

// ---------------------------------------------------------------------------

TBool CNSmlDmCommandBuffer::CheckResultsRef(TInt aResultsRef)

	{

	CNSmlDmCommands* cmd=iCommandBuffer;

	while(cmd!=0)

		{

		if(aResultsRef==cmd->iResultsRef)

			{

			return ETrue;

			}

		cmd=cmd->iNext;

		}

	return EFalse;

	}

// ---------------------------------------------------------------------------

// CNSmlDmCommandBuffer::CheckStatusRef()

// Check if this command has came inside atomc