/*

* 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 module

*

*/

#include <e32def.h>

#include <nsmldebug.h>

#include <nsmldmmodule.h>

#include "nsmldmddf.h"

#include "nsmldmcommandbuffer.h"

#include "nsmldmtreeconstants.h"

#include "nsmldmuri.h"

#include <featmgr.h>

_LIT8(KNSmlDmUriDDF, "DDF");

_LIT8(KNSmlDmPropetyACL, "ACL");

_LIT8(KNSmlDmPropetyFormat, "Format");

_LIT8(KNSmlDmPropetyName, "Name");

_LIT8(KNSmlDmPropetySize, "Size");

_LIT8(KNSmlDmPropetyType, "Type");

_LIT8(KNSmlDmPropertyCaseSense, "CaseSense");

_LIT8(KNSmlDmDDFDevInfoModDDF, "DevInfo/Ext/ModDDF");

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

// CSmlDmModule

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

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

// CNSmlDmModule::~CNSmlDmModule()

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

	{

	delete iDDF;

	delete iCommandBuffer;

	iPropResults.ResetAndDestroy();

	FeatureManager::UnInitializeLib();

	}

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

// CNSmlDmModule* CNSmlDmModule::NewL( MNSmlDmModuleCallBack* aCallBack)

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

EXPORT_C CNSmlDmModule* CNSmlDmModule::NewL( MNSmlDmModuleCallBack* aCallBack)

	{

	CNSmlDmModule* self = new (ELeave) CNSmlDmModule();

	CleanupStack::PushL(self);

	self->ConstructL();

	self->iCallBack = aCallBack;

	CleanupStack::Pop();

	return self;

	}

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

// void CNSmlDmModule::SetServerL(const TDesC& aServer)

// Sets the server

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

EXPORT_C void CNSmlDmModule::SetServerL(const TDesC8& aServer)

	{

	_DBG_FILE("CNSmlDmModule::SetServer() : begin");

	iDDF->SetServerL(aServer);

	_DBG_FILE("CNSmlDmModule::SetServer() : end");

	}

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

// void CNSmlDmModule::AddObjectL(const TDesC8& aURI, const TDesC8& aObject,

//		const TDesC8& aType, TInt aStatusRef )

// Add operation in DM protocoll

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

EXPORT_C void CNSmlDmModule::AddObjectL(const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	TInt aStatusRef,

	TBool aLargeItem )

	{

	_DBG_FILE("CNSmlDmModule::AddObjectL() : begin");

	TPtrC8 uri = NSmlDmURI::RemoveDotSlash(aURI);

	if(iInTransaction)

		{

		if(aLargeItem)

			{

			DoSetStatusL(aStatusRef,KNSmlDmStatusCommandFailed);

			return;

			}

		//command buffering

		iCommandBuffer->AddObjectL(uri,aObject,aType,aStatusRef);

		}

	else

		{

		TInt status = KNSmlDmNoStatus;

		CNSmlDmDDF::TAccess access = iDDF->CheckURIL(NSmlDmURI::RemoveProp(uri),EAclAdd);

		if(access == CNSmlDmDDF::EOk )

			{

			//check if property asked

			TInt offset = uri.Find(KNSmlDmProperty);

			if(offset==KErrNotFound)

				{

				//property is not asked, put the request to adapter

				iDDF->AddObjectL(uri,aObject,aType,aStatusRef,aLargeItem);

				}

			else

				{

				status = KNSmlDmStatusCommandNotAllowed;

				}

			}

		else if(access==CNSmlDmDDF::ENotAccess)

			{

			status = KNSmlDmStatusCommandNotAllowed;

			}

		else

			{

			status = KNSmlDmStatusNotFound;

			}

		if(status!=KNSmlDmNoStatus)

			{

			DoSetStatusL(aStatusRef,status);

			}

		}

	_DBG_FILE("CNSmlDmModule::AddObjectL() : end");

	}

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

// void CNSmlDmModule::UpdateObjectL(const TDesC8& aURI, const TDesC8& aObject,

// const TDesC8& aType, TInt aStatusRef )

