/*

* Copyright (c) 2010 Sun Microsystems, Inc. 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 Contributor:

* Maximilian Odendahl

*

* Contributors:

* 

* Description: Caldav server session, follows Symbian 

* 				client/server architecture

*/

#include <e32cmn.h>

#include "caldavserversession.h"

#include "caldavserver.h"

#include "caldavutils.h"

#define MAXLENGTH	500

CCalDavServerSession::CCalDavServerSession(CCalDavServer &aServer) :

	rServer(aServer)

	{

	}

/**

 Services a client request.

 */

void CCalDavServerSession::ServiceL(const RMessage2& aMessage)

	{

	TRAP_IGNORE(DispatchMessageL(aMessage));

	}

/**

 Called by ServiceL()

 It tests the function code and then delegates to

 the appropriate function.

 */

void CCalDavServerSession::DispatchMessageL(const RMessage2& aMessage)

	{

	switch (aMessage.Function())

		{

		case ECalDavEnable:

			EnableL(aMessage);

			return;

		case ECalDavDisable:

			DisableL(aMessage);

			return;

		case ECalDavSyncAll:

			SyncAllL(aMessage);

			return;

		case ECalDavSync:

			SyncL(aMessage);

			return;

		case ECalDavUrl:

			UrlL(aMessage);

			return;

		case ECalDavSetUrl:

			SetUrlL(aMessage);

			return;

		case ECalDavUsername:

			UsernameL(aMessage);

			return;

		case ECalDavSetUsername:

			SetUsernameL(aMessage);

			return;

		case ECalDavPassword:

			PasswordL(aMessage);

			return;

		case ECalDavSetPassword:

			SetPasswordL(aMessage);

			return;

		case ECalDavSyncInterval:

			SyncIntervalL(aMessage);

			return;

		case ECalDavSetSyncInterval:

			SetSyncIntervalL(aMessage);

			return;

		case ECalDavPastDays:

			PastDaysL(aMessage);

			return;

		case ECalDavSetPastDays:

			SetPastDaysL(aMessage);

			return;

		case ECalDavImmediateSync:

			ImmediateSyncL(aMessage);

			return;

		case ECalDavSetImmediateSync:

			SetImmediateSyncL(aMessage);

			return;

		case ECalDavKeepServer:

			KeepServerEntryL(aMessage);

			return;

		case ECalDavSetKeepServer:

			SetKeepServerEntryL(aMessage);

			return;

		case ECalDavEnabled:

			EnabledSyncL(aMessage);

			return;

		case ECalDavUnsupportedRequest:

			User::Leave(KErrNotSupported);

			//  Requests that we don't understand at all are a different matter.

			//  This is considered a client programming error, so we panic the 

			//  client - this also completes the message.

		default:

			PanicClient(aMessage, EBadRequest);

			return;

		}

	}

/**

 Panics the client

 */

void CCalDavServerSession::PanicClient(const RMessage2& aMessage, TInt aPanic) const

	{

	_LIT(KTxtServer,"CalDav server");

	aMessage.Panic(KTxtServer, aPanic);

	}

void CCalDavServerSession::EnableL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TInt result = rServer.EnableL(*calendar);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(result);

	}

void CCalDavServerSession::DisableL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TInt result = rServer.DisableL(*calendar);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(result);

	}

void CCalDavServerSession::SyncL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TInt result = rServer.SyncL(*calendar);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(result);

	}

void CCalDavServerSession::SyncAllL(const RMessage2& aMessage)

	{

	TInt result = rServer.SyncAllL();

	aMessage.Complete(result);

	}

void CCalDavServerSession::UrlL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	aMessage.WriteL(1, rServer.UrlL(*calendar));

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SetUrlL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	length = aMessage.GetDesLength(1);

	HBufC8* url = HBufC8::NewLC(length);

	TPtr8 urlPtr(url->Des());

	aMessage.ReadL(1, urlPtr);

	rServer.SetUrlL(*calendar, *url);

	CleanupStack::PopAndDestroy(url);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::UsernameL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	aMessage.WriteL(1, rServer.UsernameL(*calendar));

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SetUsernameL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	length = aMessage.GetDesLength(1);

	HBufC8* username = HBufC8::NewLC(length);

	TPtr8 usernamePtr(username->Des());

	aMessage.ReadL(1, usernamePtr);

	rServer.SetUsernameL(*calendar, *username);

	CleanupStack::PopAndDestroy(username);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::PasswordL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	aMessage.WriteL(1, rServer.PasswordL(*calendar));

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SetPasswordL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	length = aMessage.GetDesLength(1);

	HBufC8* password = HBufC8::NewLC(length);

	TPtr8 passwordPtr(password->Des());

	aMessage.ReadL(1, passwordPtr);

	rServer.SetPasswordL(*calendar, *password);

	CleanupStack::PopAndDestroy(password);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SyncIntervalL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TTimeIntervalMinutes interval = rServer.SyncIntervalL(*calendar);

	TPckg<TTimeIntervalMinutes> intervalDes(interval);

	aMessage.WriteL(1, intervalDes);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SetSyncIntervalL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TTimeIntervalMinutes interval;

	;

	TPckg<TTimeIntervalMinutes> intervalDes(interval);

	aMessage.ReadL(1, intervalDes);

	rServer.SetSyncIntervalL(*calendar, interval);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::PastDaysL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TTimeIntervalDays days = rServer.PastDaysL(*calendar);

	TPckg<TTimeIntervalDays> daysDes(days);

	aMessage.WriteL(1, daysDes);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SetPastDaysL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TTimeIntervalDays days;

	TPckg<TTimeIntervalDays> daysDes(days);

	aMessage.ReadL(1, daysDes);

	rServer.SetPastDaysL(*calendar, days);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::ImmediateSyncL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TBool immediate = rServer.ImmediateSyncL(*calendar);

	TPckg<TBool> immediateDes(immediate);

	aMessage.WriteL(1, immediateDes);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SetImmediateSyncL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TBool immediate;

	TPckg<TBool> immediateDes(immediate);

	aMessage.ReadL(1, immediateDes);

	rServer.SetImmediateSyncL(*calendar, immediate);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::KeepServerEntryL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TBool keepserver = rServer.ImmediateSyncL(*calendar);

	TPckg<TBool> keepserverDes(keepserver);

	aMessage.WriteL(1, keepserverDes);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::EnabledSyncL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TBool enabledsync = rServer.EnabledSyncL(*calendar);

	TPckg<TBool> enabledsyncDes(enabledsync);

	aMessage.WriteL(1, enabledsyncDes);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}

void CCalDavServerSession::SetKeepServerEntryL(const RMessage2& aMessage)

	{

	TUint length = aMessage.GetDesLength(0);

	HBufC* calendar = HBufC::NewLC(length);

	TPtr calendarPtr(calendar->Des());

	aMessage.ReadL(0, calendarPtr);

	TBool keepserver;

	TPckg<TBool> keepserverDes(keepserver);

	aMessage.ReadL(1, keepserverDes);

	rServer.SetImmediateSyncL(*calendar, keepserver);

	CleanupStack::PopAndDestroy(calendar);

	aMessage.Complete(KErrNone);

	}