/*
* Copyright (c) 2008 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:  Class that directly interacts with Sqlite database.
*
*/


// System Includes
#include <s32strm.h>

// User Includes
#include "evtdatabase.h"
#include "evtdbnotifier.h"
#include "evtaction.h"
#include "evtconsts.h"
#include "evtdebug.h"

// Constant
const TInt KBufferLength = 512;
const TInt KMaxIntLength = 22;

// ================ Member funtions for CEvtDatabase class ==================

// ---------------------------------------------------------------------------
// CEvtDatabase::CEvtDatabase
// ---------------------------------------------------------------------------
//
CEvtDatabase::CEvtDatabase( )
    {
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::~CEvtDatabase
// ---------------------------------------------------------------------------
//
CEvtDatabase::~CEvtDatabase()
    {
    // Close Database handle
    CloseDatabase();
    
    delete iDbNotifier;
    } 
    
// ---------------------------------------------------------------------------
// CEvtDatabase::NewL
// ---------------------------------------------------------------------------
//
CEvtDatabase* CEvtDatabase::NewL( )
    {
	CEvtDatabase* self = NewLC( );
	CleanupStack::Pop( self );
	return self;
    }

// ---------------------------------------------------------------------------
// CEvtDatabase::NewLC
// ---------------------------------------------------------------------------
//
CEvtDatabase* CEvtDatabase::NewLC( )
    {
	CEvtDatabase* self = new ( ELeave )CEvtDatabase( );
	CleanupStack::PushL( self );
	self->ConstructL( );
	return self;
    } 

// ---------------------------------------------------------------------------
// CEvtDatabase::ConstructL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::ConstructL()
    {
	EVTUIDEBUG( "+ CEvtDatabase::OpenDatabaseL()" );
	EVTUIDEBUG( "Calling OpenDatabaseL()" );
    // Open the handle to Database
    OpenDatabaseL( );
    
	EVTUIDEBUG( "Calling CEvtDbNotifier::NewL()" );
    // Notifier is instantiated to notify and listen to database change.
    iDbNotifier = CEvtDbNotifier::NewL( *this );
	EVTUIDEBUG( "+ CEvtDatabase::OpenDatabaseL()" );
    } 

// ---------------------------------------------------------------------------
// CEvtDatabase::CreateOpenDatabaseL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::OpenDatabaseL( )
	{
	EVTUIDEBUG( "+ CEvtDatabase::OpenDatabaseL()" );
  	
  	// First try to open the database.
	TInt err = iDb.Open( KEventsDbSecureFName() );
	
	// If the database is not present, then a database and schema has to be
  	// created
	if( KErrNotFound == err )
		{
		CreateOpenDatabaseL( );		// Create Database
		CreateSchemaL( );			// Create Schema
		}
	else if( KErrNone != err )
		User::LeaveIfError( err );	// Leave if Open fails for any other reason
	EVTUIDEBUG( "- CEvtDatabase::OpenDatabaseL()" );
	}

// ---------------------------------------------------------------------------
// CEvtDatabase::CloseDatabaseL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::CloseDatabase()
	{
	EVTUIDEBUG( "+ CEvtDatabase::CloseDatabase()" );
	// Close db handle
	iDb.Close();
	EVTUIDEBUG( "- CEvtDatabase::CloseDatabase()" );
	}

// ---------------------------------------------------------------------------
// CEvtDatabase::CreateDatabaseL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::CreateOpenDatabaseL( )
	{
	EVTUIDEBUG( "+ CEvtDatabase::CreateOpenDatabaseL()" );

	// To create a Secure Database, we first need to create the Security policy.
	// Security policy once defined for a database, can not be changed.
	TSecurityPolicy defaultPolicy( TSecurityPolicy::EAlwaysPass );
	RSqlSecurityPolicy securityPolicy;
	TInt err = securityPolicy.Create( defaultPolicy );
	User::LeaveIfError( err );

    // Define Security Policy
    const TSecurityPolicy KSchemaPolicy( ECapabilityLocation );
    const TSecurityPolicy KReadWritePolicy( ECapabilityLocation );

	// Set the security Policy for Schema and tables
	securityPolicy.SetDbPolicy( RSqlSecurityPolicy::ESchemaPolicy, 
															KSchemaPolicy );
	securityPolicy.SetDbPolicy( RSqlSecurityPolicy::EReadPolicy, 
															KReadWritePolicy );
	securityPolicy.SetDbPolicy( RSqlSecurityPolicy::EWritePolicy, 
															KReadWritePolicy );
	
	// CreateL will create and open the handle to database.
	iDb.CreateL( KEventsDbSecureFName(), securityPolicy );
	
	// Close the Security Policy
	securityPolicy.Close();
	
	EVTUIDEBUG( "- CEvtDatabase::CreateOpenDatabaseL()" );
	}

// ---------------------------------------------------------------------------
// CEvtDatabase::CreateSchemaL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::CreateSchemaL()
	{
	EVTUIDEBUG( "+ CEvtDatabase::CreateSchemaL()" );
	// Create Tables in database
	CreateTablesL();
	// Create Triggers in database
	CreateTriggerL();
	// Create Indexes in database
	CreateIndexL();
	EVTUIDEBUG( "- CEvtDatabase::CreateSchemaL()" );
	}

// ---------------------------------------------------------------------------
// CEvtDatabase::CreateTablesL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::CreateTablesL()
	{
	EVTUIDEBUG( "+ CEvtDatabase::CreateTablesL()" );
	
	// Leave if the creation of tables fail.
	User::LeaveIfError( 
			iDb.Exec( KCreateEventTable ) );
	User::LeaveIfError( 
			iDb.Exec( KCreateActionTable ) );
	EVTUIDEBUG( "- CEvtDatabase::CreateTablesL()" );
	}
	
// ---------------------------------------------------------------------------
// CEvtDatabase::CreateTriggerL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::CreateTriggerL()
	{
	EVTUIDEBUG( "+ CEvtDatabase::CreateTriggerL()" );
	// Triggers are used to maintain the referential integrity between
	// Event and Action tables.
	// This avoids Insert, Update and Delete anamolies.
	 
	// Leave if the creation of triggers fail.
	User::LeaveIfError( 
			iDb.Exec( KCreateTriggerActionEventInsert ) );
	User::LeaveIfError( 
			iDb.Exec( KCreateTriggerActionEventUpdate ) );
	User::LeaveIfError( 
			iDb.Exec( KCreateTriggerActionEventDelete ) );
				
	EVTUIDEBUG( "- CEvtDatabase::CreateTriggerL()" );
	}

// ---------------------------------------------------------------------------
// CEvtDatabase::CreateIndexL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::CreateIndexL()
	{
	EVTUIDEBUG( "+ CEvtDatabase::CreateIndexL()" );
    // Indexes are created to improve the performance of select Queries
    // Following indexes are created
    // 1. Index to "Select Event based on Status and Sort by Subject"
    // 2. Index to "Select Event based on Unique Event Id"
    // 3. Index to "Select Event based on Event Id" - (LBT Engine's Id)
    // 4. Index to "Select Action based on Unique Event Id"
	 
	// Leave if the creation of indexes fail.
	User::LeaveIfError( 
			iDb.Exec( KCreateEventStatusSubjectIndex ) );
	User::LeaveIfError( 
			iDb.Exec( KCreateEventEvtIdIndex ) );
	User::LeaveIfError( 
			iDb.Exec( KCreateActionEvtIdIndex ) );
			
	EVTUIDEBUG( "- CEvtDatabase::CreateIndexL()" );
	}

// ---------------------------------------------------------------------------
// CEvtDatabase::GetEventsL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::GetEventsL( 
                            TEvtEventStatus    aEventStatus,
                            RPointerArray<CEvtBasicEventInfo>&     aEventArray )
    {
	EVTUIDEBUG( "+ CEvtDatabase::GetEventsL() - Status" );
    RSqlStatement stmt;
    
    // Prepare the SQL statement to Get Events based on Status
	stmt.Prepare( iDb, KSelectBasicEventOnStatus );
	
	// Set the Status parameter in SQL statement
	TInt paramIndex = stmt.ParameterIndex( KStatus );
	stmt.BindInt( paramIndex,aEventStatus );
	
	// Pass the SQL statement to get events.
    GetEventsL( stmt, aEventArray );
	
	// Close statement
	stmt.Close();
	EVTUIDEBUG( "- CEvtDatabase::GetEventsL() - Status" );
    }

