Remove Space Bar and special Chaarcter while typing in Text field

// Remov Space Bar while typing in Text field

public void textChange()
{
    str text;
    int len;
    text = TextFIeld.valueStr();
    len = strLen(text);
 
    super();
    if(strLen(text) > 0)
    {      
        if(strnFind(text, " ",1,len) >= 0)
        {
            strdel(text,len-1,1);
            TextFIeld.text(text);
        }
    }
}

Currency Exchange through X++

Amount        costInCurrency;
currencyExchangeHelper = CurrencyExchangeHelper::construct();

    costInCurrency  = currencyExchangeHelper.calculateCurrencyToCurrency("USD" ,costingLine.CurrencyCode,costingLine.Cost,false);

Get Inventory Dimension From ItemID ... Site,warehouse,Config,Dimid

// Get Inventory Dimension From ItemID ... Site,warehouse,Config,Dimid

static void GetInventoryDimensions(Args _args)
{
    InventTable                 inventTable = inventTable::find('1005');
    InventItemOrderSetupType    setupType   = InventItemOrderSetupType::Invent;
    InventDim                   inventDim;
    ;

    inventDim.InventSiteId = inventTable.inventItemOrderSetupMap(setupType).inventSiteId(inventDim.InventSiteId, inventTable);
    inventDim.InventLocationId  = inventTable.inventItemOrderSetupMap(setupType,
                                                                      InventDim::findOrCreate(inventDim).InventDimId)
                                                                      .inventLocationId(inventDim.InventLocationId,
                                                                                        inventTable,
                                                                                        inventDim.InventSiteId);

    inventDim.ConfigId = inventTable.StandardConfigId;
    inventDim = InventDim::findOrCreate(inventDim);

    info(strFmt('Invent Dim. Id: %1', inventDim.inventDimId));
    info(strFmt('Site Id: %1', inventDim.InventSiteId));
    info(strFmt('Warehouse Id: %1', inventDim.InventLocationId));
}

Getting Dimension Values from LedgerDimension in Ax 2012

// Getting Dimension Values from LedgerDimension in Ax 2012

static void getDimensionValueFromLedgerDimension(Args _args)
{
DimensionAttribute                          dimensionAttributeTable;
DimensionAttributeValueGroupStatus          dimAttrValueGroupStatusTable;
DimensionAttributeValueGroupCombination     dimAttrValueGroupComboTable;
DimensionAttributeValueGroup                dimAttrValueGroupTable;
DimensionAttributeLevelValue                dimAttrLevelValueTable;
DimensionAttributeValue                     dimAttrValueTable;
DimensionAttrValueCOAOverride               dimAttrValueCOAOverrideTable;
DimensionAttrValueLedgerOverride            dimAttrValueLedgerOverrideTable;
DimensionFinancialTag                       dimensionFinancialTagTable;
InventPosting                               inventPostingTable;
DimensionValue                              Dimension1, Dimension2, Dimension3;
MainAccountNum                              LedgerAccount;
RecId                                       LedgerRecId, dimCombinationId;
dimCombinationId    = 5637144728; // for example here i gave a valid ledgerdimension
// find MainAccountId from LedgerDimension
LedgerAccount       = MainAccount::findByLedgerDimension(dimCombinationId).MainAccountId;
LedgerRecId         = Ledger::findLedgerRecIdByLegalEntity(CompanyInfo::findDataArea(curext()).RecId);
Dimension1 = “”;
Dimension2 = “”;
Dimension3 = “”;
while select Ordinal from dimAttrValueGroupComboTable order by Ordinal
where dimAttrValueGroupComboTable.DimensionAttributeValueCombination == dimCombinationId
join dimAttrValueGroupTable
where dimAttrValueGroupTable.RecId == dimAttrValueGroupComboTable.DimensionAttributeValueGroup
outer join dimAttrValueGroupStatusTable
where dimAttrValueGroupStatusTable.DimensionAttributeValueGroup == dimAttrValueGroupTable.RecId
join dimAttrLevelValueTable
where dimAttrLevelValueTable.DimensionAttributeValueGroup == dimAttrValueGroupTable.RecId
join pessimisticLock IsSuspended, IsTotal, ActiveFrom, ActiveTo, DimensionAttribute, RecId, EntityInstance from dimAttrValueTable
where dimAttrValueTable.RecId == dimAttrLevelValueTable.DimensionAttributeValue
outer join pessimisticLock IsSuspended, ActiveFrom, ActiveTo, RecId from dimAttrValueCOAOverrideTable
where dimAttrValueCOAOverrideTable.DimensionAttributeValue == dimAttrValueTable.RecId && dimAttrValueCOAOverrideTable.ChartOfAccounts == LedgerChartOfAccounts::current()
outer join pessimisticLock IsSuspended, ActiveFrom, ActiveTo, RecId from dimAttrValueLedgerOverrideTable
where dimAttrValueLedgerOverrideTable.DimensionAttributeValue == dimAttrValueTable.RecId && dimAttrValueLedgerOverrideTable.Ledger == LedgerRecId
{
dimensionFinancialTagTable = null;
select * from dimensionFinancialTagTable
where dimensionFinancialTagTable.RecId == dimAttrValueTable.EntityInstance
join dimensionAttributeTable
where dimensionAttributeTable.RecId == dimAttrValueTable.DimensionAttribute;
if (dimensionAttributeTable.Name == ‘Department’)
{
Dimension1 = dimensionFinancialTagTable.Value;
}
if (dimensionAttributeTable.Name == ‘CostCenter’)
{
Dimension2 = dimensionFinancialTagTable.Value;
}
if (dimensionAttributeTable.Name == ‘Purpose’)
{
Dimension3 = dimensionFinancialTagTable.Value;
}
}
info(strFmt(“%1     %2      %3?,Dimension1,Dimension2,Dimension3));
}

