/*

* Copyright (c) 2007-2009 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:  common email part object

*

*/

#include "emailtrace.h"

#include <apgcli.h>

#include <apmrec.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroy

//<cmail>

//</cmail>

// ================= MEMBER FUNCTIONS ==========================================

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

// CFSMailMessagePart::NewLC

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::NewLC( TFSMailMsgId aMessageId,

														TFSMailMsgId aMessagePartId )

{

    FUNC_LOG;

  CFSMailMessagePart* adr = new (ELeave) CFSMailMessagePart();

  CleanupStack::PushL(adr);

  adr->ConstructL( aMessageId, aMessagePartId );

  return adr;

} 

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

// CFSMailMessagePart::NewL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::NewL(	TFSMailMsgId aMessageId,

														TFSMailMsgId aMessagePartId )

{

    FUNC_LOG;

  CFSMailMessagePart* adr =  CFSMailMessagePart::NewLC( aMessageId, aMessagePartId );

  CleanupStack::Pop(adr);

  return adr;

}

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

// CFSMailMessagePart::ConstructL

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

void CFSMailMessagePart::ConstructL( TFSMailMsgId aMessageId,

                                     TFSMailMsgId aMessagePartId )

{

    FUNC_LOG;

	iMessageId = aMessageId;

	iMessagePartId = aMessagePartId;

	iMessagePartsStatus = EFSDefault;

	iContentTypeParams  = new (ELeave)CDesCArrayFlat( KArrayGranularity );

	iContentDispositionParams = new (ELeave)CDesCArrayFlat( KArrayGranularity );

}

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

// CFSMailMessagePart::~CFSMailMessagePart

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

EXPORT_C CFSMailMessagePart::~CFSMailMessagePart()

{

    FUNC_LOG;

	if(iContentType)

	{

		delete iContentType;

	}

    iContentType = NULL;

	if(iContentDescription)

	{

		delete iContentDescription;

	}

    iContentDescription = NULL;

	if(iContentDisposition)

	{

		delete iContentDisposition;

	}

	iContentDisposition = NULL;

	if(iAttachmentName)

	{

		delete iAttachmentName;

	}

 	iAttachmentName = NULL;

	if(iContentClass)

	{

		delete iContentClass;

	}

 	iContentClass = NULL;

	if(iContentID)

	{

		delete iContentID;

	}

 	iContentID = NULL;

	if(iMeetingRequest)

	{

		delete iMeetingRequest;

	}

	iMeetingRequest = NULL;

	if(iContentDispositionParams)

		{

	    iContentDispositionParams->Reset();

	    delete iContentDispositionParams;

		}

	if(iContentTypeParams)

		{

	    iContentTypeParams->Reset();

	    delete iContentTypeParams;		

		}

	iMessageParts.ResetAndDestroy();

}

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

// CFSMailMessagePart::CFSMailMessagePart

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

CFSMailMessagePart::CFSMailMessagePart() : CFSMailMessageBase()

{

    FUNC_LOG;

	iContentType = HBufC::New(1);

	iContentType->Des().Copy(KNullDesC());

	iContentDescription = HBufC::New(1);

	iContentDescription->Des().Copy(KNullDesC());

	iContentDisposition = HBufC::New(1);

	iContentDisposition->Des().Copy(KNullDesC());

	iContentClass = HBufC::New(1);

	iContentClass->Des().Copy(KNullDesC());

	iContentID = HBufC::New(1);

	iContentID->Des().Copy(KNullDesC());

	iAttachmentName = HBufC::New(1);

	iAttachmentName->Des().Copy(KNullDesC());

	iReadMessageParts = ETrue;

}

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

// CFSMailMessagePart::GetContentType

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

EXPORT_C const TDesC& CFSMailMessagePart::GetContentType()

{

    FUNC_LOG;

	return *iContentType;

}

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

// CFSMailMessagePart::SetContentType

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

EXPORT_C void CFSMailMessagePart::SetContentType(const TDesC& aContentType)

{

    FUNC_LOG;

	HBufC* contentType = HBufC::New(aContentType.Length());

	// store new mailbox name

	if(contentType)

	{

		delete iContentType;

		iContentType = contentType;

		iContentType->Des().Copy(aContentType);

	}

}

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

// CFSMailMessagePart::GetPartId

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

EXPORT_C TFSMailMsgId CFSMailMessagePart::GetPartId() const

{

    FUNC_LOG;

	return iMessagePartId;

}

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