// ---------------------------------------------------------------------------
// CEvtDatabase::GetEventsL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::GetEventsL( 
                            RPointerArray<CEvtBasicEventInfo>&     aEventArray )
    {
	EVTUIDEBUG( "+ CEvtDatabase::GetEventsL() - without Status" );
    RSqlStatement stmt;
    
    // Prepare the SQL statement to Get Events based on Status
	stmt.Prepare( iDb, KSelectBasicEvent );
	
	// Pass the SQL statement to get events.
    GetEventsL( stmt, aEventArray );
	
	// Close statement
	stmt.Close();
	EVTUIDEBUG( "- CEvtDatabase::GetEventsL() - without Status" );
    } 
    
// ---------------------------------------------------------------------------
// CEvtDatabase::GetEventL
// ---------------------------------------------------------------------------
//
CEvtEvent* CEvtDatabase::GetEventL( TEvtEventId      aEventId )
    {
	EVTUIDEBUG( "+ CEvtDatabase::GetEventL()" );

	RSqlStatement stmt;
	CEvtEvent* evt = NULL;
	
	// Prepare the SQL statement to Get Events based on Id
	stmt.Prepare( iDb, KSelectEventFromEventId );
	
	// Set the Id parameter in SQL statement
	TInt paramIndex=stmt.ParameterIndex( KEventId );
	stmt.BindInt( paramIndex, aEventId );
	
	// Constants representing the columns in Query
	TInt columnIndexStatus=0; 
	TInt columnIndexSubject=1; 
	TInt columnIndexPlace=2; 
	TInt columnIndexRadius=3; 
	TInt columnIndexDescription=4; 
	TInt columnIndexRepeat=5; 
	TInt columnIndexActionId=6;
	TInt columnIndexAction=7;  
	TInt columnIndexActionEvtId=8; 

    // Flag to loop out after the first element is found in database
    // This is not required as we maintain unique Id for every event.
    // But to ensure that we do not allocate many events object to evt,
    // this flag is defined.
    TBool flag( ETrue );

	// Set the other attributes of the Requested Event
	while( flag && stmt.Next() == KSqlAtRow )
		{
		flag = EFalse;
        evt = CEvtEvent::NewLC();

    	// Set the Id of the Requested Event
    	evt->SetEventId(aEventId);

		TInt value = stmt.ColumnInt( columnIndexStatus );
		evt->SetEventStatus( static_cast<TEvtEventStatus>(value) );
		
		TPtrC subject=stmt.ColumnTextL( columnIndexSubject );
		evt->SetSubjectL(subject);
		
		TPtrC place=stmt.ColumnTextL( columnIndexPlace );
		evt->SetPlaceL(place);
    
		TReal realvalue = stmt.ColumnReal( columnIndexRadius );
        evt->SetRadius( realvalue );
		
		TPtrC desc=stmt.ColumnTextL( columnIndexDescription );
		evt->SetDescriptionL(desc);
        
		value = stmt.ColumnInt( columnIndexRepeat );
        evt->SetRepeat(value);
        
		TInt64 value64 = stmt.ColumnInt64( columnIndexActionId );
		if( value64 != 0 )
			{			
    		// Create action instance to set for Event
    		// ownership is not passed.
    		CEvtAction* actn = CEvtAction::NewLC();
			
			// Set the Unique Id for Action
			actn->SetId( value64 );
			
			// Set Action to an Event only if there is an Action String.
			TPtrC action = stmt.ColumnTextL( columnIndexAction );
	    	actn->SetActionL( action );
    		
    		// Set the Event Id
			TUint32 value32 = stmt.ColumnInt( columnIndexActionEvtId );
	    	actn->SetEvtId( value32 );
        
        	// Set the Action to Event
	    	evt->SetActionL( actn );
	    	
    		// Pop action after setting.
    		CleanupStack::Pop( actn );
			}
		
		// Pop the Event object
		CleanupStack::Pop( evt );
		}
	stmt.Close();
	
	if( flag )
        User::Leave( KErrNotFound );	
        
	EVTUIDEBUG( "- CEvtDatabase::GetEventL()" );
	return evt;
    } 
    
