spilt string on unique symbol x++

class StringSplitTest
{       
    public static void main(Args _args)
    {
        str             string                  =   "555551-004-023-00000010-Application Development";
        str             stringwithEmptyvalue    =   "555551--00000010--";
        List            splittedString          =   strSplit(string, '-');
        ListIterator    listIterator;

        listIterator  =   new ListIterator(splittedString);

        while(listIterator.more())
        {
            info(strFmt("%1", listIterator.value()));
            listIterator.next();
        }
    }

}

to change dimension order x++

private container getProjDimension(ProjId _projId)
    {
        DimensionAttributeValueSetStorage   dimStorage;
        Str                                 displayValue, dimensionName;
        ProjTable                           projTable   =   ProjTable::find(_projId);
        Map                                 dimMap = new Map(Types::String, Types::String);
        MapEnumerator                       mapEnum;
        Counter                             i;
        INTC_DimensionPatternTable          dimensionPatternTable;
        container                           dimContainer;

   
        dimStorage = DimensionAttributeValueSetStorage::find(projTable.DefaultDimension);
 
        for (i= 1 ; i<= dimStorage.elements() ; i++)
        {
            dimensionName   = DimensionAttribute::find(dimStorage.getAttributeByIndex(i)).Name;
            displayValue    = dimStorage.getDisplayValueByIndex(i);

            if(dimensionName    ==  "BusinessUnit")
            {
                dimMap.insert(dimensionName, displayValue);
            }
            if(dimensionName    ==  "Department")
            {
                dimMap.insert(dimensionName, displayValue);
            }
            if(dimensionName    ==  "Project")
            {
                dimMap.insert(dimensionName, displayValue);
            }
            if(dimensionName    ==  "ServiceLine")
            {
                dimMap.insert(dimensionName, displayValue);
            }
           
        }
        delete_from dimensionPatternTable;
        mapEnum = dimMap.getEnumerator();
        while(mapEnum.moveNext())
        {
            str             dimName, dimValue;
            boolean         dimNameValid;

            dimName      =  mapEnum.currentKey();
            dimValue     =  mapEnum.currentValue();

            dimensionPatternTable.DimName   =   dimName;
            dimensionPatternTable.DimValue  =   dimValue;
            dimensionPatternTable.insert();
        }

        while select dimensionPatternTable order by RecId desc
        {
            dimContainer =  conIns(dimContainer, 1, dimensionPatternTable.DimValue);
        }
        return dimContainer;
    }

default dimension to ledger dimension x++

class INTC_GenerateDimension
{
    public DimensionDefault generateDefaultDimension(container _conAttr, container _value, boolean _createIfNotFound = true)
    {
        DimenSionAttributevalueSetStorage       valueSetStorage =   new DimenSionAttributevalueSetStorage();
        DimensionDefault                        result;
        DimensionAttribute                      dimensionAttribute;
        DimensionAttributeValue                 dimensionAttributeValue;
        container                               conAttr     =   _conAttr;
        container                               conValue    =   _value;
        str                                     dimValue;
        int i;

        for(i=1; i<=conLen(conAttr); i++)
        {
            dimensionAttribute  =   DimensionAttribute::findByName(conPeek(conAttr, i));

            if(dimensionAttribute.RecId ==0)
            {
                continue;
            }
            dimValue    =   conPeek(conValue, i);

            if(dimValue != "")
            {
                dimensionAttributeValue =   DimensionAttributeValue::findByDimensionAttributeAndValue(dimensionAttribute, dimValue, false, _createIfNotFound);
                valueSetStorage.addItem(dimensionAttributeValue);
            }
        }
        result  =   valueSetStorage.save();
        return  result;
    }

    public void dimPattern()
    {
        container                               attrCon, valueCon;
        DimensionDefault                        defaultDimensionRecId, ledDimRecId, finLedgerDimValue;
        DimensionAttributeValueCombination      dimensionAttributeValueCombination;
        attrCon     =   ["BusinessUnit", "Department", "Project", "ServiceLine"];
        valueCon    =   ["004", "023", "00000007", "Application Development"];

        defaultDimensionRecId   =   this.generateDefaultDimension(attrCon, valueCon);
        MainAccount mainAccount =   MainAccount::findByMainAccountId("555551");
        ledDimRecId =   LedgerDefaultAccountHelper::getDefaultAccountFromMainAccountId("555551");
        int64   offsetDim     =  LedgerJournalName::find("GenJrn").OffsetLedgerDimension;
        int64   offseDimRecId =  LedgerDefaultAccountHelper::getDefaultAccountFromLedgerDimension(offsetDim);
        finLedgerDimValue   =   LedgerDimensionFacade::serviceCreateLedgerDimension(ledDimRecId, defaultDimensionRecId);

        info(strFmt("Ledger dimension : %1", finLedgerDimValue));

       

        select dimensionAttributeValueCombination where dimensionAttributeValueCombination.RecId    ==  finLedgerDimValue;

        info(strFmt("Display value : %1", dimensionAttributeValueCombination.DisplayValue));
    }

    public static void Main(Args _args)
    {
        INTC_GenerateDimension      generateDimension   = new INTC_GenerateDimension();
        generateDimension.dimPattern();
    }

}

dimension display value x++

bankAccountId   =   DimensionAttributeValueCombination::find(ledgerJournalTrans.OffsetLedgerDimension).DisplayValue;
Vendor =   DimensionAttributeValueCombination::find(ledgerJournalTrans.LedgerDimension).DisplayValue;

to get ledger calendar period status

public boolean validateLedgerPeriod(TransDate _accountingDate)
        {
            FiscalCalendarPeriod    fiscalCalendarPeriod;
            RecId                   calendarRecId;
            AccountingDate          updatedAccountingDate;
            boolean                 isOpen;
   
            calendarRecId = Ledger::fiscalCalendar(CompanyInfo::current());
            fiscalCalendarPeriod = LedgerFiscalCalendar::findPeriodByPeriodCodeDate(calendarRecId, _accountingDate, FiscalPeriodType::Operating);
   
            if (fiscalCalendarPeriod.currentLedgerPeriodStatus() == FiscalPeriodStatus::Open)
            {
                isOpen  =   true;
            }
            return isOpen;
        }