// Replace operation in DM protocoll

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

EXPORT_C void CNSmlDmModule::UpdateObjectL(const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	TInt aStatusRef,

	TBool aLargeItem,

	// FOTA

	TInt aTotSizeOfLarge

	// FOTA end

	 )

	{

	_DBG_FILE("CNSmlDmModule::UpdateObjectL() : begin");

	TPtrC8 uri = NSmlDmURI::RemoveDotSlash(aURI);

	if(iInTransaction)

		{

		if(aLargeItem)

			{

			DoSetStatusL(aStatusRef,KNSmlDmStatusCommandFailed);

			return;

			}

		//command buffering

		iCommandBuffer->UpdateObjectL(uri,aObject,aType,aStatusRef);

		}

	else

		{

		TInt status = KNSmlDmNoStatus;

		TInt offset = uri.Find(KNSmlDmProperty);

		CNSmlDmDDF::TAccess access = iDDF->CheckURIL(

			NSmlDmURI::RemoveProp(uri),EAclReplace);

		if(access == CNSmlDmDDF::EOk)

			{

			//check if property asked

			if(offset==KErrNotFound)

				{

				//property is not asked, put the request to adapter

				// FOTA

				iDDF->UpdateObjectL(uri,aObject,aType,aStatusRef,aLargeItem,aTotSizeOfLarge);

				// FOTA end

				}

			else

				{

				UpdatePropertyL(uri,aObject,aType,offset+

					KNSmlDmProperty().Length(),aStatusRef);

				}

			}

		else if(access == CNSmlDmDDF::ENotAccess)

			{

			status = KNSmlDmStatusCommandNotAllowed;

			}

		else

			{

			status = KNSmlDmStatusNotFound;

			}

		if(status!=KNSmlDmNoStatus)

			{

			DoSetStatusL(aStatusRef,status);

			}

		} //end else(iInTransAction)

	_DBG_FILE("CNSmlDmModule::UpdateObjectL() : end");

	}

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

// void CNSmlDmModule::FetchObjectL(const TDesC8& aURI, const TDesC8& aType,

// const TDesC8& aCmdRef, TInt aStatusRef,TBool aAclPass )

// Get operation in DM protocoll

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

EXPORT_C void CNSmlDmModule::FetchObjectL(const TDesC8& aURI,

	const TDesC8& aType,

	const TInt aResultsRef,

	TInt aStatusRef,

	TBool aAclPass)

	{

	_DBG_FILE("CNSmlDmModule::FetchObjectL() : begin");

	CBufBase *object=NULL;

	TPtrC8 uri = NSmlDmURI::RemoveDotSlash(aURI);

	if (uri.Compare(KNSmlDmUriDDF)==0)

		{

		object = CBufFlat::NewL(1024);

		CleanupStack::PushL(object);

		iDDF->GenerateDDFL(*object/*,iDbHandler*/);

		iCallBack->SetResultsL(aResultsRef,*object,aType,KNSmlDmFormatChr,

			object->Size());

		iCallBack->SetStatusL(aStatusRef,KNSmlDmStatusOK);

		CleanupStack::PopAndDestroy(); //object

		}

	else if(uri.Compare(KNSmlDmDDFDevInfoModDDF)==0)

		{

		object = CBufFlat::NewL(10);

		CleanupStack::PushL(object);

		TBuf8<10> ddfCRC;

		ddfCRC.Num(iDDFCrc);

		object->InsertL(0,ddfCRC);

		iCallBack->SetResultsL(aResultsRef,*object,aType,KNSmlDmFormatChr,

			object->Size());

		iCallBack->SetStatusL(aStatusRef,KNSmlDmStatusOK);

		CleanupStack::PopAndDestroy(); //object

		}

	else

		{

		if(iInTransaction)

			{

			//command buffering

			iCommandBuffer->FetchObjectL(uri,aType,aResultsRef,aStatusRef);

			}

		else

			{

			TInt status = KNSmlDmNoStatus;

			CNSmlDmDDF::TAccess access = iDDF->CheckURIL(

				NSmlDmURI::RemoveProp(uri),EAclGet);

			if(access == CNSmlDmDDF::EOk)

				{

				//check if property asked

				TInt offset = uri.Find(KNSmlDmProperty);

				if(offset==KErrNotFound)

					{

					if(uri.Find(KNSmlDmQuestionMark)>=0)

						{

						status = KNSmlDmStatusOptionalFeatureNotSupported;

						}

					else

						{

						//property is not asked, put the request to adapter

						iDDF->FetchObjectL(uri,aType,aResultsRef,aStatusRef,

							aAclPass);

						}

					}

				else

					{

					GetPropertyL(uri,aType,KNSmlDmProperty().Length()+

						offset,aResultsRef,aStatusRef);

					}

				}

			else if(access == CNSmlDmDDF::ENotAccess)

				{

				status = KNSmlDmStatusCommandNotAllowed;

				//check if property asked

				}

			else

				{

				status = KNSmlDmStatusNotFound;

				}

			if(status!=KNSmlDmNoStatus)

				{

				DoSetStatusL(aStatusRef,status);

				}

			} //end else iInTransAction

		} //end else DDF

	_DBG_FILE("CNSmlDmModule::FetchObjectL() : end");

	}

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

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