// ---------------------------------------------------------------------------
// CEvtDatabase::UpdateEvent
// ---------------------------------------------------------------------------
//
void CEvtDatabase::UpdateEventL( 
                            CEvtEvent&          aEvtEvent )
    {
	EVTUIDEBUG( "+ CEvtDatabase::UpdateEventL()" );
	
	// Update Event's Attributes.
    UpdateEventTableL( aEvtEvent );
	
	if( aEvtEvent.HasAction() )
		{
		aEvtEvent.Action().SetEvtId( aEvtEvent.EventId() );
		if( CheckIfActionPresentL( aEvtEvent.Action().Id() ) )
			UpdateActionL( aEvtEvent.Action() );
		else
			CreateActionL( aEvtEvent.Action() );
		}
	else
		{
			DeleteActionL( aEvtEvent.EventId() );
		}
		
	// Notify the database change for Modify
	iDbNotifier->DbChangedL( );
	EVTUIDEBUG( "- CEvtDatabase::UpdateEventL()" );
    } 
    
// ---------------------------------------------------------------------------
// CEvtDatabase::AddEventL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::AddEventL( CEvtEvent&     aEvtEvent )
    {
	EVTUIDEBUG( "+ CEvtDatabase::AddEventL()" );
    
	RSqlStatement stmt;
	TInt paramIndex;
	
	// We need to create the streams to insert large texts.
	RSqlParamWriteStream subjectStream;
	RSqlParamWriteStream placeStream;
	RSqlParamWriteStream descStream;
	CleanupClosePushL( subjectStream );
	CleanupClosePushL( placeStream );
	CleanupClosePushL( descStream );
	
	// Prepare the SQL statement to Get Events based on Status
	stmt.Prepare( iDb, KInsertEvent );
	
	// Set Status
	paramIndex = stmt.ParameterIndex( KStatus );
	stmt.BindInt( paramIndex, aEvtEvent.EventStatus() );
	
	// Set Subject
	paramIndex = stmt.ParameterIndex( KSubject );
	if( KNullDesC() == aEvtEvent.Subject() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		subjectStream.BindText( stmt, paramIndex );
		subjectStream.WriteL( aEvtEvent.Subject() );
		subjectStream.CommitL();
		}
	
	// Set Place
	paramIndex = stmt.ParameterIndex( KPlace );
	if( KNullDesC() == aEvtEvent.Place() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		placeStream.BindText( stmt, paramIndex );
		placeStream.WriteL( aEvtEvent.Place() );
		placeStream.CommitL();
		}
	
	// Set Radius
	paramIndex = stmt.ParameterIndex( KRadius );
	stmt.BindReal( paramIndex, aEvtEvent.Radius() );
	
	// Set Description
	paramIndex = stmt.ParameterIndex( KDescription );
	if( KNullDesC() == aEvtEvent.Description() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		descStream.BindText( stmt, paramIndex );
		descStream.WriteL( aEvtEvent.Description() );
		descStream.CommitL();
		}
	
	// Set Repeat
	paramIndex = stmt.ParameterIndex( KRepeat );
	stmt.BindInt( paramIndex, aEvtEvent.Repeat() );
    
    // Set Event Id
	paramIndex = stmt.ParameterIndex( KEventId );
	stmt.BindInt( paramIndex, aEvtEvent.EventId() );
	
	// Execute the Remove SQL statement
	User::LeaveIfError( stmt.Exec() );
	
	//Close the streams
	CleanupStack::PopAndDestroy( &descStream );
	CleanupStack::PopAndDestroy( &placeStream );
	CleanupStack::PopAndDestroy( &subjectStream );
	    
	stmt.Close();
    
	// Insert into Action table If action is present for the event.  
	if( aEvtEvent.HasAction() )
		{
		aEvtEvent.Action().SetEvtId( aEvtEvent.EventId() );
			CreateActionL( aEvtEvent.Action() );
		}
        
	// Notify the database change for Insert
	iDbNotifier->DbChangedL( );
	EVTUIDEBUG( "- CEvtDatabase::AddEventL()" );
    }  
 