Getting Individual Dimension Combination Values–Dimension Storage class in ax 2012

//Getting Individual Dimension Combination Values–Dimension Storage class in ax 2012

static void getDimensionCombinationValues(Args _args)
{
    // DimensionAttributeValueCombination stores the combinations of dimension values
    // Any tables that uses dimension  combinations for main account and dimensions
    // Has a reference to this table’s recid
    DimensionAttributeValueCombination  dimAttrValueComb;
    //GeneralJournalAccountEntry is one such tables that refrences DimensionAttributeValueCombination
    GeneralJournalAccountEntry          gjAccEntry;
    // Class Dimension storage is used to store and manipulate the values of combination
    DimensionStorage        dimensionStorage;
    // Class DimensionStorageSegment will get specfic segments based on hierarchies
    DimensionStorageSegment segment;
    int                     segmentCount, segmentIndex;
    int                     hierarchyCount, hierarchyIndex;
    str                     segmentName, segmentDescription;
    SysDim                  segmentValue;
    ;

    //Get one record for demo purpose
    gjAccEntry = GeneralJournalAccountEntry::find(5637765403);

    setPrefix("Dimension values fetching");
    //Fetch the Value combination record
    dimAttrValueComb = DimensionAttributeValueCombination::find(gjAccEntry.LedgerDimension);
    setPrefix("Breakup for " + dimAttrValueComb.DisplayValue);

    // Get dimension storage
    dimensionStorage = DimensionStorage::findById(gjAccEntry.LedgerDimension);
    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++)
    {
        setPrefix(strFmt("Hierarchy: %1", DimensionHierarchy::find(dimensionStorage.getHierarchyId(hierarchyIndex)).Name));
        //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 segment name
                segmentName = DimensionAttribute::find(DimensionAttributeValue::find(segment.parmDimensionAttributeValueId()).DimensionAttribute).Name;
                //Get segment value (id of the dimension)
                segmentValue        = segment.parmDisplayValue();
                //Get segment value name (Description for dimension)
                segmentDescription  = segment.getName();
                info(strFmt("%1: %2, %3", segmentName, segmentValue, segmentDescription));
            }
        }
    }
}

Get Default Dimensions value For Vend Customer Item in ax 2012 through X++

// Get Default Dimensions value For Vend Cust Item

