// Copyright (c) 2004-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:

// Mapping rules for deprecated elements in the comms database schema

// All data in file

// CONTENTS OF FILE

// 1/  Utilities

// 2/  CCDMapper Base class implementation

// 3/  Mapper classes for individual elements in the database

// a) CCDMapperGlobalSettingsRecord

// b) CCDMapperIAPPrioritySelectionPolicyRecord

// c) CCDMapperAccessPointRecord

// MAINTENANCE - some rules may need adding or amending whenever the database schema changes

// 

//

/**

 @file CommsDatMapper.cpp

 @internalComponent

*/

#include "CommsDatInternalDefs.h"

#include <commsdattypesv1_1.h>

#include "CommsDatMapper.h"

#include <comms-infras/commsdatschema.h>

#include <commsdat.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdattypesv1_1_partner.h>

#include <commsdat_partner.h>

#endif

using namespace Meta;

using namespace CommsDatInternal;

using namespace CommsDat;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY 

//anonymous namespace

namespace

    {

    const TInt NetworkBaseTagId     = 10000;

    }

#endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY 

/***************************************************************************************

 * 1/ Utilities

 */

TBool Changed(const CMDBElement& aElement)

/*

Utility function to check if an element has been changed

@internalComponent

*/

    {

    if ( aElement.ElementId() & KCDChangedFlag )

        {

        return ETrue;

        }

    return EFalse;

    }

void Sync(CMDBElement& aElement)

/*

Utility function to mark an element in sync with Database

@internalComponent

*/

    {

    aElement.SetElementId(aElement.ElementId() & ~KCDChangedFlag);

    }

TInt CCDMapper::FindLinkElementIdL(TInt aVal, TInt aTargetTable)

/*

utility for mapping link fields - when link fields fixed this will be unnecessary

*/    {

        TInt ret(KErrNone);

        if (KLinkableTag & aVal)

            {

            // this is a link by tag so need to do a find for the tag in the target field

            CMDBField<TUint32>* tagField = new (ELeave) CMDBField<TUint32>(aTargetTable |KCDTIdRecordTag);

            CleanupStack::PushL(tagField);

            *tagField = aVal;

            if (tagField->FindL(iSession.iOwner))

                {

                ret = (tagField->ElementId() | KCDMaskShowRecordTypeAndId);

                }

            CleanupStack::PopAndDestroy(tagField);

            }

        // add a check for the record id too.

        // otherwise the value already gives the element id directly

        return ret;

        }   

/****************************************************************************************

 * 2/  CCDMapper base class implementation

 ***************************************************************************************/

CCDMapper::CCDMapper(TMDBElementId aElementId, CMDBElement& aElement,CMDBSessionImpl& aSession

		             ,const TOperation& aOperation)

	: CMDBRecordBase(aElementId)

    , iElement(aElement)

    , iSession(aSession)

    , iOperation(aOperation)

    {

    iSession.iMapping = ETrue;

    }

CCDMapper::~CCDMapper()

    {

    iSession.iMapping = EFalse;

    }

CCDMapper* CCDMapper::MaybeCreateMapperLC(CMDBElement& aElement,CMDBSessionImpl& aSession, const TOperation& aOperation)