// ---------------------------------------------------------------------------
// CEvtDatabase::RemoveEventsL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::RemoveEventsL( const RArray<TEvtEventId>&     aEventArray )
    {
	EVTUIDEBUG( "+ CEvtDatabase::RemoveEventsL()" ); 
    // Removing an Event in database should be done in an order of
    // - remove Action entry and then remove Event entry
    
    // Leave if there are no array elements
    if( aEventArray.Count() == 0 )
        User::Leave( KErrArgument );
    
    RSqlStatement stmt;
    
    HBufC8* buf = HBufC8::NewLC(KBufferLength);
    
    buf->Des().Zero();
    TInt tempLength = KOr().Length()+KMultiActionId().Length()+KMaxIntLength;

    for(TInt i=0; i<aEventArray.Count(); i++ )
        {
        if(buf->Length() == 0)
            {
            buf->Des().Zero();
            buf->Des().Append(KDeleteMultiAction());
            buf->Des().Append(KMultiActionId());
            buf->Des().AppendNum(aEventArray[i]);
            }
        else
            {
            buf->Des().Append(KOr());
            buf->Des().Append(KMultiActionId());
            buf->Des().AppendNum(aEventArray[i]);
            }

        if( i == aEventArray.Count()-1 || KBufferLength - buf->Length() < tempLength )
            {
            // Prepare the SQL statement to Update Status based on Id
            stmt.Prepare( iDb, *buf );
            
            // Execute the Remove SQL statement
            User::LeaveIfError( stmt.Exec() );
            buf->Des().Zero();
            
            // Close the Connection
            stmt.Close();
            }
        }
    
    buf->Des().Zero();
    tempLength = KOr().Length()+KMultiEventId().Length()+KMaxIntLength;

    for(TInt i=0; i<aEventArray.Count(); i++ )
        {
        if(buf->Length() == 0)
            {
            buf->Des().Zero();
            buf->Des().Append(KDeleteMultiEvent());
            buf->Des().Append(KMultiEventId());
            buf->Des().AppendNum(aEventArray[i]);
            }
        else
            {
            buf->Des().Append(KOr());
            buf->Des().Append(KMultiEventId());
            buf->Des().AppendNum(aEventArray[i]);
            }

        if( i == aEventArray.Count()-1 || KBufferLength - buf->Length() < tempLength )
            {
            // Prepare the SQL statement to Update Status based on Id
            stmt.Prepare( iDb, *buf );
            
            // Execute the Remove SQL statement
            User::LeaveIfError( stmt.Exec() );
            buf->Des().Zero();
            
            // Close the Connection
            stmt.Close();
            }
        }
    
    CleanupStack::PopAndDestroy( buf ); //buf
	        	
	// Notify the database change for Delete
	iDbNotifier->DbChangedL( );
	EVTUIDEBUG( "- CEvtDatabase::RemoveEventsL()" ); 
    }       
 
