// 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:

// Validation rules for some comms database elements

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

// No need to validate every entry  

// Mostly rely on compliance from writers as they are well trusted

// FILE CONTENTS :

// 1/  CCDValidator Base class implementation

// 2/  Validator classes for particular records

// a) CCDValidatorProxyRecord

// b) CCDValidatorLANServiceRecord

// c) CCDValidatorTierRecord

// d) CCDValidatorConnPref

// e) CCDValidatorIAPRecord

// All data in file

// 

//

/**

 @file CommsDatValidator.cpp

 @internalComponent

*/

#include "CommsDatInternalDefs.h"

#include <commsdattypesv1_1.h>

#include "CommsDatValidator.h"

#include <comms-infras/commsdatschema.h>

#include <commsdat.h>

#include "CommsDatMapperAndValidatorUtils.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 KNumServiceType = 12;

    struct TMapBearerToServiceType

    	{

    	TCommDbBearer				bearerMask;

    	TCommDbConnectionDirection	direction;

    	const TText*				serviceType;

    	};

    const TMapBearerToServiceType KMap[KNumServiceType] =

    	{

        	{KCommDbBearerCSD,		ECommDbConnectionDirectionOutgoing, DIAL_OUT_ISP},

        	{KCommDbBearerCSD,		ECommDbConnectionDirectionIncoming, DIAL_IN_ISP},

        	{KCommDbBearerWcdma,	ECommDbConnectionDirectionOutgoing, OUTGOING_GPRS},

        	 /** The following two mappings are only required for tornado */

        	{KCommDbBearerWcdma,	ECommDbConnectionDirectionIncoming, INCOMING_GPRS},

        	{KCommDbBearerLAN,		ECommDbConnectionDirectionIncoming,	LAN_SERVICE},

        	{KCommDbBearerLAN,		ECommDbConnectionDirectionOutgoing,	LAN_SERVICE},

        	{KCommDbBearerVirtual,	ECommDbConnectionDirectionIncoming,	VPN_SERVICE},

        	{KCommDbBearerVirtual,	ECommDbConnectionDirectionOutgoing,	VPN_SERVICE},

        	/** PAN profile uses LAN service table, plus an extension service table */

        	{KCommDbBearerPAN,		ECommDbConnectionDirectionIncoming,	LAN_SERVICE},

        	{KCommDbBearerPAN,		ECommDbConnectionDirectionOutgoing,	LAN_SERVICE},

        	/** WLAN uses LAN service table, plus an extension service table */

        	{KCommDbBearerWLAN,		ECommDbConnectionDirectionIncoming,	LAN_SERVICE},

        	{KCommDbBearerWLAN,		ECommDbConnectionDirectionOutgoing,	LAN_SERVICE}

    	};

        //this function returns the index in the array of the service type which should be used based

        //on the received bearer and direction parameters.

        //it returns KErrNotFound if the service type cannot be found based on the received params.

        TInt GetIAPServiceType(TUint32& aServTypeArrayStartIndex, TCommDbBearer aBearerSet, TCommDbConnectionDirection aDirection)

            {

            for (int i = aServTypeArrayStartIndex; i < KNumServiceType; i++)

        		{

        		if ((aBearerSet & KMap[i].bearerMask) != 0 &&

        			(aDirection == KMap[i].direction ||

        			 aDirection == ECommDbConnectionDirectionUnknown ))

        			{

        			aServTypeArrayStartIndex = i;

        			return i;

        			}

                }

            return KErrNotFound;

            }

        CMDBRecordLink<CCDAccessPointRecord>* GetTheAPxLinkFromAPPrioritySelPol(CCDAPPrioritySelectionPolicyRecord* aAPSelPolRec,

                                                                        TInt aRankingFromConnPref)

            {

            TMetaVTableIterator attribIter(aAPSelPolRec);

            SVDataTableEntry const* entry = 0;

            TInt fieldCounter(15);

            TInt linkNumber(aRankingFromConnPref);

            CMDBRecordLink<CCDAccessPointRecord>* apPrioritySelPolLink = NULL;

            while ( (entry = attribIter++) != NULL &&

                    linkNumber-- > 0 && 

                    fieldCounter-- > 0 )

                {

                apPrioritySelPolLink = reinterpret_cast<CMDBRecordLink<CCDAccessPointRecord>*>(aAPSelPolRec->GetAttribPtr(entry->iOffset));

                }

            return apPrioritySelPolLink;

            }

    }

#endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

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

 * 1/ CCDValidator   Base class implementaion

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

CCDValidator::CCDValidator(CMDBElement* aElement,CMDBSessionImpl& aSession):

iElement(aElement),iSession(aSession)

/*

@internalComponent

*/

    {

    iSession.iMapping = ETrue;

    }

CCDValidator::~CCDValidator()

/*

@internalComponent

*/

    {

    iSession.iMapping = EFalse;

    }

void CCDValidator::ValidateL(CMDBElement* aElement,CMDBSessionImpl& aSession

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

                             ,TOperation aValidatorOperation

#endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

                             )

/*

Creates a validation object of the appropriate type

if there are validation rules for aElement

and calls validate

@internalComponent

*/

	{

    if( aSession.iMapping )

        {

        return;

        }

    if( CommsDat::CommsDatSchema::IsTable(aElement->ElementId()) )

    	{

        return;

        }

    // then create a validator for the business data if there are any rules set

    CCDValidator* validator = NULL;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY        

    if (EModify == aValidatorOperation ||

    	EStore == aValidatorOperation)

    //this is the original behaviour of this method

        {

#endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        if (! CommsDat::CommsDatSchema::IsNode(aElement->ElementId()))

            {

            // First validate the field type (see CommsDatSchema)

            CommsDatSchema::ValidateFieldTypeL(aSession.iOwner, *aElement); 

            /* Only compliant processes can write to the database

              don't see it is valuable to validate every field*/

            //return;  

            }

        switch(aElement->ElementId() & KCDMaskShowRecordType) 

    		{

            case KCDTIdConnectionPrefsRecord:

                {

                validator = new(ELeave)CCDValidatorConnPref(aElement,aSession

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

                , aValidatorOperation

#endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

                ); 

                break;

                }

            case KCDTIdIAPRecord:

    		    {

                validator = new(ELeave)CCDValidatorIAPRecord(aElement,aSession

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

                , aValidatorOperation

#endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

                ); 

                break;

                }

            case KCDTIdLANServiceRecord:

    		    {

    			validator = new(ELeave)CCDValidatorLANServiceRecord(aElement,aSession); 

    			break;

    		    }

            case KCDTIdProxiesRecord:

    		    {

    			validator = new(ELeave)CCDValidatorProxyRecord(aElement,aSession); 

    			break;

    		    }

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

            case KCDTIdTierRecord:

    		    {

    			validator = new(ELeave)CCDValidatorTierRecord(aElement,aSession); 

    			break;

    		    }

    #endif // SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

            default :

                {

    			return; // Exit quickly if there's no validator

                }

            }

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

        }

    else

    //the validator should be created for deleting some other data...

        {

        switch(aElement->ElementId() & KCDMaskShowRecordType) 

    		{

            case KCDTIdConnectionPrefsRecord:

                {

                validator = new(ELeave)CCDValidatorConnPref(aElement,aSession, aValidatorOperation); 

                break;

                }

            case KCDTIdIAPRecord:

    		    {

                validator = new(ELeave)CCDValidatorIAPRecord(aElement,aSession, aValidatorOperation); 

                break;

    		    }

            default :

                {

    			return; // Exit quickly if there's no validator

                }

    		}

        }

#endif //SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

    CleanupStack::PushL(validator);

    validator->DoValidateL();

    CleanupStack::PopAndDestroy(validator);

	}

void CCDValidator::DoValidateL()

/*

Default is nothing to validate so return 

@internalComponent

*/

    {

    User::LeaveIfError(1 == 1);

    }

void CCDValidator::OnDeleteL()

/*

Default is nothing to delete;

@internalTechnology

*/

    {

    User::LeaveIfError(1 == 1);

    }

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

 * 2/ VALIDATION CLASSES FOR INDIVIDUAL RECORDS

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

/************************* 2a) Validate Proxy Record ************************************

Validate open link to service record

*/