/*

Static Factory function. 

  Creates a mapping object of the appropriate type

@internalComponent

*/

	{

    if (aSession.UsingLatestVersion() || aSession.iMapping)

        {

        // only map if client has asked to manage deprecated fields

        // and if no mapping or validation going on already

        return NULL;

        }

    if(CommsDat::CommsDatSchema::IsTable(aElement.ElementId()))

        {

    	// only need mapper for records and fields, not tables

        return NULL;

        }

	CCDMapper* mapper = NULL;

    switch((TUint32)aElement.TypeId() & KCDMaskShowRecordType)

	    {

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        case KCDTIdGlobalSettingsRecord:

	        {

            mapper = new(ELeave)CCDMapperGlobalSettingsRecord(aElement,aSession, aOperation); 

		    break;

	        }

	    case KCDTIdIapPrioritySelectionPolicyRecord:

	        {

            mapper = new(ELeave)CCDMapperIAPPrioritySelectionPolicyRecord(aElement,aSession, aOperation); 

            break;

	        }

	    case KCDTIdAccessPointRecord:

	        {

	        mapper = new(ELeave)CCDMapperAccessPointRecord(aElement,aSession, aOperation); 

		    break;

	        }

#endif // SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        default :

            {

            // Nothing to do so exit quickly

            mapper = NULL;

            }

		}

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    if(! mapper)

        {

        return NULL;

        }

    if (mapper->NeedsMapping(aElement))

        {

        CleanupStack::PushL(mapper);

        mapper->ConstructL();

        }

    else 

        {

        delete mapper;

        mapper = NULL;

        }

#endif // SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    return mapper;	

	}

void CCDMapper::ConstructL()

/*

following a unique set of mapping rules implemented in derived classes and

using information from both the input element and the database

1/ Set up record id(s) for elements in the map 

2/ where deprecated elements in the input element (iElement) have values that

have been changed by the user, populate the values of the corresponding map element(s) 

@internalTechnology

*/

    {   

    //  Default is nothing to construct

    return;

    }

void CCDMapper::PrepareToStoreL()

    {   

    //  Default is nothing to prepare

    return;

    }

//TBool CCDMapper::Mapped(TMDBElementId aElementId)

/*

Return ETrue if the sub-element (always a field) is mapped.  

Otherwise return EFalse

@internalTechnology

*/

   // {

  //  return aElementId != aElementId;

   // }

void CCDMapper::MapResultsL()

/*

Set up record id(s) for the map and populate each entry in the map

following a unique set of mapping rules (implemented in derived classes)

using information from both the input element and the database

@internalTechnology

*/

    { 

    // Default is nothing to map

    return; 

    }

/*virtual*/ void CCDMapper::PostMappingsL()

/*

@internalTechnology

*/    

    {

     // Default is nothing to process...

    (void)iOperation; //just to bypass the comp. warning

    return; 

    }

/*virtual*/ void CCDMapper::PreMappingsL()

/*

@internalTechnology

*/    

    {

     // Default is nothing to process...

    (void)iOperation; //just to bypass the comp. warning

    return; 

    }

/*****************************************************************************************

 * 3/ MAPPER CLASSES FOR INDIVIDUAL ELEMENTS

 *****************************************************************************************/

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY 

/************************* 3/ a) Mapper for GlobalSettings Table ************************************

 * KCDTIdGlobalSettingsRecord

 *

 * These 2 fields are now stored against the Default Tier record in the Tier table

 *      DefaultSnap     KCDTIdDefaultSnap    CCDGlobalSettingsRecord::iDefaultSnap

 *      PromptUser      KCDTIdPromptForSnap  CCDGlobalSettingsRecord::iPromptForSnap

 *

 * Corresponding fields in the Tier table (KCDTIdTierRecord) are

 *      DefaultSnap     KCDTIdDefaultAccessPoint  CCDTierRecord::iDefaultAccessPoint

 *	    PromptUser      KCDTIdPromptUser          CCDTierRecord::iPromptUser

 *

 * The mapping relies on the presence of the DefaultTier field in the GlobalSettings Table

 *      DefaultTier     KCDTIdDefaultTier    CCDGlobalSettingsRecord::iDefaultTier

 *

 * The DefaultTier must always be present as a real or default value in the GlobalSettings

 * Table.  A preface config file may be the best way to set this value.

 * 

 * If KCDTIdDefaultTier field is not present in the GlobalSettings Table, 

 * these fields cannot be mapped [They could be set as default values in Template of Tier Table?]

 */

#define KCDTIdGlobalSettingsRecordMapper    9879

