schweda.net - Blog

Filter über Finanzdimensionen in einer FormDataSource

heinz.schweda@schweda.net (Heinz Schweda) — Fri, 08 Mar 2019 18:18:00 +0100

Möchte man in einem Formular nur Datensätze einer Tabelle anzeigen, die bestimmte Finanzdimensionen enthalten, kann man dies über das überschreiben der init() der FormDataSource wie folgt erreichen:

public void init()
{
    super();
    
    SysQuery::addDimensionAttributeRange(salesTable_ds.query(),
                        salesTable_ds.name(),
                        fieldStr(Salestable, DefaultDimension),
                        DimensionComponent::DimensionAttribute,
                        '1001',
                        'CostCenter');    
}

Man kann addDimensionAttributeRange() auch mehrmals aufrufen, so kann man nach mehreren Dimensionen gleichzeitig filtern.

Mit clearDimensionRangesFromQuery() entfernt man solche Filter übrigens wieder:

SysQuery::clearDimensionRangesFromQuery(salesTable_ds.query())

AX 2012: Ändern einer Standardfinanzdimension (DefaultDimension) eines Datensatzes

heinz.schweda@schweda.net (Heinz Schweda) — Sat, 07 Feb 2015 17:06:00 +0100

Der nachstehende Job demonstriert, wie man den Wert einer Dimension (im Beispiel wird die Dimension Kostenstelle eines Debitors geändert) innerhalb der Standardfinanzdimensionen eines Datensatzes per Code austauschen kann. Auf diese Art & Weise können auch einzelne Dimensionswerte entfernt werden.

static void changeDimensionValue(Args _args)
{
    DimensionAttributeValueSetStorage dimensionAttributeValueSetStorage;
    DimensionAttribute dimensionAttribute;
    CustTable custTable = CustTable::find("US-014");
    DimensionValue oldDimensionValue;
    DimensionValue newDimensionValue = "011";
    DimensionDefault newDimensionDefault;

    #define.dimensionName("CostCenter")

    DimensionValue getDimensonValue(DimensionDefault _dimensionDefault)
    {
        DefaultDimensionView defaultDimensionView;
        select firstonly DisplayValue
        from defaultDimensionView
        where defaultDimensionView.Name == #dimensionName
            && defaultDimensionView.DefaultDimension == _dimensionDefault;

        return defaultDimensionView.DisplayValue;
    }

    // Get current value
    oldDimensionValue = getDimensonValue(custTable.DefaultDimension);

    // Build DimensionAttributeValueSetStorage
    dimensionAttributeValueSetStorage = DimensionAttributeValueSetStorage::find(custTable.DefaultDimension);
 
    // Remove old dimension value
    dimensionAttribute = DimensionAttribute::findByName(#dimensionName);
    dimensionAttributeValueSetStorage.removeDimensionAttributeValue(
        DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, oldDimensionValue).RecId);
 
    // Set new dimension value
    if(newDimensionValue != "")
    {
        dimensionAttribute = DimensionAttribute::findByName(#dimensionName);
        dimensionAttributeValueSetStorage.addItem(
            DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, newDimensionValue));
    }
 
    newDimensionDefault = dimensionAttributeValueSetStorage.save();

    ttsbegin;
    custTable.selectForUpdate(true);
    custTable.DefaultDimension = newDimensionDefault;
    custTable.update();
    ttscommit;
}

Screenshot vor der Änderung

Screenshot nach der Änderung

AX 2012: Erstellen einer DefaultDimension/LedgerDimension

heinz.schweda@schweda.net (Heinz Schweda) — Sun, 14 Dec 2014 09:29:00 +0100

Nachstehend ein Code-Beispiel, wie man eine RecId vom Typ DefaultDimension für mehrere Dimensionen generieren kann.
Anschließend wird diese DefaultDimension mit einem Hauptkonto zu einer RecId vom Typ LedgerDimension kombiniert.