// ---------------------------------------------------------------------------
// CEvtDatabase::UpdateEventsStatusL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::UpdateEventsStatusL( const RArray<TEvtEventId>& aEventArray,  TEvtEventStatus  aEvtStatus )
    {
    EVTUIDEBUG( "Sync UpdateEventsStatusL"); 
    
    // Leave if there are no array elements
    if( aEventArray.Count() == 0 )
        User::Leave( KErrArgument );
    
    RSqlStatement stmt;
    
    HBufC8* buf = HBufC8::NewLC(KBufferLength);
    buf->Des().Zero();
    TInt tempLength = KOr().Length()+KMultiEventId().Length()+KMaxIntLength;

    for(TInt i=0; i<aEventArray.Count(); i++ )
        {
        if(buf->Length() == 0)
            {
            buf->Des().Zero();
            buf->Des().Append(KUpdateMultiStatus());
            buf->Des().AppendNum(aEvtStatus);
            buf->Des().Append(KWhere());
            buf->Des().Append(KMultiEventId());
            buf->Des().AppendNum(aEventArray[i]);
            }
        else
            {
            buf->Des().Append(KOr());
            buf->Des().Append(KMultiEventId());
            buf->Des().AppendNum(aEventArray[i]);
            }

        if( i == aEventArray.Count()-1 || KBufferLength - buf->Length() < tempLength )
            {
            // Prepare the SQL statement to Update Status based on Id
            stmt.Prepare( iDb, *buf );
            
            // Execute the Remove SQL statement
            User::LeaveIfError( stmt.Exec() );
            buf->Des().Zero();
            
            // Close the Connection
            stmt.Close();
            }
        }

    CleanupStack::PopAndDestroy( buf ); //buf
                
    // Notify the database change for Delete
    iDbNotifier->DbChangedL( );
    }     
 
// ---------------------------------------------------------------------------
// CEvtDatabase::UpdateEventStatusL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::UpdateEventStatusL( 
                            TEvtEventId      aEvtId,
                            TEvtEventStatus    aEvtStatus)
    {
	EVTUIDEBUG( "+ CEvtDatabase::UpdateEventStatusL()" ); 
	RSqlStatement stmt;
	TInt paramIndex;
	
	// Prepare the SQL statement for Status updation
	stmt.Prepare( iDb, KUpdateEventStatus );
	
	// Set the Status parameter in SQL statement
	paramIndex=stmt.ParameterIndex( KStatus );
	stmt.BindInt( paramIndex, aEvtStatus );
	
	// Set the Id parameter in SQL statement
	paramIndex=stmt.ParameterIndex( KEventId );
	stmt.BindInt64( paramIndex, aEvtId );
	
	// Execute the Update SQL statement
	User::LeaveIfError( stmt.Exec() );
	
	stmt.Close();
	
	// Notify the database change for Modify
	iDbNotifier->DbChangedL( );
	EVTUIDEBUG( "- CEvtDatabase::UpdateEventStatusL()" ); 
    } 
         
// ---------------------------------------------------------------------------
// CEvtDatabase::RemoveEventL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::RemoveEventL( TEvtEventId      aEventId )
    {
	EVTUIDEBUG( "+ CEvtDatabase::RemoveEventL()" ); 
    
    // To maintain the Referential Integrity, we have to first delete
    // Action and then Event
	DeleteActionL( aEventId );
	DeleteEventL( aEventId );
	
	// Notify the database change for Delete
	iDbNotifier->DbChangedL( );
	EVTUIDEBUG( "- CEvtDatabase::RemoveEventL()" ); 
	} 
	
// ---------------------------------------------------------------------------
// CEvtDatabase::GetEventsL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::GetEventsL( 
                            RSqlStatement&      aStmt,
                            RPointerArray<CEvtBasicEventInfo>&     aEventArray )
    {
	EVTUIDEBUG( "+ CEvtDatabase::GetEventsL() - Generic" ); 
    
	TInt columnIndexEventId=0; 
	TInt columnIndexStatus=1; 
	TInt columnIndexSubject=2; 
	TInt columnIndexPlace=3;  
	TInt columnIndexRepeat=4; 
	/*
	Note that the column can be looked up if necessary
	although this is more expensive
	TInt columnIndex=aStmt.ColumnIndex("location");
	*/
	
	// Keep the count of the number of Events object that are pushed on to
	// Cleanup Stack. So that those many objects can be popped up later.
	TInt count=0;
	
	while( aStmt.Next() == KSqlAtRow )
		{
        count++;
		CEvtBasicEventInfo* evt = CEvtBasicEventInfo::NewLC();
		
        TUint32 value32 = aStmt.ColumnInt( columnIndexEventId );
		evt->SetEventId( value32 );

		TInt value = aStmt.ColumnInt( columnIndexStatus );
		evt->SetEventStatus( static_cast<TEvtEventStatus>( value ) );
		
		TPtrC subject=aStmt.ColumnTextL( columnIndexSubject );
		evt->SetSubjectL( subject );
		
		TPtrC place=aStmt.ColumnTextL( columnIndexPlace );
		evt->SetPlaceL( place );
        
		value = aStmt.ColumnInt( columnIndexRepeat );
		evt->SetRepeat(value);
		        
        aEventArray.Append( evt );
		}
	
	// count number of objects from Cleanup stack
    CleanupStack::Pop( count );
	EVTUIDEBUG( "- CEvtDatabase::GetEventsL() - Generic" ); 
    } 
    