// CFSMailMessagePart::ChildPartsL

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

EXPORT_C void CFSMailMessagePart::ChildPartsL(RPointerArray<CFSMailMessagePart>& aParts)

	{

    FUNC_LOG;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

		{

	    plugin->ChildPartsL(GetMailBoxId(),GetFolderId(),GetMessageId(),GetPartId(),aParts);

		}

	}

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

// CFSMailMessagePart::ChildPartL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::ChildPartL(TFSMailMsgId aPartId)

	{

    FUNC_LOG;

	CFSMailMessagePart* part = NULL;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

		{

		part = plugin->MessagePartL(GetMailBoxId(),

									GetFolderId(),

									GetMessageId(),

									aPartId);

		}

	return part;

	}

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

// CFSMailMessagePart::IsMessageL

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

EXPORT_C TBool CFSMailMessagePart::IsMessageL() const

	{

    FUNC_LOG;

	TBuf<KMaxDataTypeLength> ptr;

	if ( iContentType )

    {

		ptr.Copy(iContentType->Des());

		TInt length = ptr.Locate(';');

		if(length >= 0)

			{

			ptr.SetLength(length);

			}

		if( !ptr.CompareF(KFSMailContentTypeMessage) )

		{

			return ETrue;

		}

    }

	return EFalse;

	}

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

// CFSMailMessagePart::NewChildPartL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::NewChildPartL( const TFSMailMsgId aInsertBefore,

																const TDesC& aContentType )

	{

    FUNC_LOG;

	CFSMailMessagePart* part = NULL;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))

		{

		part = plugin->NewChildPartL( 	GetMailBoxId(), GetFolderId(), GetMessageId(),

								 		GetPartId(), aInsertBefore, aContentType );

		}

	return part;

	}

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

// CFSMailMessagePart::RemoveChildPartL

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

EXPORT_C void CFSMailMessagePart::RemoveChildPartL(TFSMailMsgId aPartId)

{

    FUNC_LOG;

	// get plugin pointer

	TFSMailMsgId id = GetPartId();

	if(id.IsNullId())

		{

		id = GetMessageId();

		}

	CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(id);

	if(plugin)

		{

		plugin->RemoveChildPartL( GetMailBoxId(), GetFolderId(), GetMessageId(), GetPartId(), aPartId );

		}

	}

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

// CFSMailMessagePart::GetContentClass

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

EXPORT_C const TDesC& CFSMailMessagePart::GetContentClass()

	{

    FUNC_LOG;

		return *iContentClass;

	}

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

// CFSMailMessagePart::SetContentClass

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

EXPORT_C void CFSMailMessagePart::SetContentClass( const TDesC& aContentClass )

	{

    FUNC_LOG;

	// 

	HBufC* contentClass = HBufC::New(aContentClass.Length());

	// store new mailbox name

	if(contentClass)

	{

		delete iContentClass;

		iContentClass = contentClass;

		iContentClass->Des().Copy(aContentClass);

	}

		iContentClass->ReAlloc(aContentClass.Length());

		if(iContentClass)

		{

			iContentClass->Des().Copy(aContentClass);		

		}

	}

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

// CFSMailMessagePart::ContentSize

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

EXPORT_C TUint CFSMailMessagePart::ContentSize() const

	{

    FUNC_LOG;

		return iContentSize;

	}

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

// CFSMailMessagePart::SetContentSize

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

EXPORT_C void CFSMailMessagePart::SetContentSize( TUint aContentSize )

	{

    FUNC_LOG;

		iContentSize = aContentSize;

	}

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

// CFSMailMessagePart::ContentID

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

EXPORT_C const TDesC& CFSMailMessagePart::ContentID()

	{

    FUNC_LOG;

	return *iContentID;

	}

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

// CFSMailMessagePart::SetContentIDL

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

EXPORT_C void CFSMailMessagePart::SetContentIDL(const TDesC& aContentID)

	{

    FUNC_LOG;

	// init mailbox name

	HBufC* id = HBufC::New(aContentID.Length());

	// store new mailbox name

	if(id)

	{

		delete iContentID;

		iContentID = id;

		iContentID->Des().Copy(aContentID);

	}

	}

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

// CFSMailMessagePart::CopyMessageAsChildPartL

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