static void buildDefaultAndLedgerDimension(Args _args)
{
    DimensionAttributeValueSetStorage dimensionAttributeValueSetStorage;
    DimensionAttribute dimensionAttribute;
    DimensionAttributeValue dimensionAttributeValue;
    DimensionDefault dimensionDefault;
    LedgerDimensionAccount ledgerDimensionAccount;

    dimensionAttributeValueSetStorage = new DimensionAttributeValueSetStorage();

    // BusinessUnit
    dimensionAttribute = DimensionAttribute::findByName('BusinessUnit');
    if(dimensionAttribute)
    {
        dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, '069', false, true);
        dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
    }

    // CostCenter
    dimensionAttribute = DimensionAttribute::findByName('CostCenter');
    if(dimensionAttribute)
    {
        dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, '010', false, true);
        dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
    }

    // Department
    dimensionAttribute = DimensionAttribute::findByName('Department');
    if(dimensionAttribute)
    {
        dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, '024', false, true);
        dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
    }
 
    dimensionDefault = dimensionAttributeValueSetStorage.save();

    // Merge main account and source dimension values and return RecId which can be used as ledgerDimension
    ledgerDimensionAccount = DimensionDefaultingService::serviceCreateLedgerDimension(DimensionStorage::getDefaultAccountForMainAccountNum("110110"),
                                                                                      dimensionDefault);

    info(strFmt("Default dimension recId: %1", dimensionDefault));
    info(strFmt("DefaultDimension (Source RecId): %1 LedgerDimension (Merged RecId): %2", dimensionDefault, ledgerDimensionAccount));
}

Notiz: Aufmerksamen Lesern ist sicherlich nicht entgangen, daß ich beides bereits in anderen Beiträgen geposted habe. Dieser Beitrag ist lediglich eine Kombination davon.

AX 2012: Anzeige-Wert einer LedgerDimension-RecId per Code ausgeben

heinz.schweda@schweda.net (Heinz Schweda) — Wed, 21 May 2014 21:40:00 +0200

Im Beispiel wird ein beliebiger Datensatz aus der LedgerJournalTrans selektiert und dessen Finanzdimensionen bzw. das Gegenkonto so ausgegeben, wie der Benutzer es im sog. Segmented Entry Control sieht.

static void GetLedgerDimensionDisplayValue(Args _args)
{
    DimensionStorage dimensionStorage;
    DimensionDisplayValue DimensionDisplayValue;
    ledgerJournalTrans ledgerJournalTrans = LedgerJournalTrans::findRecId(5637169330, false);
    
    // LedgerDimension
    dimensionStorage = DimensionStorage::findById(ledgerJournalTrans.LedgerDimension);
    DimensionDisplayValue = dimensionStorage.getComboDisplayValue();
    
    info(DimensionDisplayValue);   
     // OffsetLedgerDimension
    dimensionStorage = DimensionStorage::findById(ledgerJournalTrans.OffsetLedgerDimension);
    DimensionDisplayValue = dimensionStorage.getComboDisplayValue();
    
    info(DimensionDisplayValue);
}

Ergebnis beispielsweise:
5170-10-00AB03---1500-

AX 2012: LedgerDimension generieren III

heinz.schweda@schweda.net (Heinz Schweda) — Sun, 11 May 2014 12:14:00 +0200

Im folgenden ein kurzes Code-Snippet, welches zeigt wie man beispielsweise die Standard-Finanzdimensionen eines Debitoren mit einem Haupt-/Sachkonto zu einer RecId verbindet, welche beispielsweise als LedgerDimension in einer Sachkontenjournal-Zeile (Allgemeine Erfassung; LedgerJournalTrans.LedgerDimension) verwendet werden kann.

static void mergeDimensions_I(Args _args)
{
    LedgerDimensionAccount ledgerDimensionAccount;
    CustTable custTable;

    custTable = CustTable::find('‪‪‪2000');

    // Merge main account and source dimension values and return RecId which can be used as ledgerDimension
    ledgerDimensionAccount = DimensionDefaultingService::serviceCreateLedgerDimension(DimensionStorage::getDefaultAccountForMainAccountNum("4100"),
                                                                                      custTable.DefaultDimension);

    info(strFmt("DefaultDimension (Source RecId): %1 LedgerDimension (Merged RecId): %2", custTable.DefaultDimension, ledgerDimensionAccount));
}

AX 2012: Finanzdimension als Display-Methode anzeigen

