sumitsaxfactor: Replacing Financial Dimension in Ledger Dimension

[Blog bot]

Источник: http://sumitsaxfactor.wordpress.com/...ger-dimension/
==============

Replacing a financial dimension in a Ledger dimension is not straight forward as the replacing of a dimension in Default dimensions. For default dimensions, we had a method serviceReplaceAttributeValue to replace one particular dimension. But for a ledger dimension, we need to do the following:

static void replaceLedgerDimensions(Args _args)
{
    #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; // 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
    DimAttributeHcmWorker           dimAttrWorker; //Backing entity view for Employee type dimension
    DimensionEnumeration            dimensionSetId; //Record id for table that contains active dimensions for current ledger
    LedgerDimensionAccount          targetDimension = 5637145829; //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
 
    int     segmentCount, segmentIndex;
    int     hierarchyCount, hierarchyIndex;
    SysDim  segmentValue, mainAccountValue;
    int     dimAttrCount, i;
    int     emplBackEntityType; //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;
    ;
 
    //The employee backing entity will be the view DimAttributeHcmWorker
    emplBackEntityType = tableNum(DimAttributeHcmWorker);
 
    //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;
 
                if (backingEntityInstance == tableNum(DimAttributeMainAccount))
                    mainAccountValue = segment.parmDisplayValue();
 
                //Default the required arrays
                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();
    dimAttr = DimensionAttribute::find(dimAttrRecId.lookup(emplBackEntityType));
 
    //Get the backing entity type for the dimension value to process
    select firstOnly dimAttrWorker
        where dimAttrWorker.Value == "51011";
 
    //Find the required Dimension Attribute Value record
    //Create if necessary
    dimAttrValue = DimensionAttributeValue::findByDimensionAttributeAndEntityInst(dimAttr.RecId, dimAttrWorker.RecId, false, true);
 
    //Replace the required combination hash keys and other value arrays
    i = dimAttrIdx.lookup(emplBackEntityType);
    valueKeyHashArray[i]    = dimAttrValue.HashKey;
    valueStrArray[i]        = dimAttrWorker.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 Employee 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));
 
}

Here is the output: