/*

* Copyright (c) 2002 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:  Job history entry

*

*/

#include <SyncMLHistory.h>

#include <SyncMLAlertInfo.h>

#include <SyncMLErr.h> // sync error codes

#include <nsmlconstants.h>

#include "NSmlErrorCodeConversion.h"

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

// CSyncMLHistoryJob::TTaskInfo::TTaskInfo()

// Constructor

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

EXPORT_C CSyncMLHistoryJob::TTaskInfo::TTaskInfo() :

	iTaskId( KErrNotFound ),

	iError( KErrNone ),

	iItemsAdded( 0 ),

	iItemsChanged( 0 ),

	iItemsDeleted( 0 ),

	iItemsMoved( 0 ),

	iItemsFailed( 0 ),

	iServerItemsAdded( 0 ),

	iServerItemsChanged( 0 ),

	iServerItemsDeleted( 0 ),

	iServerItemsMoved( 0 ),

	iServerItemsFailed( 0 ),

	iSyncType( ESmlTwoWay )

	{

	}

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

// CSyncMLHistoryJob::TTaskInfo::TTaskInfo::InternalizeL(RReadStream& aStream)

// Reads task info from given stream

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

EXPORT_C void CSyncMLHistoryJob::TTaskInfo::TTaskInfo::InternalizeL(RReadStream& aStream)

	{

	iTaskId = (TSmlTaskId) aStream.ReadInt32L();

	iError = aStream.ReadInt32L();

	iItemsAdded = aStream.ReadInt32L();

	iItemsChanged = aStream.ReadInt32L();

	iItemsDeleted = aStream.ReadInt32L();

	iItemsMoved = aStream.ReadInt32L();

	iItemsFailed = aStream.ReadInt32L();

	iServerItemsAdded = aStream.ReadInt32L();

	iServerItemsChanged = aStream.ReadInt32L();

	iServerItemsDeleted = aStream.ReadInt32L();

	iServerItemsMoved = aStream.ReadInt32L();

	iServerItemsFailed = aStream.ReadInt32L();

	iSyncType = (TSmlSyncType) aStream.ReadInt32L();

	}

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

// CSyncMLHistoryJob::TTaskInfo::TTaskInfo::ExternalizeL(RWriteStream& aStream) const

// Writes task info to given stream

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

EXPORT_C void CSyncMLHistoryJob::TTaskInfo::TTaskInfo::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteInt32L((TInt) iTaskId);

	aStream.WriteInt32L(iError);

	aStream.WriteInt32L(iItemsAdded);

	aStream.WriteInt32L(iItemsChanged);

	aStream.WriteInt32L(iItemsDeleted);

	aStream.WriteInt32L(iItemsMoved);

	aStream.WriteInt32L(iItemsFailed);

	aStream.WriteInt32L(iServerItemsAdded);

	aStream.WriteInt32L(iServerItemsChanged);

	aStream.WriteInt32L(iServerItemsDeleted);

	aStream.WriteInt32L(iServerItemsMoved);

	aStream.WriteInt32L(iServerItemsFailed);

	aStream.WriteInt32L( (TInt) iSyncType);

	}

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

// CSyncMLHistoryJob::NewL()

// Two phase constructor

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

EXPORT_C CSyncMLHistoryJob* CSyncMLHistoryJob::NewL()

	{

	return new (ELeave) CSyncMLHistoryJob;

	}

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

// CSyncMLHistoryJob::NewL(TSmlProfileId aProfileId, const RArray<TSmlTaskId>& aTasks)

// Two phase constructor

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

EXPORT_C CSyncMLHistoryJob* CSyncMLHistoryJob::NewL(TSmlProfileId aProfileId, const RArray<TSmlTaskId>& aTasks)

	{

	CSyncMLHistoryJob * self = new (ELeave) CSyncMLHistoryJob;

	CleanupStack::PushL(self);

	self->ConstructL(aProfileId, aTasks);

	CleanupStack::Pop(); // self

	return self;

	}

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

// CSyncMLHistoryJob::~CSyncMLHistoryJob()

// Destructor

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

EXPORT_C CSyncMLHistoryJob::~CSyncMLHistoryJob()

	{

	iTaskInfo.Reset();

	iTaskInfo.Close();

	}

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

// CSyncMLHistoryJob::ExternalizeL(RWriteStream& aStream) const

// Writes entry to given stream

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

EXPORT_C void CSyncMLHistoryJob::ExternalizeL(RWriteStream& aStream) const

	{

	CSyncMLHistoryEntry::ExternalizeL(aStream);

	TPckgBuf<TTime> start(iStartTime);

	aStream << start;

	TPckgBuf<TTime> end(iFinishTime);

	aStream << end;

	TPckgBuf<TTime> lastsync(iLastSuccessSync);

	aStream << lastsync;

	aStream.WriteInt32L(iResultCode);

	aStream.WriteInt32L(iProfileId);

	TInt count = iTaskInfo.Count();

	aStream.WriteInt32L( count );

	for (TInt i = 0; i < count; i++)

		{

		iTaskInfo[i].ExternalizeL(aStream);

		}

	}

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

// CSyncMLHistoryJob::Profile() const

// Returns profile id

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

EXPORT_C TSmlProfileId CSyncMLHistoryJob::Profile() const

	{

	return iProfileId;

	}

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

// CSyncMLHistoryJob::TimeStamp() const

// Returns entry creation time

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

EXPORT_C TTime CSyncMLHistoryJob::TimeStamp() const

	{

	return iStartTime;

	}

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

// CSyncMLHistoryJob::LastSuccessSyncTime() const

// Returns the set Last Success Synchronization time

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

EXPORT_C TTime CSyncMLHistoryJob::LastSuccessSyncTime() const 

	{

	return iLastSuccessSync;

	}

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

// CSyncMLHistoryJob::ResultCode() const

// Returns the set result code

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

EXPORT_C TInt CSyncMLHistoryJob::ResultCode() const

	{

	return iResultCode;

	}

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

// CSyncMLHistoryJob::FinishTime() const

// Returns the job's finish time

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

EXPORT_C TTime CSyncMLHistoryJob::FinishTime() const

	{

	return iFinishTime;

	}

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

// CSyncMLHistoryJob::TaskCount() const

// Returns the job's task count

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

EXPORT_C TInt CSyncMLHistoryJob::TaskCount() const

	{

	return iTaskInfo.Count();

	}

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

// CSyncMLHistoryJob::TaskAt(TInt aIndex) const

// Returns the task into from specified index

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

EXPORT_C const CSyncMLHistoryJob::TTaskInfo& CSyncMLHistoryJob::TaskAt(TInt aIndex) const

	{

	return iTaskInfo[aIndex];

	}

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

// CSyncMLHistoryJob::TaskById(TSmlTaskId aTaskId)

// Returns the task into from specified task

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

EXPORT_C CSyncMLHistoryJob::TTaskInfo& CSyncMLHistoryJob::TaskById(TSmlTaskId aTaskId)

	{

	TInt count = iTaskInfo.Count();

	TInt i(0);

	for (i = 0; i < count; i++)

		{

		if (aTaskId == iTaskInfo[i].iTaskId)

			{

			break;

			}

		}

	return iTaskInfo[i];

	}

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

// CSyncMLHistoryJob::SetResult(TTime aFinishTime, TInt aResultCode)

// Sets the finish time and result code

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

EXPORT_C void CSyncMLHistoryJob::SetResult(TTime aFinishTime, TInt aResultCode)

	{

	iFinishTime = aFinishTime;

	iResultCode = aResultCode;

	}

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

// CSyncMLHistoryJob::SetLastSyncResult(TTime aSuccessSyncTime )

// Sets the Successful synchronization finish time

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

	EXPORT_C  void CSyncMLHistoryJob::SetLastSyncResult(TTime aSuccessSyncTime )

	{

	iLastSuccessSync=aSuccessSyncTime;

	}

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

// CSyncMLHistoryJob::ConstructL(TSmlProfileId aProfileId, const RArray<TSmlTaskId>& aTasks)

// Second phase constructor

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

void CSyncMLHistoryJob::ConstructL(TSmlProfileId aProfileId, const RArray<TSmlTaskId>& aTasks)

	{

	iProfileId = aProfileId;

	TInt count( aTasks.Count() );

	for (TInt i = 0; i < count; i++)

		{

		TInt taskId = aTasks[i];

		TTaskInfo info;

		info.iTaskId = taskId;

		iTaskInfo.AppendL( info );

		}

	}

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

// CSyncMLHistoryJob::InternalizeL(RReadStream& aStream)

// Reads job entry from given stream

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

void CSyncMLHistoryJob::InternalizeL(RReadStream& aStream)

	{

	CSyncMLHistoryEntry::InternalizeL(aStream);

	TPckgBuf<TTime> start(iStartTime);

	aStream >> start;

	iStartTime = start().Int64();

	TPckgBuf<TTime> end(iFinishTime);

	aStream >> end;

	iFinishTime = end().Int64();

	TPckgBuf<TTime> lastsync(iLastSuccessSync);

	aStream >> lastsync;

	iLastSuccessSync = lastsync().Int64();

	iResultCode = aStream.ReadInt32L();

	// Added for syncml engine error handling and displaying in view logs

	TInt32 error = iResultCode ;

	TNSmlErrorConversion errorconv( error );

	error = errorconv.Convert();

	if (error <= SyncMLError::KErrSyncEngineErrorBase)

		{

		iResultCode = error ;

		}

	iProfileId = aStream.ReadInt32L();

	TInt count = aStream.ReadInt32L();

	for (TInt i = 0; i < count; i++)

		{

		TTaskInfo info;

		info.InternalizeL(aStream);

		iTaskInfo.AppendL(info);

		}

	}

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

// CSyncMLHistoryJob::	CSyncMLHistoryJob()

// Constructor

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

CSyncMLHistoryJob::	CSyncMLHistoryJob()

: CSyncMLHistoryEntry(KUidSmlHistoryEntryJob) , iResultCode(0), iProfileId( KNSmlNullId )

	{

	iStartTime.UniversalTime();

	}

//End of File