heinz.schweda@schweda.net (Heinz Schweda) — Thu, 13 Feb 2014 21:40:00 +0100

Folgende Display-Methode in der Datasource einer Form zeigt beispielsweise die Finanzdimension Costcenter eines Debitoren an.

public display DimensionValue showCostCenter(CustTable _custTable)
{
    DimensionAttributeValueSet dimensionAttributeValueSet;
    DimensionAttributeValueSetItem dimensionAttributeValueSetItem;
    DimensionAttributeValue dimensionAttributeValue;
    DimensionAttribute dimensionAttribute;

    #define.CostCenterDimensionName("CostCenter");
 
    if( !_custTable || !_custTable.DefaultDimension)
    {
        return '';
    } 

    dimensionAttributeValueSet = DimensionAttributeValueSet::find(_custTable.DefaultDimension); 

    select firstOnly RecId
    from dimensionAttributeValueSetItem
        where dimensionAttributeValueSetItem.DimensionAttributeValueSet == dimensionAttributeValueSet.RecId
    join DimensionAttributeValue
        where DimensionAttributeValue.RecId == dimensionAttributeValueSetItem.DimensionAttributeValue
    join RecId from dimensionAttribute
    where dimensionAttribute.RecId == DimensionAttributeValue.DimensionAttribute
       && dimensionAttribute.Name  == #CostCenterDimensionName
    

    if(dimensionAttributeValue && dimensionAttribute)
    {
        return dimensionAttributeValue.getValue();
    }

    return '';
}

Einfachere Variante (siehe Kommentare)

public display DimensionValue showCostCenter(CustTable _custTable)
{
    #define.CostCenterDimensionName("CostCenter");
 
    return ((select firstOnly DisplayValue from DefaultDimensionView
             where DefaultDimensionView.Name == #CostCenterDimensionName
                && DefaultDimensionView.DefaultDimension == _custTable.DefaultDimension).DisplayValue);
}

AX 2012: Finanzdimension auf Basis einer Formulareingabe eintragen

heinz.schweda@schweda.net (Heinz Schweda) — Sat, 08 Feb 2014 18:09:00 +0100

Oftmals hat man die Anforderung, daß auf Basis einer Eingabe in einem Formular auch eine bestimmte Finanzdimension eingetragen werden soll.

Mit folgendem Code-Beispiel ist so etwas relativ einfach zu realisieren. Im Beispiel wird, wann immer ein bestimmtes Feld geändert wird - abgefragt über die Methode modified() des Feldes einer Datasource, die Finanzdimension Kostenstelle mit dem Wert 25 befüllt. Ist der einzutragende Wert ein ungültiger, passiert nichts (Fehlermeldung oder ähnliches).

public void modified()
{
    DimensionAttribute DimensionAttribute = DimensionAttribute::findByName("Kostenstelle");
    DimensionValue newValue = '25';    // New dimension value
    
    super();
    
    dimensionDefaultingController.setDimensionAttributeValue(
        DimensionAttribute, 
        DimensionAttributeValue::findByDimensionAttributeAndValue(DimensionAttribute, newValue).RecId, 
        newValue);
}

Im Beispiel wird eine existierende Instanz von DimensionDefaultingController verwendet.

AX 2012: Erstellen einer DefaultDimension mit mehreren Dimensionen

heinz.schweda@schweda.net (Heinz Schweda) — Sun, 10 Nov 2013 17:20:00 +0100

Nachstehend ein Code-Beispiel, wie man eine RecId vom Typ DefaultDimension für mehrere Dimensionen generieren kann.

Im Beispiel werden die Dimension Kostenstelle mit dem Wert "10", die Dimension Abteilung mit dem Wert "IT" und die Dimension Kategorie mit dem Wert "02" zu einer DefaultDimension kombiniert.

Durch den letzten Parameter von findByDimensionAttributeAndValue() wird sichergestellt, daß fehlende Dimensionen angelegt werden (soferne möglich).

