Ax2012 Replace financial Dimensions

This sample code is used to replace the Organization value based on the selection of department dimension.


Req:- Dimension Department inheritance.
when we select the department we have to select the default organization.


Before doing this sample, I build one form which will loads the Department and organization and user will select the department dimension and default organization for that department.
ex:-
Dept    organization
600     roskilds
650    kildemos




static DimensionAttributeValueCombination Krishh_ReplaceLedgerDimensions(LedgerDimensionAccount targetDimension)
{
    #LedgerSHA1Hash
    DimensionSHA1Hash               hash; //To store the calculated hash for DimensionAttributeValueSet
    HashKey                         valueKeyHashArray[]; //To store the has key of dimension in question
    Map                             dimAttrIdx, dimAttrRecId; //to store the dimension index and backing entity type
    DimensionAttributeSetItem       dimAttrSetItem; // Contains the number of dimensions active for a account structure ledger
    DimensionAttribute              dimAttr,dimAttrNew; // Contains the financial dimensions records
    DimensionAttributeValue         dimAttrValue; // Contains used financial dimension values
    DimensionAttributeValueSet      dimAttrValueSet; //Contains default dimension records
    DimensionAttributeValueSetItem  dimAttrValueSetItem; //Contains individual records for default dimensions
    DimensionEnumeration            dimensionSetId; //Record id for table that contains active dimensions for current ledger
   // LedgerDimensionAccount          targetDimension = 5637151382; //Record Id DimensionAttributeValueCombination table in which attribute value is to be replaced
    LedgerDimensionAccount          ledgerDimension; // To hold the resultant DimensionAttributeValueCombination record id
    LedgerDimensionAccount          mainAccDimension; // Record id for LedgerDimension(DimensionAttributeValueCombination) containing default account for main account RecId
    DimensionStorage                dimensionStorage; // Class Dimension storage is used to store and manipulate the values of combination
    DimensionStorageSegment         segment; // Class DimensionStorageSegment will get specfic segments based on hierarchies
    DimAttributeProjTable           dimAttributeProjTable;

    DimensionFinancialTag           financialTag;

    int     segmentCount, segmentIndex;
    int     hierarchyCount, hierarchyIndex;
    SysDim  segmentValue, mainAccountValue;
    int     dimAttrCount, i;
    int     OrgBackEntityType; //Stores the backing entity type for Employee type dimension
    str     valueStrArray[]; //To store the dimension attribute values
    int64   valueKeyArray[]; //To store the record ids of DimensionAtrributeValue table
    int     backingEntityInstance;

    str     segmentName;// get the segment name ex: get the Department
    Department departmentValue;
    Organisation organizatioValue;

    ;

    //The  backing entity will be Financial Tag
    OrgBackEntityType = tableNum(DimensionFinancialTag);

    //Initialize the map to store the backing entity types
    dimAttrIdx = new Map(Types::Integer, Types::Integer);
    dimAttrRecId = new Map(Types::Integer, Types::Int64);

    //Get the record Id (dimension set id) for current ledger to find active dimensions
    dimensionSetId = DimensionCache::getDimensionAttributeSetForLedger();

    //Find all the active dimensions for current ledger except main account and store there
    //backing entity type in the map
    while select * from dimAttr
            order by Name
            where dimAttr.Type != DimensionAttributeType::MainAccount
        join RecId from dimAttrSetItem
            where dimAttrSetItem.DimensionAttribute == dimAttr.RecId &&
                dimAttrSetItem.DimensionAttributeSet == dimensionSetId

    {
        dimAttrCount++;
        dimAttrIdx.insert(dimAttr.BackingEntityType, dimAttrCount);
        dimAttrRecId.insert(dimAttr.BackingEntityType, dimAttr.RecId);
    }

    //initialize hash key array to null
    for (i = 1; i<= dimAttrCount; i++)
    {
        valueKeyHashArray[i] = emptyGuid();
        valueStrArray[i] = '';
        valueKeyArray[i] = 0;
    }

    // Default hash key array with required dimension value
    // Get dimension storage
    dimensionStorage = DimensionStorage::findById(targetDimension);
    if (dimensionStorage == null)
    {
        throw error("@SYS83964");
    }

    // Get hierarchy count
    hierarchyCount = dimensionStorage.hierarchyCount();
    //Loop through hierarchies to get individual segments
    for(hierarchyIndex = 1; hierarchyIndex <= hierarchyCount; hierarchyIndex++)
    {
        //Get segment count for hierarchy
        segmentCount = dimensionStorage.segmentCountForHierarchy(hierarchyIndex);

        //Loop through segments and display required values
        for (segmentIndex = 1; segmentIndex <= segmentCount; segmentIndex++)
        {
            // Get segment
            segment = dimensionStorage.getSegmentForHierarchy(hierarchyIndex, segmentIndex);

            // Get the segment information
            if (segment.parmDimensionAttributeValueId() != 0)
            {

                //Get the backing entity type;
                backingEntityInstance = DimensionAttribute::find(DimensionAttributeValue::find(segment.parmDimensionAttributeValueId()).DimensionAttribute).BackingEntityType;
                segmentName = DimensionAttribute::find(DimensionAttributeValue::find(segment.parmDimensionAttributeValueId()).DimensionAttribute).Name;

                if (backingEntityInstance == tableNum(DimAttributeMainAccount))
                    mainAccountValue = segment.parmDisplayValue();

                if(segmentName=="Department")
                    departmentValue=segment.parmDisplayValue();

                if (dimAttrIdx.exists(backingEntityInstance))
                {
                    i = dimAttrIdx.lookup(backingEntityInstance);
                    valueKeyHashArray[i]    = segment.parmHashKey();
                    valueKeyArray[i]        = segment.parmDimensionAttributeValueId();
                    valueStrArray[i]        = segment.parmDisplayValue();
                }

            }
        }
    }

    //Find the Dimension attribute record for the dimension to work on, in our case it is HcmWorker
    dimAttr.clear();

    select firstonly
            dimAttrNew
        where
            dimAttrNew.Name=="Organization";
    dimAttr = dimAttrNew;


 // store the Organization value for the Department and loads the Organization based on the selection of department in the General Journal   organizatioValue=DefaultOrganisationValues::findbyDepartmentOrganizations(departmentValue).Organisation;

    select firstonly financialTag where financialTag.Value==organizatioValue;


    //Find the required Dimension Attribute Value record
    //Create if necessary
    dimAttrValue = DimensionAttributeValue::findByDimensionAttributeAndEntityInst(dimAttr.RecId, financialTag.RecId, false, true);

    //Replace the required combination hash keys and other value arrays
    i = dimAttrIdx.lookup(OrgBackEntityType);
    valueKeyHashArray[i]    = dimAttrValue.HashKey;
    valueStrArray[i]        = dimAttributeProjTable.Value;
    valueKeyArray[i]        = dimAttrValue.RecId;

    //Calculate the hash for the current values
    hash = DimensionAttributeValueSetStorage::getHashFromArray(valueKeyHashArray, dimAttrCount);

    //Null hash indicates no values exist, which may occur if the user entered an invalid value for one dimension attribute
    if (hash == conNull())
    {
        throw error("Wrong value for Organization Dimension");
    }

    // Search for existing value set
    dimAttrValueSet = DimensionAttributeValueSet::findByHash(hash);

   // This value set does not exist, so it must be persisted
    if (!dimAttrValueSet)
    {
        ttsbegin;

        // Insert the value set with appropriate hash
        dimAttrValueSet.Hash = hash;
        dimAttrValueSet.insert();

        // Insert only specified set items use this
        for (i = 1; i <= dimAttrCount; i++)
        {
            if (valueKeyArray[i] != 0)
            {
                dimAttrValueSetItem.clear();
                dimAttrValueSetItem.DimensionAttributeValueSet = dimAttrValueSet.RecId;
                dimAttrValueSetItem.DimensionAttributeValue = valueKeyArray[i];
                dimAttrValueSetItem.DisplayValue = valueStrArray[i];
                dimAttrValueSetItem.insert();
            }
        }
        ttsCommit;

    }

    // Get the default account for main account
    mainAccDimension = DimensionStorage::getDefaultAccountForMainAccountNum(mainAccountValue);

    //Find or create the LedgerDimension record for required combination
    ledgerDimension = DimensionDefaultingService::serviceCreateLedgerDimension(
                                                            mainAccDimension,
                                                            dimAttrValueSet.RecId);

   // info(strFmt("Original %1: %2", targetDimension, DimensionAttributeValueCombination::find(targetDimension).DisplayValue));
    //info(strFmt("Replaced %1: %2", ledgerDimension, DimensionAttributeValueCombination::find(ledgerDimension).DisplayValue));
    return DimensionAttributeValueCombination::find(ledgerDimension);
}