void CCDValidatorProxyRecord::SetShadowElementL()

	{

	iShadowElement = CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord);

	iShadowElement->SetRecordId(iElement->RecordId());

	iShadowElement->LoadL(iSession.iOwner);

	if ( KCDMaskShowFieldType != (KCDMaskShowFieldType & iElement->ElementId()) )

		{

		//field validation

		CMDBElement* shadowFieldPtr = static_cast<CMDBRecordBase*>(iShadowElement)->GetFieldByIdL(iElement->ElementId());

		if ( KCDTIdRecordName == (iElement->ElementId() & KCDMaskShowFieldType) ||

			 KCDTIdProxyServiceType == (iElement->ElementId() & KCDMaskShowType) ||

			 KCDTIdServerName == (iElement->ElementId() & KCDMaskShowType) ||

			 KCDTIdProtocolName == (iElement->ElementId() & KCDMaskShowType) ||

			 KCDTIdExceptions == (iElement->ElementId() & KCDMaskShowType) )

			{

			CMDBField<TDesC>* nameField = static_cast<CMDBField<TDesC>*>(shadowFieldPtr);

			CMDBField<TDesC>* origField = static_cast<CMDBField<TDesC>*>(iElement);

			nameField->SetL(*origField);

			}

		else		

			{

			CMDBField<TInt>* numField = static_cast<CMDBField<TInt>*>(shadowFieldPtr);

			CMDBField<TInt>* origField = static_cast<CMDBField<TInt>*>(iElement);

			numField->SetL(*origField);

			}

		}

	iElement = iShadowElement;

	}

void CCDValidatorProxyRecord::DoValidateL()

/*

Just validate the linked field

@internalComponent

*/

    {

    if ( KCDMaskShowFieldType != (KCDMaskShowFieldType & iElement->ElementId()))

    	{

    	//field validation

    	SetShadowElementL(); 

    	}

#ifndef SYMBIAN_COMMSDAT_USE_INT_RECORD_LINKS

    CCDProxiesRecord* proxyRecord = static_cast<CCDProxiesRecord*>(iElement);

    if (! proxyRecord->iService.IsNull() && ! proxyRecord->iServiceType.IsNull())

        {

        TMDBElementId serviceTypeId = CommsDatSchemaV1_1::LookupTableId(proxyRecord->iServiceType.GetL());

        proxyRecord->iService = CommsDatSchema::GetLinkIdL(iSession.iOwner, proxyRecord->iService.ElementId(), proxyRecord->iService.GetL(), serviceTypeId/*, &proxyRecord*/);

        }

#endif // SYMBIAN_COMMSDAT_USE_INT_RECORD_LINKS

    }

/************************* 2b) Validate LANService Record ***********************************

Validate open link to service extension record

*/

void CCDValidatorLANServiceRecord::SetShadowElementL()

	{

	iShadowElement = CCDRecordBase::RecordFactoryL(KCDTIdLANServiceRecord);

	iShadowElement->SetRecordId(iElement->RecordId());

	iShadowElement->LoadL(iSession.iOwner);

	if ( KCDMaskShowFieldType != (KCDMaskShowFieldType & iElement->ElementId()) )

		{

		//field validation

		CMDBElement* shadowFieldPtr = static_cast<CMDBRecordBase*>(iShadowElement)->GetFieldByIdL(iElement->ElementId());

		if ( KCDTIdRecordTag == (iElement->ElementId() & KCDMaskShowFieldType) ||

			 KCDTIdLANIpAddrFromServer == (iElement->ElementId() & KCDMaskShowType) ||

			 KCDTIdLANIpDNSAddrFromServer == (iElement->ElementId() & KCDMaskShowType) ||

			 KCDTIdLANIp6DNSAddrFromServer == (iElement->ElementId() & KCDMaskShowType) ||

			 KCDTIdLANServiceExtensionTableRecordId == (iElement->ElementId() & KCDMaskShowType) )

			{

			CMDBField<TInt>* numField = static_cast<CMDBField<TInt>*>(shadowFieldPtr);

			CMDBField<TInt>* origField = static_cast<CMDBField<TInt>*>(iElement);

			numField->SetL(*origField);

			}

		else

			{

			CMDBField<TDesC>* nameField = static_cast<CMDBField<TDesC>*>(shadowFieldPtr);

			CMDBField<TDesC>* origField = static_cast<CMDBField<TDesC>*>(iElement);

			nameField->SetL(*origField);	

			}

		}

	iElement = iShadowElement;

	}

void CCDValidatorLANServiceRecord::DoValidateL()