static void buildDefaultDimension(Args _args)
{
    dimensionAttributeValueSetStorage dimensionAttributeValueSetStorage;
    dimensionAttribute dimensionAttribute;
    dimensionAttributeValue dimensionAttributeValue;
    dimensionDefault dimensionDefault;

    dimensionAttributeValueSetStorage = new DimensionAttributeValueSetStorage();

    // Kostenstelle
    dimensionAttribute = dimensionAttribute::findByName('Kostenstelle');
    if(dimensionAttribute)
    {
        dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, '10', false, true);
        dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
    }

    // Abteilung
    dimensionAttribute = dimensionAttribute::findByName('Abteilung');
    if(dimensionAttribute)
    {
        dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, 'IT', false, true);
        dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
    }

    // Kategorie
    dimensionAttribute = dimensionAttribute::findByName('Kategorie');
    if(dimensionAttribute)
    {
        dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, '02', false, true);
        dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
    }

    dimensionDefault = dimensionAttributeValueSetStorage.save();

    info(strFmt("Default dimension recId: %1", dimensionDefault));
}

AX 2012: LedgerDimension generieren II

heinz.schweda@schweda.net (Heinz Schweda) — Sun, 07 Jul 2013 18:41:00 +0200

Update 11.05.2014: Da die unten stehende Code-Beispiele nicht in allen Applikationen zu funktionieren scheinen, habe ich unter folgendem Beitrag ein weiteres Code-Beispiel veröffentlicht.

Im folgenden ein kurzes Code-Snippet, welches zeigt wie man beispielsweise Finanzdimensionen mit einem Haupt-/Sachkonto zu einer RecId verbindet, welche beispielsweise als LedgerDimension in einer Sachkontenjournal-Zeile (Allgemeine Erfassung; LedgerJournalTrans.LedgerDimension) verwendet werden kann.

static void mergeDimensions(Args _args)
{
    SalesLine salesLine;
    MainAccount mainAccount;
    LedgerDimensionAccount ledgerDimensionAccount;

    // Get source dimension values (for example from SalesLine-Record)
    select firstonly salesLine
    where salesLine.SalesId == "20001"
       && salesLine.DefaultDimension;

    // Get main account
    mainAccount = MainAccount::findByMainAccountId('0500');

    // Merge main account and source dimension values and return RecId which can be used as ledgerDimension
    ledgerDimensionAccount = DimensionDefaultingService::serviceCreateLedgerDimension(mainAccount.RecId, salesLine.DefaultDimension);

    info(strFmt("DefaultDimension (Source RecId): %1 LedgerDimension (Merged RecId): %2", salesLine.DefaultDimension, ledgerDimensionAccount));
}

Das zweite Snippet macht prinzipiell das selbe wie oben, allerdings wird hier statt einem Haupt-/Sachkonto ein Debitorenkonto verwendet.

AX 2012: LedgerDimension generieren

heinz.schweda@schweda.net (Heinz Schweda) — Wed, 12 Jun 2013 20:32:00 +0200

Die folgende Methode erstellt eine sog. LedgerDimension (EDT RecId) unter Verwendung des angebenen Hauptkontos und der angegebenen Finanzdimension.

static recid createLedgerDimensionRecId()
{
    AccountNum accountNum = '60000';
    str 255 dimensionValue = '300';
    Name DimensionName = 'Kostenstelle';
    
    MainAccount MainAccount;
    LedgerDimensionAccount LedgerDimensionAccount;
    DimensionAttributeValue DimensionAttributeValue;
    DimensionAttribute DimensionAttribute;
    dimensionAttributeValueSetStorage dimensionAttributeValueSetStorage;
    dimensionDefault dimensionDefault;
    
    DimensionAttribute = DimensionAttribute::findByName(DimensionName);
    if (dimensionValue)
    {
        DimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(DimensionAttribute, dimensionValue, false, true);
        if (!DimensionAttributeValue)
        {
            throw error(strFmt("@SYS24602", "@SYS13911", dimensionValue));
        }
    }    
    
    // Konto
    MainAccount = MainAccount::findByMainAccountId(accountNum);
    if(MainAccount)
    {
        LedgerDimensionAccount = DimensionDefaultingEngine::getLedgerDimensionFromAccountAndDim(
            MainAccount.RecId,
            DimensionHierarchy::getAccountStructure(MainAccount.RecId));

        if( !LedgerDimensionAccount)
        {
            throw error("LedgerDimensionAccount konnte nicht ermittelt werden.");
        }
    }
    // Konto und Dimension verbinden
    if (DimensionAttributeValue && LedgerDimensionAccount)
    {
        dimensionAttributeValueSetStorage = new DimensionAttributeValueSetStorage();
        if(dimensionAttribute)
        {
            dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, dimensionValue, false, true);
            dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
        }
         
        dimensionDefault = dimensionAttributeValueSetStorage.save();
        
        LedgerDimensionAccount =
        DimensionDefaultingService::serviceCreateLedgerDimension(LedgerDimensionAccount, dimensionDefault);
    }
    
    return LedgerDimensionAccount;
}