// ---------------------------------------------------------------------------
// CEvtDatabase::UpdateEventTableL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::UpdateEventTableL( 
                            CEvtEvent&          aEvtEvent )
    {
	EVTUIDEBUG( "+ CEvtDatabase::UpdateEventTableL()" ); 
    // Update all the attributes of an Event
	  
	RSqlStatement stmt;
	TInt paramIndex;
	
	// We need to create the streams to insert large texts.
	RSqlParamWriteStream subjectStream;
	RSqlParamWriteStream placeStream;
	RSqlParamWriteStream descStream;
	CleanupClosePushL( subjectStream );
	CleanupClosePushL( placeStream );
	CleanupClosePushL( descStream );
	
	// Prepare the SQL statement to Get Events based on Status
	stmt.Prepare( iDb, KUpdateEvent );
	
	// Set Status
	paramIndex = stmt.ParameterIndex( KStatus );
	stmt.BindInt( paramIndex, aEvtEvent.EventStatus() );
	
	// Set Subject
	paramIndex = stmt.ParameterIndex( KSubject );
	if( KNullDesC() == aEvtEvent.Subject() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		subjectStream.BindText( stmt, paramIndex );
		subjectStream.WriteL( aEvtEvent.Subject() );
		subjectStream.CommitL();
		}
	
	// Set Place
	paramIndex = stmt.ParameterIndex( KPlace );
	if( KNullDesC() == aEvtEvent.Place() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		placeStream.BindText( stmt, paramIndex );
		placeStream.WriteL( aEvtEvent.Place() );
		placeStream.CommitL();
		}
	
	// Set Radius
	paramIndex = stmt.ParameterIndex( KRadius );
	stmt.BindReal( paramIndex, aEvtEvent.Radius() );
	
	// Set Description
	paramIndex = stmt.ParameterIndex( KDescription );
	if( KNullDesC() == aEvtEvent.Description() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		descStream.BindText( stmt, paramIndex );
		descStream.WriteL( aEvtEvent.Description() );
		descStream.CommitL();
		}
	
	// Set Repeat
	paramIndex = stmt.ParameterIndex( KRepeat );
	stmt.BindInt( paramIndex, aEvtEvent.Repeat() );
    
    // Set Id
	paramIndex = stmt.ParameterIndex( KEventId );
	stmt.BindInt( paramIndex, aEvtEvent.EventId() );
	
	// Execute the Remove SQL statement
	User::LeaveIfError( stmt.Exec() );
	
	//Close the streams
	CleanupStack::PopAndDestroy( &descStream );
	CleanupStack::PopAndDestroy( &placeStream );
	CleanupStack::PopAndDestroy( &subjectStream );
	    
	stmt.Close();

	EVTUIDEBUG( "- CEvtDatabase::UpdateEventTableL()" );
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::DeleteEventL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::DeleteEventL( 
                            	TEvtEventId          aEventId )
    {
	EVTUIDEBUG( "+ CEvtDatabase::DeleteEventL()" );
    
	RSqlStatement stmt;
	TInt paramIndex;
	
	// Prepare the SQL statement to Remove Action based on Id
	stmt.Prepare( iDb, KDeleteEvent );
	
	// Set the Id parameter in SQL statement
	paramIndex = stmt.ParameterIndex( KEventId );
	stmt.BindInt( paramIndex, aEventId );
	
	// Execute the Remove SQL statement
	User::LeaveIfError( stmt.Exec() );
	
	stmt.Reset();
	stmt.Close();

	EVTUIDEBUG( "- CEvtDatabase::DeleteEventL()" );
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::CheckIfEventPresentL
// ---------------------------------------------------------------------------
//
TBool CEvtDatabase::CheckIfEventPresentL( 
                            TEvtEventId          aId )
    {
	EVTUIDEBUG( "+ CEvtDatabase::DeleteEventL()" );

	RSqlStatement stmt;
	
	// Prepare the SQL statement to Get Action based on EvtId
	stmt.Prepare( iDb, KSelectEvent );
	
	// Set the Id parameter in SQL statement
	TInt paramIndex=stmt.ParameterIndex( KEventId );
	stmt.BindInt( paramIndex, aId ); 

    // Flag to Check if the the Action is present
    TBool flag( EFalse );

	// Set the other attributes of the Requested Event
	while( !flag && stmt.Next() == KSqlAtRow )
		{
		flag = ETrue;
		}
    
    stmt.Close();
	EVTUIDEBUG( "- CEvtDatabase::DeleteEventL()" );
	
    return flag;
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::CheckIfActionPresentL
// ---------------------------------------------------------------------------
//
TBool CEvtDatabase::CheckIfActionPresentL( 
                            TInt64          aId )
    {
	EVTUIDEBUG( "+ CEvtDatabase::CheckIfActionPresentL()" );

	RSqlStatement stmt;
	
	// Prepare the SQL statement to Get Action based on EvtId
	stmt.Prepare( iDb, KSelectAction );
	
	// Set the Id parameter in SQL statement
	TInt paramIndex=stmt.ParameterIndex( KId );
	stmt.BindInt64( paramIndex, aId ); 

    // Flag to Check if the the Action is present
    TBool flag( EFalse );

	// Set the other attributes of the Requested Event
	while( !flag && stmt.Next() == KSqlAtRow )
		{
		flag = ETrue;
		}
    
    stmt.Close();
	EVTUIDEBUG( "- CEvtDatabase::CheckIfActionPresentL()" );
	
    return flag;
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::GetActionId
// ---------------------------------------------------------------------------
//
TInt64 CEvtDatabase::GetActionId( 
                            TEvtEventId          aId )
    {
	EVTUIDEBUG( "+ CEvtDatabase::GetActionId()" );
    TInt64 id=0;
	TInt columnIndexActionId=0;
    
	RSqlStatement stmt;
	
	// Prepare the SQL statement to Get Action based on EvtId
	stmt.Prepare( iDb, KSelectActionFromEvent );
	
	// Set the Id parameter in SQL statement
	TInt paramIndex=stmt.ParameterIndex( KEvtId );
	stmt.BindInt( paramIndex, aId ); 

    // Flag to Check if the the Action is present
    TBool flag( EFalse );

	// Set the other attributes of the Requested Event
	while( !flag && stmt.Next() == KSqlAtRow )
		{
		id = stmt.ColumnInt64( columnIndexActionId );
		flag = ETrue;
		}
    
    stmt.Close();
	EVTUIDEBUG( "- CEvtDatabase::GetActionId()" );
	
    return id;
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::CreateActionL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::CreateActionL( 
								CEvtAction&          aEvtAction )
    {
	EVTUIDEBUG( "+ CEvtDatabase::CreateActionL()" );
    
    RSqlStatement stmt;
	
	// Update Action table.
	RSqlParamWriteStream actionStream;
	CleanupClosePushL( actionStream );
	
	// Prepare the SQL statement to update Action based on Id
	stmt.Prepare( iDb, KInsertAction );
	
	// Set the Action parameter in SQL statement
	TInt paramIndex=stmt.ParameterIndex( KAction );
	if( KNullDesC() == aEvtAction.Action() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		actionStream.BindText( stmt, paramIndex );
		actionStream.WriteL( aEvtAction.Action() );
		actionStream.CommitL();
		}
	
	// Set the EvtId parameter in SQL statement
	paramIndex=stmt.ParameterIndex( KEvtId );
	stmt.BindInt( paramIndex, aEvtAction.EvtId() );
	
	// Actual Query execution that updates the database.
	User::LeaveIfError( stmt.Exec() );
	
	//Close the stream
	CleanupStack::PopAndDestroy( &actionStream );
	stmt.Close();
	
	//Set the new Action Id
	aEvtAction.SetId( GetActionId( aEvtAction.EvtId() ) );
	
	EVTUIDEBUG( "- CEvtDatabase::CreateActionL()" );

    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::UpdateActionL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::UpdateActionL( 
                            	CEvtAction&          aEvtAction )
    {
	EVTUIDEBUG( "+ CEvtDatabase::UpdateActionL()" );
    
    RSqlStatement stmt;
	
	// Update Action table.
	RSqlParamWriteStream actionStream;
	CleanupClosePushL( actionStream );
	
	// Prepare the SQL statement to update Action based on Id
	stmt.Prepare( iDb, KUpdateAction );
	
	// Set the Action parameter in SQL statement
	TInt paramIndex=stmt.ParameterIndex( KAction );
	if( KNullDesC() == aEvtAction.Action() )
		{
	    stmt.BindNull( paramIndex );
		}
	else
		{
		actionStream.BindText( stmt, paramIndex );
		actionStream.WriteL( aEvtAction.Action() );
		actionStream.CommitL();
		}
	
	// Set the EvtId parameter in SQL statement
	paramIndex=stmt.ParameterIndex( KEvtId );
	stmt.BindInt( paramIndex, aEvtAction.EvtId() );
	
	// Set the Id parameter in SQL statement
	paramIndex=stmt.ParameterIndex( KId );
	stmt.BindInt64( paramIndex, aEvtAction.Id() );
	
	// Actual Query execution that updates the database.
	User::LeaveIfError( stmt.Exec() );
	
	//Close the stream
	CleanupStack::PopAndDestroy( &actionStream );
	stmt.Close();

	EVTUIDEBUG( "- CEvtDatabase::UpdateActionL()" );
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::DeleteActionL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::DeleteActionL( 
                            	TEvtEventId          aEventId )
    {
	EVTUIDEBUG( "+ CEvtDatabase::DeleteActionL()" );
    
	RSqlStatement stmt;
	TInt paramIndex;
	
	// Prepare the SQL statement to Remove Action based on Id
	stmt.Prepare( iDb, KDeleteAction );
	
	// Set the Id parameter in SQL statement
	paramIndex = stmt.ParameterIndex( KEvtId );
	stmt.BindInt( paramIndex, aEventId );
	
	// Execute the Remove SQL statement
	User::LeaveIfError( stmt.Exec() );
	
	stmt.Close();

	EVTUIDEBUG( "- CEvtDatabase::DeleteActionL()" );
    }
    
// ---------------------------------------------------------------------------
// CEvtDatabase::SetObserver
// ---------------------------------------------------------------------------
//
void CEvtDatabase::SetObserver( MEvtStorageDbObserver*      
														aStorageDbObserver )
    {
	EVTUIDEBUG( "+ CEvtDatabase::SetObserver()" );
    // Set the Observer to the database
	iStorageDbObserver = aStorageDbObserver;
	EVTUIDEBUG( "- CEvtDatabase::SetObserver()" );
    } 

// ---------------------------------------------------------------------------
// CEvtDatabase::HandleDbChangedL
// ---------------------------------------------------------------------------
//
void CEvtDatabase::HandleDbChangedL( )
    {
	EVTUIDEBUG( "+ CEvtDatabase::HandleDbChangedL()" );
    
    // If there is an observer to the database, notify it.
	if( iStorageDbObserver )
		{
		iStorageDbObserver->HandleStorageDbChangedL( );
		}
	EVTUIDEBUG( "- CEvtDatabase::HandleDbChangedL()" );
    } 
    
// End of File