// Delete operation in DM protocoll

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

EXPORT_C void CNSmlDmModule::DeleteObjectL( const TDesC8& aURI,

TInt aStatusRef )

	{

	_DBG_FILE("CNSmlDmModule::DeleteObjectL() : begin");

	TPtrC8 uri = NSmlDmURI::RemoveDotSlash(aURI);

	if(iInTransaction)

		{

		//command buffering

		iCommandBuffer->DeleteObjectL(uri,aStatusRef);

		}

	else

		{

		TInt status = KNSmlDmNoStatus;

		CNSmlDmDDF::TAccess access = iDDF->CheckURIL(

			NSmlDmURI::RemoveProp(uri),EAclDelete);

		if(access==CNSmlDmDDF::EOk)

			{

			//check if property asked

			TInt offset = uri.Find(KNSmlDmProperty);

			if(offset==KErrNotFound)

				{

				//property is not asked, put the request to adapter

				iDDF->DeleteObjectL(uri,aStatusRef);

				}

			else

				{

				status = KNSmlDmStatusCommandNotAllowed;

				}

			}

		else if(access==CNSmlDmDDF::ENotAccess)

			{

			status = KNSmlDmStatusCommandNotAllowed;

			}

		else

			{

			status = KNSmlDmStatusNotFound;

			}

		if(status!=KNSmlDmNoStatus)

			{

			DoSetStatusL(aStatusRef,status);

			}

		}

	_DBG_FILE("CNSmlDmModule::DeleteObjectL() : end");

	}

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

// void CNSmlDmModule::ExecuteObjectL( const TDesC8& aURI,

// const TDesC8& aObject, const TDesC8& aType, TInt aStatusRef)

// Execute operation in DM protocoll

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

EXPORT_C void CNSmlDmModule::ExecuteObjectL( const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	TInt aStatusRef,

	// FOTA

	const TDesC8& aCorrelator,

	// FOTA end	

	TBool aLargeItem )

	{

	_DBG_FILE("CNSmlDmModule::ExecuteObjectL() : begin");

	TPtrC8 uri = NSmlDmURI::RemoveDotSlash(aURI);

	if(iInTransaction)

		{

		if(aLargeItem)

			{

			DoSetStatusL(aStatusRef,KNSmlDmStatusCommandFailed);

			return;

			}

		//command buffering

		// FOTA

		// It is not expected that the FOTA adapter will get atomic commands.

		// That's why correlator is not forwarded to the command buffer.

		// FOTA end		

		iCommandBuffer->ExecuteObjectL(uri,aObject,aType,aStatusRef);

		}

	else

		{

		TInt status = KNSmlDmNoStatus;

		TInt offset = uri.Find(KNSmlDmProperty);

		CNSmlDmDDF::TAccess access = iDDF->CheckURIL(

			NSmlDmURI::RemoveProp(uri),EAclExecute);

		if(access == CNSmlDmDDF::EOk)

			{

			//check if property asked

			if(offset==KErrNotFound)

				{

				//property is not asked, put the request to adapter

				// FOTA

				iDDF->ExecuteObjectL(uri,aObject,aType,aStatusRef,aCorrelator,aLargeItem);

				// FOTA end

				}

			else

				{

				status = KNSmlDmStatusCommandNotAllowed;

				}

			}

		else if(access == CNSmlDmDDF::ENotAccess)

			{

			//check if property asked

			status = KNSmlDmStatusCommandNotAllowed;

			}

		else

			{

			status = KNSmlDmStatusNotFound;

			}

		if(status!=KNSmlDmNoStatus)

			{

			DoSetStatusL(aStatusRef,status);

			}

		} //end else(iInTransAction)

	_DBG_FILE("CNSmlDmModule::ExecuteObjectL() : end");

	}

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