Wichtig: Die Methode prüft nicht, ob es die Dimension gibt, d.h. werden ungültige Werte für DimensionName oder DimensionValue angegeben, bricht die Methode mir einer Fehlermeldung ab.

AX 2012: Nützliche Funktionen rund um das Thema Finanzdimensionen

heinz.schweda@schweda.net (Heinz Schweda) — Tue, 16 Apr 2013 21:27:00 +0200

Wenn man in AX beispielsweise Finanzdimensionen aus einer externen Quelle verarbeiten soll, dann können die beiden folgenden Methoden möglicherweise hilfreich sein.

Die Erste Methode namens existDimension() prüft ob es die übergebene, benannte Dimension in AX überhaupt gibt und ob der übergebene Dimensionswert ebenfalls gültig ist.

boolean existDimension(str 255 _dimensionName, str 255 _dimensionValue)
{
    boolean isValid = false;
    DimensionAttribute DimensionAttribute;
    DimensionAttributeValue DimensionAttributeValue;

    DimensionAttribute = DimensionAttribute::findByName(_dimensionName);

    if(DimensionAttribute)
    {
        DimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(DimensionAttribute, _dimensionValue);

        if(DimensionAttributeValue)
        {
            isValid = true;
        }
        else
        {
            isValid = checkFailed(strFmt("'%1' für Dimension '%2' nicht gefunden.", _dimensionValue, _dimensionName));
        }
    }
    else
    {
        isValid = checkFailed(strFmt("Dimension '%1' unbekannt.", _dimensionName));
    }
    return isValid;
}

Beispielaufruf: existDimension("Costcenter", "3100");

Die Zweite Methode namens existDimensionCombination() prüft, ob die Kombination des übergebenen Hauptkontos und des übergebenen Dimensionswertes gültig ist.

boolean existDimensionCombination(str 255 _mainAccount, str 255 _dimensionName, str 255_dimensionValue)
{
    boolean isValid = false;
    FinancialDimensionValidationService FinancialDimensionValidationService;
    ledgerAccountValidationContract ledgerAccountValidationContract;
    ledgerAccountContract ledgerAccountContract;
    dimensionAttributeValueContract dimensionAttributeValueContract;

    FinancialDimensionValidationService = new FinancialDimensionValidationService();

    ledgerAccountValidationContract = new LedgerAccountValidationContract();
    ledgerAccountContract = new LedgerAccountContract();
    dimensionAttributeValueContract = new DimensionAttributeValueContract();
    ledgerAccountContract.parmMainAccount(_mainAccount);
    ledgerAccountContract.parmValues(new List(Types::Class));
    dimensionAttributeValueContract.parmName(_dimensionName);
    dimensionAttributeValueContract.parmValue(_dimensionValue);
    ledgerAccountContract.parmValues().addEnd(dimensionAttributeValueContract);
    ledgerAccountValidationContract.parmLedgerAccount(ledgerAccountContract);

    isValid = FinancialDimensionValidationService.validateLedgerAccount(ledgerAccountValidationContract);

    if( !isValid)
    {
        error(strFmt("Ungültige Kombination: %1 - %2: %3", _mainAccount, _dimensionName, _dimensionValue));
    }

    return isValid;
}

Beispielaufruf: existDimensionCombination("60000", "Costcenter", "3100");

In der realen AX-Entwickler-Welt wird eine solche Prüfung vermutlich etwas komplexer werden und wahrscheinlich auch eine Kombination beider Methoden notwendig sein.

AX 2012: Standardfinanzdimension eines Datensatzes setzen