static void San_GetDefaultDimensionsForVendCustItem(Args _args)
{
    VendTable                       vendTable;
    InventTable                     inventTable;
    CustTable                       custTable;
    DimensionAttributeValueSet      dimAttrValueSet;
    DimensionAttributeValueSetItem  dimAttrValueSetItem;
    DimensionAttributeValue         dimAttrValue;
    DimensionAttribute              dimAttr;
    Common                          dimensionValueEntity;
    ;
    //vendTable = VendTable::find('3008');
    //inventTable = InventTable::find('1001');
    custTable = CustTable::find('1102');
    //dimAttrValueSet = DimensionAttributeValueSet::find(vendTable.DefaultDimension);
    //dimAttrValueSet = DimensionAttributeValueSet::find(inventTable.DefaultDimension);
    dimAttrValueSet = DimensionAttributeValueSet::find(custTable.DefaultDimension);
    while select dimAttrValueSetItem
        where   dimAttrValueSetItem.DimensionAttributeValueSet   == dimAttrValueSet.RecId
    {
        dimAttrValue        = DimensionAttributeValue::find(dimAttrValueSetItem.DimensionAttributeValue);
        dimAttr             = DimensionAttribute::find(dimAttrValue.DimensionAttribute);
        dimensionValueEntity = DimensionDefaultingControllerBase::findBackingEntityInstance(curext(),dimAttr,dimAttrValue.EntityInstance);
        info(dimAttr.Name + ' ' + dimAttrValue.getValue());
    }
}

Inventory OnHand Get through X++

real a;
    InventDimParm inventDimParm;
    inventDimParm.initFromInventDim(InventDim::find("00000492_069"));
    a =InventSumDatePhysicalDim::onHandQty(today(),"1001",InventDim::find("00000492_069"),inventDimParm);
    info(strfmt("%1",a));

Copy data from one dropped table to another

// Copy data from one dropped table to another
static void EmployeeDetailsCopyTableData(Args _args)
{
    EmployeeDetails      employeeDetails; // Table From Copying
    CopyOfEmployeeDetails copyOfEmployeeDetails; // Duplicated Table want to copy data from base table
    ;

    ttsBegin;
    // Clear the data from the copy table
    delete_from copyOfEmployeeDetails;

    while select employeeDetails
    {
        buf2Buf(employeeDetails, copyOfEmployeeDetails);
        copyOfEmployeeDetails.insert();
    }
 
    ttsCommit;
}

Position test in ax

//  Position test

static void PositionTest(Args _args)
{
    HierarchyPosition   hierarchyPosition;
    container           workerHirerchy;
    int                 i;
    int64               posi;
    str                 name;
    HcmWorker         worker;



    delete_from hierarchyPosition;
    RecursionPosition::postion(curUserId());
    while select hierarchyPosition //where currency.CurrencyCode like "E*"
    {
        workerHirerchy += hierarchyPosition.Position;
    }

    for(i=1;i<=conLen(workerHirerchy);i++)
    {
        posi = conPeek(workerHirerchy, i);
        worker = HcmWorker::find(posi);
        name   = strFmt("%1 ",worker.name());
        info(name);

    }
}

Journal Creation Method in Class

// Journal Creation Method in Class