START_ATTRIBUTE_TABLE( CCDMapperGlobalSettingsRecord, KCDTIdGlobalSettingsRecordMapper, KCDTIdGlobalSettingsRecordMapper)

	X_REGISTER_ATTRIBUTE( CCDMapperGlobalSettingsRecord, iPromptUser,         TMDBNum)

    //X_REGISTER_ATTRIBUTE( CCDMapperGlobalSettingsRecord, iDefaultAccessPoint, TMDBNum)

    X_REGISTER_ATTRIBUTE( CCDMapperGlobalSettingsRecord, iDefaultAccessPoint, TMDBLinkNum)

END_ATTRIBUTE_TABLE()

CCDMapperGlobalSettingsRecord::CCDMapperGlobalSettingsRecord(CMDBElement& aElement,CMDBSessionImpl& aSession, const TOperation& aOperation)

: CCDMapper(0, aElement,aSession,aOperation), 	

  iPromptUser(KCDTIdPromptUser),

  iDefaultAccessPoint(KCDTIdDefaultAccessPoint)		

    {}

void CCDMapperGlobalSettingsRecord::ConstructL()

/*

Set up record id(s) for elements in the map and populate the values of 

each each element in the map following a unique set of mapping rules 

(implemented in derived classes) using information from both the input 

element and the database

 * Rules 

    a) find DefaultTier in GlobalSettings record (from inputElement or database)

    b) use the value to give the record id of the Tier record

@internalComponent

*/

    {   

    CMDBRecordLink<CCDTierRecord> *defaultTier = new(ELeave) CMDBRecordLink<CCDTierRecord>(KCDTIdGlobalSettingsRecord | KCDTIdDefaultTier); 

    CleanupStack::PushL(defaultTier);

    defaultTier->SetRecordId(1);

    defaultTier->LoadL(iSession.iOwner);

    if (CommsDat::CommsDatSchema::IsRecord(iElement.ElementId()))

        {

        CCDGlobalSettingsRecord& globalSettings = static_cast<CCDGlobalSettingsRecord&>(iElement);

        if (! globalSettings.iDefaultTier.IsNull())

            {

            defaultTier->SetL(globalSettings.iDefaultTier);

            }

        }

    TMDBElementId targetId = CommsDatSchema::GetLinkIdL(iSession.iOwner, defaultTier->ElementId(), defaultTier->GetL(), KCDTIdTierRecord/*, NULL*/);

    CleanupStack::PopAndDestroy(defaultTier);

    SetRecordId(targetId);

    // Now populate the data from the input element

    CreateMapL();

    }

void CCDMapperGlobalSettingsRecord::CreateMapL()

/*

Populate the values of each each element in the map from data in the input element

following a unique set of mapping rules.

NB. Should only use data in the input element (iElement), not the database

The record ids of the mapping elements have already been set in InitMapL

@internalComponent

*/

    {           

    //switch (iElement.TypeId())

    switch (iElement.ElementId() & KCDMaskShowType)

        {

        case KCDTIdGlobalSettingsRecord | KCDMaskShowFieldType:

            {

            CCDGlobalSettingsRecord* globalSettings = static_cast<CCDGlobalSettingsRecord*>(&iElement);

            if (Changed(globalSettings->iDefaultSnap))

            	{

            	/* There are cases when the 'DefaultSnap' field in the GS record

            	 * is 0 (explicitly). In this case the GS mapper checks wheather

            	 * the given field is changed or not (it's changed) BUT during the

            	 * STORE operation we don't want to store and map the 0 value because

            	 * this would mean to overwrite the default AP field in the NetworkTier,

            	 * which is set to a default value form the meshpreface.cfg file.

            	 * So the check here checks:

            	 * if we are in a STORE operation and the DefualtSNAP field in the GS

            	 *    record is 0 then we change the field back to the 'unchanged state'.*/

            	if (0 == globalSettings->iDefaultSnap.GetL() &&

            	    EStore == iOperation)

            		{

            		//change back the field to the 'unchanged' state

            		iDefaultAccessPoint.SetElementId(iDefaultAccessPoint.ElementId() & ~KCDChangedFlag);

            		}

            	else

            		{

            		//Assuming that the defaultSnap id the Snap config file is an AP record id

            		iDefaultAccessPoint.SetL(KCDTIdAccessPointRecord | (globalSettings->iDefaultSnap << 8));

            		}

            	}

            if (Changed(globalSettings->iPromptForSnap))

                {

                iPromptUser.SetL(globalSettings->iPromptForSnap);

                }

            break;

            }

        //case KCDTIdDefaultAccessPoint :

        case KCDTIdDefaultSnap :

            {

        	if (Changed(iElement))

                {

                iDefaultAccessPoint.SetL(*static_cast<CMDBRecordLinkBase*>(&iElement));

                }

            break;

            }

        case KCDTIdPromptForSnap :

            {

            if (Changed(iElement))

                {

                iPromptUser.SetL(*static_cast<CMDBField<TBool>*>(&iElement)); 

                }

            break;

            }

        default :

            {

            ASSERT(KErrNotFound); // hmmm... shouldn't get here.

            User::Leave(KErrNotFound); 

            }

        }

    }