heinz.schweda@schweda.net (Heinz Schweda) — Sat, 19 May 2012 10:55:00 +0200

Der nachstehende Code soll zeigen, wie man in Dynamics AX 2012 bei einem Datensatz - im Beispiel handelt es sich um einen Debitor - die Standardfinanzdimensionen per X++ befüllen kann.

Im Beispiel werden mehrere Dimensionen mit Werten befüllt. Bitte beachtet, daß die angeführten Dimensionen möglicherweise in Euren AX-Installationen nicht vorhanden sind.

static void setDefaultDimension4CustTable(Args _args)
{
    CustTable custTable;

    RecId getDefaultDimension(container _c)
    {
        DimensionAttribute dimensionAttribute;
        DimensionAttributeValue dimensionAttributeValue;
        DimensionAttributeValueSetStorage dimensionAttributeValueSetStorage;
        int i;
        container dimensionCon;
        Name dimensionName;
        str 255 dimensionValue;

        dimensionAttributeValueSetStorage = new DimensionAttributeValueSetStorage();

        for (i=1;i<=conLen(_c);i++)
        {
            dimensionCon = conPeek(_c, i);

            dimensionName = conPeek(dimensionCon, 1);
            dimensionValue = conPeek(dimensionCon, 2);

            select dimensionAttribute
            where dimensionAttribute.Name == dimensionName;

            if(dimensionAttribute)
            {
                dimensionAttributeValue = DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, dimensionValue, false, true);
                dimensionAttributeValueSetStorage.addItem(dimensionAttributeValue);
            }
        }

        return dimensionAttributeValueSetStorage.save();
    }
    ;

    try
    {
        ttsbegin;
        custTable = CustTable::find('9101', true);
        custTable.DefaultDimension =
            getDefaultDimension([
                                    ["Department",      '100'],
                                    ["Debitor",         '3010'],
                                    ["CustomerGroup",   '80'],
                                    ["ParentProject",   '2000'],
                                    ["CostCenter",      '07']
                                ]);

        custTable.update();
        ttscommit;

        info("Update custtable.defaultDimension sucessfull.");
    }
    catch
    {
        throw error("Error occured");
    }
}

AX 2012: Standardfinanzdimension eines Datensatzes auslesen und Inhalt prüfen

heinz.schweda@schweda.net (Heinz Schweda) — Wed, 16 May 2012 21:22:00 +0200

Der folgende Job demonstriert, wie man den Inhalt der Standardfinanzdimensionen eines Datensatzes - im Beispiel jene eines Debitoren - per X++ prüft.

Im Beispiel werden die Dimensionen namens CustomerGroup, Debitor und NonExistingDimension als zu prüfen angegeben. Bitte beachtet, daß nicht alle Dimensionen in jeder AX-Instanz vorhanden sind. Vor allem letztere dient lediglich zur Demonstration, wie sich der Code verhält, wenn eine Dimensionen ausgelesen werden soll, die es gar nicht gibt.

static void validateDefaultDimensionValues(Args _args)
{
    CustTable custTable = CustTable::find('9101', true);
    container validateCon;
    container helpCon;
    int ii;

    container getDimensionValue(RecId _dimensionAttributeValueSetRecId, container _c)
    {
        DimensionAttributeValueSetItem dimensionAttributeValueSetItem;
        DimensionAttributeValue dimensionAttributeValue;
        DimensionAttribute dimensionAttribute;
        Common dimensionValueEntity;
        int i;
        Name dimensionName;
        str 255 dimensionValue;
        container retCon;

        for (i=1;i<=conLen(_c);i++)
        {
            dimensionName = conPeek(_c, i);

            if( !DimensionAttribute::findByName(dimensionName))
                error(strFmt("Dimension %1 not found", dimensionName));

            while select dimensionAttributeValueSetItem
                where   dimensionAttributeValueSetItem.DimensionAttributeValueSet   == _dimensionAttributeValueSetRecId
            {
                // Find the dimension 'value' (DimensionAttributeValue) that the set item points to.
                dimensionAttributeValue = DimensionAttributeValue::find(dimensionAttributeValueSetItem.DimensionAttributeValue);

                // Find the underlying attribute.
                dimensionAttribute = DimensionAttribute::find(dimensionAttributeValue.DimensionAttribute);

                // Use the helper class to obtain a reference to the underlying entity (can be anything)
                dimensionValueEntity = DimensionDefaultingControllerBase::findBackingEntityInstance(
                    curext(),
                    dimensionAttribute,
                    dimensionAttributeValue.EntityInstance);

                if(dimensionAttribute.Name == dimensionName)
                {
                    retCon = conIns(retCon, conLen(retCon)+1, [dimensionAttribute.Name, dimensionAttributeValue.getValue()]);
                }
            }
        }

        return retCon;
    }
    ;

    validateCon = getDimensionValue(custTable.DefaultDimension, ["CustomerGroup", "Debitor", "NonExistingDimension"]);
    for (ii=1;ii<=conLen(validateCon);ii++)
    {
        helpCon = conPeek(validateCon, ii);

        if(conPeek(helpCon, 1) == "CustomerGroup" && conPeek(helpCon, 2) != custTable.CustGroup)
        {
            warning(strFmt("Dimension %1 should be %2.", conPeek(helpCon, 1), conPeek(helpCon, 2)));
        }
        if(conPeek(helpCon, 1) == "Debitor" && conPeek(helpCon, 2) != custTable.AccountNum)
        {
            warning(strFmt("Dimension %1 should be %2.", conPeek(helpCon, 1), conPeek(helpCon, 2)));
        }
        if(conPeek(helpCon, 1) == "NonExistingDimension" && conPeek(helpCon, 2) != custTable.AccountNum)
        {
            warning(strFmt("Dimension %1 should be %2.", conPeek(helpCon, 1), conPeek(helpCon, 2)));
        }
    }
}

AX 2012: Benutzerdefinierte Finanzdimension anlegen

heinz.schweda@schweda.net (Heinz Schweda) — Mon, 14 May 2012 12:53:00 +0200

MIt Hilfe des folgenden Jobs kann in Dynamics AX 2012 ein neuer Eintrag für eine benutzerdefinierte Finanzdimension erstellt werden. Im Beispiel ist der Name der Dimension ParentProject und der einzufügende Wert ist 4600.

static void createCustomDimensionValue(Args _args)
{
    DimensionValueService dimensionValueService;
    DimensionValueContract dimensionValueContract;

    dimensionValueService = new DimensionValueService();
    dimensionValueContract = new DimensionValueContract();
    dimensionValueContract.parmDescription('Project 4500');
    dimensionValueContract.parmValue('4600');
    dimensionValueContract.parmDimensionAttribute('ParentProject');
    if(dimensionValueService.createDimensionValue(dimensionValueContract))
    {
        info(strFmt("Dimension value %1 for dimension %2 created", dimensionValueContract.parmValue(), dimensionValueContract.parmDimensionAttribute()));
    }
}

AX 2012: Werte einer Finanzdimension auslesen

heinz.schweda@schweda.net (Heinz Schweda) — Sun, 13 May 2012 20:45:00 +0200

Der folgende Job demonstriert, wie man sich die Werte einer Finanzdimension - im Beispiel Department - per X++ ausgeben lassen kann.

static void getValues4Dimension(Args _args)
{
    DimensionValueService dimensionValueService;
    DimensionContract dimensionContract;
    List dimensionValueContractList;
    ListEnumerator listEnumerator ;
    DimensionValueContract dimensionValueContract;
    DimensionValue dimensionValue;

    dimensionValueService = new DimensionValueService();
    dimensionContract = new DimensionContract();
    dimensionContract.parmDimensionName('Department');
    dimensionValueContractList = dimensionValueService.getDimensionValues(dimensionContract);
    listEnumerator = dimensionValueContractList.getEnumerator();

    setPrefix(strFmt("Dimension %1: ", dimensionContract.parmDimensionName()));
    while(listEnumerator.moveNext())
    {
        dimensionValueContract = listEnumerator.current();
        dimensionValue = dimensionValueContract.parmValue();

        info(dimensionValue);
    }
}

AX 2012: Kontostruktur eines Hauptkontos ermitteln

heinz.schweda@schweda.net (Heinz Schweda) — Fri, 11 May 2012 11:02:00 +0200