private void JournalCreation( System.Data.SqlClient.SqlDataReader   dr1)
{

    NumberSequenceTable                 numberSequenceTable;

    Voucher                             voucher;
    Amount                              amountCurDebit,amountCurCredit;

    AxLedgerJournalTrans                trans  = new AxLedgerJournalTrans();
    AxLedgerJournalTable                header ;//= new AxLedgerJournalTable();

    str                                 description;
    str                                 Agreement,Category,Department,Division,Employee,ProductManagers,Project,Publisher,Region,Salesmen;

    DimensionStorage                    DimensionStorage;
    LedgerJournalNameId                 LedgerJournalNameId;
    CurrencyCode                        currencycode;
    TransDate                           TransDate = today();

    LedgerAccountContract               ledgerAccountContract,OffledgerAccountContract;
    MainAccountNum                      mainAccount;
    mainAccountNum                      OffmainAccount ;
    DimensionAttributeValueContract     attributeValueContract;

    LedgerJournalCheckPost              ledgerJournalCheckPost;

    ;

    ttsBegin;

    header = new AxLedgerJournalTable();
    LedgerJournalNameId = "GenJrn";
    header.parmJournalName(LedgerJournalNameId);

    header.save();

    numberSequenceTable = NumberSequenceTable::find(LedgerJournalName::find(LedgerJournalNameId).NumberSequenceTable);

    voucher =  NumberSeq::newGetVoucherFromId(numberSequenceTable.RecId).voucher();

    mainAccount     = dr1.get_Item('Account');
    OffmainAccount  = dr1.get_Item('OffsetAccount');

    amountCurDebit  = dr1.get_Item('Debit');
    amountCurCredit = dr1.get_Item('Credit');

    description  = dr1.get_Item('Txt');
    currencycode = dr1.get_Item('Currency');

    Employee        = dr1.get_Item('Dimension1');
    ProductManagers = dr1.get_Item('Dimension2');
    Project         = dr1.get_Item('Dimension3');
    Publisher       = dr1.get_Item('Dimension4');
    Region          = dr1.get_Item('Dimension5');

    trans.parmJournalNum(header.ledgerJournalTable().JournalNum);

    //AccountNum
    ledgerAccountContract = new LedgerAccountContract();
    ledgerAccountContract.parmValues(new List(Types::Class));

    ledgerAccountContract.parmMainAccount(mainAccount);
    if (Employee)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Employee");
        attributeValueContract.parmValue(Employee);

        ledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (ProductManagers)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("ProductManagers");
        attributeValueContract.parmValue(ProductManagers);

        ledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (Project)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Project");
        attributeValueContract.parmValue(Project);

        ledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (Publisher)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Publisher");
        attributeValueContract.parmValue(Publisher);

        ledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (Region)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Region");
        attributeValueContract.parmValue(Region);

        ledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }

    dimensionStorage = DimensionServiceProvider::buildDimensionStorageForLedgerAccount(ledgerAccountContract);

    trans.parmLedgerDimension(dimensionStorage.save());
    //-------------------------------------
    //OffsetAccount
    OffledgerAccountContract = new LedgerAccountContract();
    OffledgerAccountContract.parmValues(new List(Types::Class));
    Employee        = dr1.get_Item('Dimension1');
    ProductManagers = dr1.get_Item('Dimension2');
    Project         = dr1.get_Item('Dimension3');
    Publisher       = dr1.get_Item('Dimension4');
    Region          = dr1.get_Item('Dimension5');

    OffledgerAccountContract.parmMainAccount(OffmainAccount);
    if (Employee)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Employee");
        attributeValueContract.parmValue(Employee);

        OffledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (ProductManagers)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("ProductManagers");
        attributeValueContract.parmValue(ProductManagers);

        OffledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (Project)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Project");
        attributeValueContract.parmValue(Project);

        OffledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (Publisher)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Publisher");
        attributeValueContract.parmValue(Publisher);

        OffledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }
    if (Region)
    {
        attributeValueContract = new DimensionAttributeValueContract();
        attributeValueContract.parmName("Region");
        attributeValueContract.parmValue(Region);

        OffledgerAccountContract.parmValues().addEnd(attributeValueContract);
    }

    dimensionStorage = DimensionServiceProvider::buildDimensionStorageForLedgerAccount(OffledgerAccountContract);

    trans.parmOffsetLedgerDimension(dimensionStorage.save());
    //------------------------------------
    trans.parmTxt(description);

    trans.parmDocumentDate(today());
    trans.parmTransDate(today());

    trans.parmAmountCurDebit(AmountCurDebit);

    trans.parmAmountCurCredit(AmountCurCredit) ;

    trans.parmCompany(curext());
    trans.parmCurrencyCode(currencycode);
    trans.parmVoucher(voucher);
    trans.parmExchRate(1);
    trans.currentRecord().insert();

    trans.save();

    //ledgerJournalCheckPost= ledgerJournalCheckPost::newLedgerJournalTable(header.ledgerJournalTable(),NoYes::Yes);
    //ledgerJournalCheckPost.run();

    info(header.ledgerJournalTable().JournalNum);

    ttsCommit;

}