EXPORT_C CFSMailMessagePart* CFSMailMessagePart::CopyMessageAsChildPartL(

													TFSMailMsgId aInsertBefore,

													CFSMailMessage* aMessage)

	{

    FUNC_LOG;

	CFSMailMessagePart* part = NULL;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId()))

	{

		part = plugin->CopyMessageAsChildPartL(GetMailBoxId(),GetFolderId(),GetMessageId(),GetPartId(),

											aInsertBefore, *aMessage);

	}

	return part;

	}

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

// CFSMailMessagePart::RemoveContentL

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

EXPORT_C void CFSMailMessagePart::RemoveContentL()

	{

    FUNC_LOG;

	CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId());

	if(plugin == NULL)

	    {

	    plugin = iRequestHandler->GetPluginByUid(GetMessageId());

	    }

	if(plugin != NULL)

		{

		RPointerArray<CFSMailMessagePart> parts;

		RArray<TFSMailMsgId> partIds;

    	plugin->ChildPartsL(GetMailBoxId(),GetFolderId(),GetMessageId(),GetPartId(),parts);

		for(TInt i=0;i<parts.Count();i++)

			{

			partIds.Append(parts[i]->GetMessageId());

			}

        partIds.Append(GetPartId());

		plugin->RemovePartContentL(GetMailBoxId(), GetFolderId(), GetMessageId(), partIds);

        parts.ResetAndDestroy();

		partIds.Reset();

		}

	}

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

// CFSMailMessagePart::RemoveDownLoadedAttachmentsL

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

EXPORT_C void CFSMailMessagePart::RemoveDownLoadedAttachmentsL()

    {

    FUNC_LOG;

    CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId());

    if(plugin == NULL)

        {

        plugin = iRequestHandler->GetPluginByUid(GetMessageId());

        }

    if(plugin != NULL)

        {

        // get attachment list

        RPointerArray<CFSMailMessagePart> attachments;

        attachments.Reset();

        DoAttachmentListL(attachments);

        // copy attachment part ids

        RArray<TFSMailMsgId> ids;

        ids.Reset();

        for(TInt i=0;i<attachments.Count();i++)

            {

            ids.Append(attachments[i]->GetPartId());

            }

        // remove attachment fetched contents 

        if(ids.Count())

            {

            TRAP_IGNORE(plugin->RemovePartContentL(GetMailBoxId(), GetFolderId(), GetMessageId(), ids));

            }

        // clean tables

        attachments.ResetAndDestroy();

        ids.Reset();

        }

    }

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

// CFSMailMessagePart::GetContentFileL

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

EXPORT_C RFile CFSMailMessagePart::GetContentFileL()

	{

    FUNC_LOG;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId()))

		{

		TInt rcode = plugin->GetMessagePartFileL( GetMailBoxId(), GetFolderId(),

					                            GetMessageId(), GetPartId(),

					                            iFile );

		// if content is encrypted, use temp dir files

		if(rcode == KErrNotSupported)

		    {

		    // temp directory C:\Private\<uid>

		    TFileName fileName;

		    iFile = iRequestHandler->GetTempFileL(GetPartId(),fileName);

		    plugin->CopyMessagePartFileL(GetMailBoxId(), GetFolderId(),

		                                 GetMessageId(), GetPartId(),

		                                 fileName);

		    }

		}

	return iFile;

	}

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

// CFSMailMessagePart::SetContentFromFileL

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

EXPORT_C void CFSMailMessagePart::SetContentFromFileL(const TDesC& aFilePath)

	{

    FUNC_LOG;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId()))

		{

		plugin->SetPartContentFromFileL(GetMailBoxId(), GetFolderId(),

			GetMessageId(), GetPartId(), aFilePath );

		}

	}

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

// CFSMailMessagePart::CopyContentFileL

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

EXPORT_C void CFSMailMessagePart::CopyContentFileL( const TDesC& aFilePath )

	{

    FUNC_LOG;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId()))

		{

		plugin->CopyMessagePartFileL( GetMailBoxId(), GetFolderId(),

			GetMessageId(), GetPartId(), aFilePath);		

		}

	}

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

// CFSMailMessagePart::GetContentToBufferL

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

EXPORT_C void CFSMailMessagePart::GetContentToBufferL(TDes16& aBuffer, TUint aStartOffset)

	{

    FUNC_LOG;

	if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetPartId()))

		{

		plugin->GetContentToBufferL( GetMailBoxId(), GetFolderId(), GetMessageId(),

									 GetPartId(), aBuffer, aStartOffset );

		}

	}

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

// CFSMailMessagePart::SetContent

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

EXPORT_C void CFSMailMessagePart::SetContent( TDes16& aBuffer )

	{