Möchte man für das Hauptkonto einer Position einer Allgemeinen Erfassung ermitteln, kann man dies mit Hilfe des nachstehenden Codes tun.

static void getAccountStructureFromLedgerDimension(Args _args)
{
    ledgerJournalTrans ledgerJournalTrans;

    select ledgerJournalTrans
        where ledgerJournalTrans.JournalNum == '000151_010';

    info(DimensionStorage::getAccountStructureFromLedgerDimension(ledgerJournalTrans.LedgerDimension).Name);
}

AX 2012: Standardfinanzdimension eines Datensatzes auslesen und ausgeben

heinz.schweda@schweda.net (Heinz Schweda) — Wed, 09 May 2012 20:00:00 +0200

Im folgenden Job werden die eingetragenen Standardfinanzdimensionen eines Datensatzes - im konkreten Fall die eines bestimmten Debitoren - ausgegeben.

static void getDimensionsFromDefaultDimension(Args _args)
{
    DimensionAttributeValueSet dimensionAttributeValueSet;
    DimensionAttributeValueSetItem dimensionAttributeValueSetItem;
    DimensionAttributeValue dimensionAttributeValue;
    DimensionAttribute dimensionAttribute;
    Common dimensionValueEntity;

    dimensionAttributeValueSet = DimensionAttributeValueSet::find(CustTable::find('9101').DefaultDimension);

    // Find all of the 'value set items' linked against the 'value set'
    while select dimensionAttributeValueSetItem
        where   dimensionAttributeValueSetItem.DimensionAttributeValueSet == dimensionAttributeValueSet.RecId
    {
        // Find the dimension 'value' (DimensionAttributeValue) that the set item points to.
        dimensionAttributeValue = DimensionAttributeValue::find(dimensionAttributeValueSetItem.DimensionAttributeValue);

        // Find the underlying attribute.
        dimensionAttribute = DimensionAttribute::find(dimensionAttributeValue.DimensionAttribute);

        // Use the helper class to obtain a reference to the underlying entity (can be anything)
        dimensionValueEntity = DimensionDefaultingControllerBase::findBackingEntityInstance(
            curext(),
            dimensionAttribute,
            dimensionAttributeValue.EntityInstance);

        info(strFmt("%1: %2", dimensionAttribute.Name, dimensionAttributeValue.getValue()));
    }
}

AX 2012: Dimensionen einer Position einer Allgemeines Erfassung per X++ auslesen

heinz.schweda@schweda.net (Heinz Schweda) — Wed, 09 May 2012 09:28:00 +0200

Wenn man bei einer Position einer Allgemeinen Erfassung, welche gegen ein Sachkonto/Hauptkonto bucht, per X++ die eingetragenen Dimensionen auslesen möchte, kann der folgende Code möglicherweise hilfreich sein.

AX 2012: Datensätze mit einer bestimmten Dimension ausgeben

heinz.schweda@schweda.net (Heinz Schweda) — Tue, 08 May 2012 18:06:00 +0200

Der folgende Job listet alle Debitoren auf, bei welchen in der Dimension CustomerGroup der Wert 80 eingetragen ist.

Der interessante Teil des Jobs ist die Methode addDimensionAttributeRange der Klasse SysQuery, da diese sich um das Verknüpfen der benötigten Datenquellen kümmert.

static void getRecords4DimensionValue(Args _args)
{
    Query query;
    QueryBuildDataSource queryBuildDataSource;
    QueryBuildRange queryBuildRange;
    QueryRun queryRun;
    CustTable custTable;

    query = new Query();
    queryBuildDataSource = query.addDataSource(tableNum(CustTable));

    queryBuildRange = SysQuery::addDimensionAttributeRange( query,
                                                            queryBuildDataSource.name(),
                                                            "DefaultDimension",
                                                            DimensionComponent::DimensionAttribute,
                                                            queryValue("80"),
                                                            "CustomerGroup");

    queryRun = new QueryRun(query);
    while(queryRun.next())
    {
        custTable = queryRun.get(tableNum(CustTable));

        info(custTable.name());
    }
}

Die Klasse SysQuery stellt übrigens zahlreiche weitere ähnliche Funktionen zur Verfügung, um mit Dimensionswerten zu arbeiten.