// void CNSmlDmModule::CopyObjectL( const TDesC8& aURI,

//	const TDesC8& aObject, const TDesC8& aType, TInt aStatusRef)

// Copy operation in DM protocoll.

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

EXPORT_C void CNSmlDmModule::CopyObjectL( const TDesC8& aTargetURI,

	const TDesC8& aSourceURI,

	const TDesC8& aType,

	TInt aStatusRef)

	{

	_DBG_FILE("CNSmlDmModule::CopyObjectL() : begin");

	TPtrC8 sourceUri = NSmlDmURI::RemoveDotSlash(aSourceURI);

	TPtrC8 targetUri = NSmlDmURI::RemoveDotSlash(aTargetURI);

	if(iInTransaction)

		{

		//command buffering

		iCommandBuffer->CopyObjectL(targetUri,sourceUri,aType,aStatusRef);

		}

	else

		{

		TInt status = KNSmlDmNoStatus;

		TInt offset = sourceUri.Find(KNSmlDmProperty);

		CNSmlDmDDF::TAccess access = iDDF->CheckURIL(

			NSmlDmURI::RemoveProp(sourceUri),EAclCopy);

		if(access == CNSmlDmDDF::EOk)

			{

			//check if property asked

			if(offset==KErrNotFound)

				{

				//property is not asked, put the request to adapter

				iDDF->CopyObjectL(targetUri,sourceUri,aType,aStatusRef);

				}

			else

				{

				status = KNSmlDmStatusCommandNotAllowed;

				}

			}

		else if(access == CNSmlDmDDF::ENotAccess)

			{

			//check if property asked

			status = KNSmlDmStatusCommandNotAllowed;

			}

		else

			{

			status = KNSmlDmStatusNotFound;

			}

		if(status!=KNSmlDmNoStatus)

			{

			DoSetStatusL(aStatusRef,status);

			}

		} //end else(iInTransAction)

	_DBG_FILE("CNSmlDmModule::CopyObjectL() : end");

	}

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

// void CNSmlDmModule::StartTransactionL( )

// Start Atomic operation

// Tells that the following commands must be buffered

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

EXPORT_C void CNSmlDmModule::StartTransactionL( )

	{

	iInTransaction = ETrue;

	if(iCommandBuffer==0)

		{

		iCommandBuffer = CNSmlDmCommandBuffer::NewL(*this);

		}

	}

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

// void CNSmlDmModule::CommitTransactionL( )

// Commit Atomic operation

// The buffered commands can be executed

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

EXPORT_C void CNSmlDmModule::CommitTransactionL( )

	{

	iInTransaction = EFalse;

	if(iCommandBuffer)

		{

		iCommandBuffer->CommitL(*iDDF);

		delete iCommandBuffer;

		iCommandBuffer = 0;

		}

	}

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

// void CNSmlDmModule::RollBackL( )

// Rollback Atomic operation

// The buffered commands are removed from buffer and they are not executed

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

EXPORT_C void CNSmlDmModule::RollBackL( )

	{

	iInTransaction = EFalse;

	if(iCommandBuffer)

		{

		delete iCommandBuffer;

		iCommandBuffer = 0;

		}