/*

Just validate the linked field

@internalComponent

*/

	{

    if ( KCDMaskShowFieldType != (KCDMaskShowFieldType & iElement->ElementId()))

    	{

    	//field validation

    	SetShadowElementL(); 

    	}

#ifndef SYMBIAN_COMMSDAT_USE_INT_RECORD_LINKS

    CCDLANServiceRecord* lanServiceRecord = static_cast<CCDLANServiceRecord*>(iElement);

    if (! lanServiceRecord->iServiceExtensionTableRecordId.IsNull() && ! lanServiceRecord->iServiceExtensionTableName.IsNull())

        {

        //this was caught in testing but it is not valid to have a real record without these fields...

        TMDBElementId serviceExtTypeId = CommsDatSchemaV1_1::LookupTableId(lanServiceRecord->iServiceExtensionTableName.GetL());

        lanServiceRecord->iServiceExtensionTableRecordId = 

            CommsDatSchema::GetLinkIdL(iSession.iOwner, lanServiceRecord->iServiceExtensionTableRecordId.ElementId(), lanServiceRecord->iServiceExtensionTableRecordId.GetL(), serviceExtTypeId/*, &lanServiceRecord*/);    

        }

#endif

    }

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

// because tier record doesn't exist before then

/************************* 2c) Validate Tier Record *************************************

Tier thread name needs to be short name for Tier thread

*/

void CCDValidatorTierRecord::SetShadowElementL()

	{

	iShadowElement = CCDRecordBase::RecordFactoryL(KCDTIdTierRecord);

	iShadowElement->SetRecordId(iElement->RecordId());

	iShadowElement->LoadL(iSession.iOwner);

	if ( KCDMaskShowFieldType != (KCDMaskShowFieldType & iElement->ElementId()) )

		{

		//field validation

		CMDBElement* shadowFieldPtr = static_cast<CMDBRecordBase*>(iShadowElement)->GetFieldByIdL(iElement->ElementId());

		if ( KCDTIdRecordTag == (iElement->ElementId() & KCDMaskShowFieldType) ||

			 KCDTIdDefaultAccessPoint == (iElement->ElementId() & KCDMaskShowType) )

			{

			CMDBField<TInt>* numField = static_cast<CMDBField<TInt>*>(shadowFieldPtr);

			CMDBField<TInt>* origField = static_cast<CMDBField<TInt>*>(iElement);

			numField->SetL(*origField);

			}

		else

			{

			CMDBField<TDesC>* nameField = static_cast<CMDBField<TDesC>*>(shadowFieldPtr);

			CMDBField<TDesC>* origField = static_cast<CMDBField<TDesC>*>(iElement);

			nameField->SetL(*origField);	

			}

		}

	iElement = iShadowElement;

	}

void CCDValidatorTierRecord::DoValidateL()

/*

@internalComponent

*/	

    {

    if ( KCDMaskShowFieldType != (KCDMaskShowFieldType & iElement->ElementId()) )

    	{

    	//field validation

    	SetShadowElementL(); 

    	}

    CCDTierRecord* tierRec = static_cast<CCDTierRecord*>(iElement);

	if(static_cast<const TDesC16&>(tierRec->iTierThreadName).Length() > KShortTextLength)

		{

        __FLOG_STATIC(KLogComponent, KCDErrLog,

                            _L("CCDValidatorTierRecord::DoValidateL() - TierThreadName > KShortTextLength chars"));

		User::Leave(KErrTooBig);

		}

    }

/***************** 2d) Validate Connection Preference Record *****************************

*/

void CCDValidatorConnPref::SetShadowElementL()

	{	

	iShadowElement = CCDRecordBase::RecordFactoryL(KCDTIdConnectionPrefsRecord);

	iShadowElement->SetRecordId(iElement->RecordId());

	iShadowElement->LoadL(iSession.iOwner);

	if ( KCDMaskShowFieldType != (KCDMaskShowFieldType & iElement->ElementId()) )

		{

		//field validation

		CMDBElement* shadowFieldPtr = static_cast<CMDBRecordBase*>(iShadowElement)->GetFieldByIdL(iElement->ElementId());

		if (KCDTIdRecordName == (iElement->ElementId() & KCDMaskShowFieldType))

			{

			CMDBField<TDesC>* nameField = static_cast<CMDBField<TDesC>*>(shadowFieldPtr);

			CMDBField<TDesC>* origField = static_cast<CMDBField<TDesC>*>(iElement);

			nameField->SetL(*origField);		

			}

		else

			{

			//the only reason this cast can be done here is that the connPref record contains only

			//numerical based fields... (except the name field -> handled above...)

			CMDBField<TInt>* numField = static_cast<CMDBField<TInt>*>(shadowFieldPtr);

			CMDBField<TInt>* origField = static_cast<CMDBField<TInt>*>(iElement);

			if (EDelete == iOperation)

				{

				numField->SetL(0);

				}

			else

				{

				numField->SetL(*origField);

				}

			//in the case of the IAP link it has to be checked whether is it