/**

    if the mapped fields are already existing in the Tier record on the Network

    level, they should be deleted.

*/

/*virtual*/ void CCDMapperGlobalSettingsRecord::PrepareToStoreL()

    {

    //Create the storage for the original GlobalSettings record...

    iSession.MaybeCreateNodeL(iElement);

    if (Changed(iPromptUser))

        {

        iPromptUser.SetRecordId(RecordId());

        iPromptUser.DeleteL(iSession.iOwner);

        }

    if (Changed(iDefaultAccessPoint))

        {

        iDefaultAccessPoint.SetRecordId(RecordId());

        iDefaultAccessPoint.DeleteL(iSession.iOwner);

        }

    }

TBool CCDMapperGlobalSettingsRecord::Mapped(TMDBElementId aElementId)

/*

Return ETrue for any element that is mapped.  

@internalComponent

*/

    {

    //switch(aElementId & KCDMaskShowFieldType)

    switch(aElementId & KCDMaskShowType)

		{

 		case KCDTIdDefaultSnap :

		case KCDTIdPromptForSnap :

		    {

            return ETrue;

		    }

        }

	return EFalse; 

    }

TBool CCDMapperGlobalSettingsRecord::NeedsMapping(CMDBElement& aElement)

/*

Return ETrue for any element that is mapped.  

@internalComponent

*/

    {

    if(CommsDat::CommsDatSchema::IsRecord(iElement.ElementId()))

        {

        //this is a record mapping and the session used is not the latest. So let's have a mapper...

        /*CCDGlobalSettingsRecord& globalSettings = static_cast<CCDGlobalSettingsRecord&>(iElement);

        if (Changed(globalSettings.iDefaultSnap) ||

            Changed(globalSettings.iPromptForSnap)   )

            {

            return ETrue;

            }*/

        return ETrue;

        }

    return Mapped(aElement.ElementId());

    }

void CCDMapperGlobalSettingsRecord::MapResultsL()

/*

Map results to original element

@internalComponent

*/

    {

    //switch (iElement.TypeId())

    switch (iElement.ElementId() & KCDMaskShowType)

        {

        case KCDTIdGlobalSettingsRecord | KCDMaskShowFieldType:

            {

            CCDGlobalSettingsRecord* globalSettings = static_cast<CCDGlobalSettingsRecord*>(&iElement);

            globalSettings->iDefaultSnap.SetL(iDefaultAccessPoint);

            //give back just the record number of the linked AP - as in the good old days...

            CMDBRecordLink<CCDAccessPointRecord>* defaultSnap = static_cast<CMDBRecordLink<CCDAccessPointRecord>*>(&(globalSettings->iDefaultSnap));

            *defaultSnap = (*defaultSnap & KCDMaskShowRecordId) >> 8;