CustPackingSlipJour custPackingSlipJour; 
    InventJournalTable inventJournalTable;
    InventJournalTrans inventJournalTrans;
    InventJournalTableData journalTableData;
    InventJournalTransData journalTransData;

    /// <summary>
    /// Create Inventory journal header record
    /// </summary>
    /// <param name = "_throwOnError">throw on error (Y/N)?</param>
    /// <returns>true is record has been created, false if it already exists</returns>
    protected boolean createInventJournalTable(boolean _throwOnError = true)
    {
        boolean ret = true;

        if (inventJournalTable.RecId != 0)
        {
            return ret;
        }

        journalTableData = JournalTableData::newTable(inventJournalTable);

        // Init JournalTable
        inventJournalTable.clear();

        inventJournalTable.JournalId = journalTableData.nextJournalId();
        inventJournalTable.JournalType = InventJournalType::LossProfit;
        inventJournalTable.JournalNameId = InventParameters::find().VKJournalNameId;
        inventJournalTable.VKRefDeliveryNote = custPackingSlipJour.InternalPackingSlipId;
        inventJournalTable.VKRefSourceDocumentHeader = custPackingSlipJour.SourceDocumentHeader;  // unique ref

        journalTableData.initFromJournalName(journalTableData.journalStatic().findJournalName(inventJournalTable.JournalNameId));

        inventJournalTable.DeletePostedLines = NoYes::No;

        if (inventJournalTable.validateWrite())
        {
            inventJournalTable.insert();
        }
        else
        {
            ret = false;
            if (_throwOnError)
            {
                throw Error("@SYS93289");
            } 
        }
        return ret;
    }

    /// <summary>
    /// Create Inventory journal line records
    /// </summary>
    /// <returns>true if records have been created, exception is thrown otherwise</returns>
    protected boolean createInventJournalTrans()
    {
        boolean ret = true;

        if (!inventJournalTable)
        {
            this.createInventJournalTable();
        }

        CustPackingSlipTrans custPackingSlipTrans;

        while select custPackingSlipTrans
            where custPackingSlipTrans.SalesId == custPackingSlipJour.SalesId
            && custPackingSlipTrans.PackingSlipId == custPackingSlipJour.PackingSlipId
            && custPackingSlipTrans.DeliveryDate  == custPackingSlipJour.DeliveryDate
        {
            
            inventJournalTrans.clear();
            
            journalTransData = journalTableData.journalStatic().newJournalTransData(inventJournalTrans, journalTableData);

            if (inventJournalTable.NumOfLines)
            {
                journalTransData.parmLastLineNum(inventJournalTable.NumOfLines);
            }
            journalTransData.initFromJournalTable();

            inventJournalTrans.TransDate    = DateTimeUtil::getSystemDate(DateTimeUtil::getUserPreferredTimeZone());
            inventJournalTrans.ItemId       = custPackingSlipTrans.ItemId;

            inventJournalTrans.VKOrigRefRecId  = custPackingSlipTrans.RecId;

            inventJournalTrans.Qty                          = 0;
            if (PdsGlobal::pdsIsCWItem(inventJournalTrans.ItemId)
			{
				inventJournalTrans.pdsCWQty                 = 0;
			}

            // standard unit qty
            inventJournalTrans.UnitQty  = 0; // synced by default with 0 Qty
            inventJournalTrans.Unit     = custPackingSlipTrans.SalesUnit;

            InventTransOrigin   inventTransOrigin;
            InventTrans inventTrans;
            select firstonly RecId from inventTransOrigin
                where inventTransOrigin.InventTransId == custPackingSlipTrans.InventTransId
                join InventDimId from inventTrans
                where inventTrans.inventTransOrigin == inventTransOrigin.RecId
                && inventTrans.PackingSlipId == custPackingSlipJour.PackingSlipId;

            inventJournalTrans.InventDimId = inventTrans.InventDimId;
            inventJournalTrans.setCostPrice(inventJournalTrans.InventDimId);            
            inventJournalTrans.DefaultDimension = custPackingSlipTrans.DefaultDimension;

            journalTransData.create();
        }

        return ret;
    }

        InventTransferVoucherId voucherId = '';
        if (inventTransferTable)
        {
            InventTransferUpdShip   shipUpdate;
            InventTransferParmTable inventTransferParmTable;

            InventTransferTable.selectForUpdate(true);
            InventTransferTable.ReceiveDate         = intTransferReceiptStaging.ReceiveDate;
            InventTransferTable.update();

            inventTransferParmTable.initParmDefault();
        
            inventTransferParmTable.TransferId      = inventTransferTable.TransferId;
            inventTransferParmTable.ShipUpdateQty   = InventTransferShipUpdateQty::PickedQty;
            inventTransferParmTable.EditLines       = NoYes::Yes;
            inventTransferParmTable.TransDate       = intTransferReceiptStaging.ReceiveDate;
            inventTransferParmTable.AutoReceiveQty  = NoYes::Yes;
        
            shipUpdate = InventTransferUpdShip::newParmBuffer(inventTransferParmTable);
            shipUpdate.run();

            if (shipUpdate.parmIsSomeThingPosted())
            {
                InventTransferJour  inventTransferJour = shipUpdate.parmInventTransferJour();
                voucherId = inventTransferJour.VoucherId;
            }

    void cancelPreviousPicks(SalesId _salesId)
    {
        SalesLine           salesLine;
        wmsOrderTrans       wmsOrderTrans,
                            wmsOrderTransNew;
        InventTrans         inventTransCancel;
        InventTransOrigin   inventTransOriginCancel;

        // select forupdate is required by standard unpick logic
        while select forupdate wmsOrderTrans
            //join inventTransferLine
            //    where inventTransferLine.TransferId == _transferId
            join salesLine
                where salesLine.SalesId             == _salesId
                    &&wmsOrderTrans.inventTransId   == salesLine.InventTransId
                    &&wmsOrderTrans.expeditionStatus== WMSExpeditionStatus::Complete
        {

            select sum(qty), sum(PdsCWQty)
                from inventTransCancel
                join inventTransOriginCancel
                    where  inventTransOriginCancel.InventTransId    == wmsOrderTrans.inventTransId
                        && inventTransOriginCancel.RecId            == inventTransCancel.inventTransOrigin
                        && InventTransCancel.StatusIssue            == statusIssue::Picked
                        && InventTransCancel.PickingRouteID         == wmsOrderTrans.RouteId;

            // Unpick previous picks if not delivered
            if (abs(InventTransCancel.qty) >= wmsOrderTrans.qty)
            {
                wmsOrderTrans.wmsOrderTransType().unPick(
                    wmsOrderTrans.qty,
                    wmsOrderTrans.inventDim(),
                    NoYes::Yes,
                    wmsOrderTrans.PdsCWQty
                );
            }
            // If there is delivered quantity then unpick as much as possible that has not been delivered
            else if (InventTransCancel.qty < 0  && abs(InventTransCancel.qty) < wmsOrderTrans.qty)
            {
                wmsOrderTransNew = wmsOrderTrans.split(abs(InventTransCancel.qty), abs(InventTransCancel.PdsCWQty));
                wmsOrderTransNew.wmsOrderTransType().unPick(
                    abs(InventTransCancel.qty),
                    wmsOrderTrans.inventDim(),
                    NoYes::Yes,
                    wmsOrderTrans.PdsCWQty
                );
            }
        }
    }

        InventTransferParmTable inventTransferParmTable;
        InventTransferUpdPick   inventTransferUpdPick;
        ParmId                  parmId = RunBaseMultiParm::getSysParmId();
    
        inventTransferParmTable.clear();
        inventTransferParmTable.initParmDefault();
    
        inventTransferParmTable.ParmId                      = parmId;
        inventTransferParmTable.TransferId                  = _transferId;
        inventTransferParmTable.UpdateType                  = InventTransferUpdateType::PickingList;
        inventTransferParmTable.PickUpdateQty               = InventTransferPickUpdateQty::All;
        inventTransferParmTable.EditLines                   = NoYes::Yes;
        inventTransferParmTable.PrintTransferPickingList    = NoYes::No;
    
        inventTransferUpdPick = InventTransferUpdPick::newParmBuffer(inventTransferParmTable);
        inventTransferUpdPick.run();

        WMSPickingRoute wmsPickingRoute;

        if (inventTransferUpdPick.parmIsSomeThingPosted())
        {
            select firstonly RecId from wmsPickingRoute
                where   wmsPickingRoute.ParmId      == parmId
                    &&  wmsPickingRoute.transRefId  == _transferId
                    &&  wmsPickingRoute.transType   == InventTransType::TransferOrderShip;
        }

By default, for company-specific tables (SaveDataPerCompany=Yes), DataAreaId is always included in the index at the beginning. Like, for example, PurchTable PurchIdx index structure from MS SQL Server Management Studio:

Such indexes will NOT work for cross-company queries.

Sometimes it is required to optimize the performance of cross-company queries to company-specific tables. For example, to optimize cross-company oData queries.

To accomplish this, you need to add the DataAreaId field explicitly to your index at the end and set the property Included Column to Yes.

From MS SQL Server Management Studio:

DataAreaId field appears in the Included columns, and this index will be used by SQL Server for cross-company queries:

Convert to accounting currency:

CurrencyExchangeHelper::amountCur2MST(amount, currencyCodeFrom[, fixedExchRate]);

Convert to a different currency:

CurrencyExchangeHelper::curAmount2CurAmount(amount, currencyCodeFrom, CurrencyCodeTo);

Get accounting currency:

CurrencyCode    accountingCurrency = Ledger::accountingCurrency();
CurrencyCode    accountingCurrency = Ledger::accountingCurrencyByLedger(_ledgerRecId);

Get reporting currency:

CurrencyCode    accountingCurrency = Ledger::reportingCurrency();
CurrencyCode    accountingCurrency = Ledger::reportingCurrencyByLedger(_ledgerRecId);

Convert currency with a class instance:

CurrencyExchangeHelper currencyExchangeHelper = CurrencyExchangeHelper::newExchangeDate(
    Ledger::current(),
    DateTimeUtil::getSystemDate(DateTimeUtil::getUserPreferredTimeZone())
);
currencyExchangeHelper.calculateTransactionToAccounting(currencyCodeFrom, amountCur, true);
// currencyExchangeHelper.calculateCurrencyToCurrency()
currencyExchangeHelper.parmExchangeRate1();

Get the exchange rate:

//accounting currency
ExchangeRateCalculation exchangeRateCalculation = ExchangeRateCalculation::newExchangeDate(Ledger::defaultExchangeRateType(),
    purchTable.CurrencyCode,
    Ledger::accountingCurrency(),
    DateTimeUtil::getSystemDate(DateTimeUtil::getUserPreferredTimeZone()));

purchTable.FixedExchRate = exchangeRateCalculation.getExchangeRate1();

// reporting currency
ExchangeRateCalculation exchangeRateCalculation = ExchangeRateCalculation::newExchangeDate(Ledger::reportingCurrencyExchangeRateType(),
    currencyCodeFrom,
    currencyCodeTo,
    DateTimeUtil::getSystemDate(DateTimeUtil::getUserPreferredTimeZone()));
exchangeRateCalculation.getExchangeRate1();

Also, when you are interested in only several field contents, it is not convenient to scroll back and forth to investigate particular field values.

Here is the SysTableBrowser extension, which you can use together with the Table Browser tool.

It allows you to:

- indicate fields which you want to see.

- predefine field ranges to see only specific records

Last updated: April 29, 2026

How to install?

- create a class with the name DXTSysTableBrowserFrm_Extension

- copy/paste the following content

- compile

/// <summary>
/// CoC extension of SysTableBrowser form
/// </summary>
[ExtensionOf(formStr(SysTableBrowser))]
final class DXTSysTableBrowserFrm_Extension
{
    private Map                 visibleFieldList;
    private Map                 rangeFieldList;
    private TableId             tableId;
    private FormGridControl     formGridControlAllFields;
    private FormGroupControl    customGroup;
    private str                 parmFieldList;
    private str                 parmRangeList;
    private FormStringControl   visibleFieldListControl;
    private FormStringControl   rangeFieldListControl;
 
    /// <summary>
    /// CoC for init method
    /// </summary>
    public void init()
    {
        next init();
 
        parmFieldList               = strLRTrim(getClientURLQueryValue('FieldList'));
        parmRangeList               = strLRTrim(getClientURLQueryValue('RangeList'));
        formGridControlAllFields    = this.design(0).controlName(formControlStr(SysTableBrowser, AllFieldsGrid));
        tableId                     = formGridControlAllFields.formRun().dataSource().cursor().TableId;
 
        this.dxtParseFieldListParam();
        this.dxtApplyRanges();
        this.dxtShowHideFields(true);
        this.dxtAddControls();
    }

    /// <summary>
    /// Applies datasource ranges.
    /// </summary>
    public void dxtApplyRanges()
    {
        FormDataSource          fds = this.dataSource(1);
        Query                   q;
        QueryBuildDataSource    qbds;

        rangeFieldList = new Map(Types::Integer, Types::Integer);
 
        container   ranges = str2con(parmRangeList, ',');
        str         rangeValue;
        FieldName   fieldName;
        FieldId     fieldId;
        int         i;
        
        if (fds)
        {
            q       = fds.query();
            qbds    = q.dataSourceNo(1);
            qbds.clearRanges();
 
            if (parmRangeList && conLen(ranges))
            {
                for (i = 1; i <= conLen(ranges); i++)
                {
                    str         pairStr = strLTrim(conPeek(ranges, i));
                    container   pairCnt = str2con(pairStr, '=');
                    fieldName   = conPeek(pairCnt, 1);
                    rangeValue  = conPeek(pairCnt, 2);
                    fieldId     = fieldName2Id(tableId, fieldName);
                    if (fieldId && rangeValue)
                    {
                        QueryBuildRange qbr = qbds.addRange(fieldId);
                        qbr.value(rangeValue);
                        if (!rangeFieldList.exists(fieldId))
                        {
                            rangeFieldList.add(fieldId, 1);
                        }
                    }
                }
            }
        }
    }

    /// <summary>
    /// Add additional controls on the SySTableBrowser form.
    /// </summary>
    public void dxtAddControls()
    {
        FormGroupControl   filterGroup = this.design().controlName(formControlStr(SysTableBrowser, CustomFilter));
        FormGroupControl   parentGroup;
 
        if (filterGroup)
        {
            parentGroup = filterGroup.parentControl();
 
            customGroup = this.design().addControl(FormControlType::Group, 'DXTCustomGroup', filterGroup);
            customGroup.caption('Extended functionality');
            customGroup.columns(2);
 
            visibleFieldListControl = customGroup.addControl(FormControlType::String, 'DXTVisibleFields');
            visibleFieldListControl.multiLine(true);
            visibleFieldListControl.width(400, -1);
            visibleFieldListControl.displayHeight(2, AutoMode::Fixed);
            visibleFieldListControl.text(parmFieldList);
            visibleFieldListControl.label('Visible fields');
            visibleFieldListControl.helpText('Comma-separated list of visible field names (AOT).');
            visibleFieldListControl.labelPosition(LabelPosition::Left);
 
            visibleFieldListControl.registerOverrideMethod(
                methodStr(FormStringControl, modified),
                methodStr(DXTSysTableBrowserFrm_Extension, dxtVisibleFieldListControlModified),
                this);
 
            rangeFieldListControl = customGroup.addControl(FormControlType::String, 'DXTRangeFields');
            rangeFieldListControl.multiLine(true);
            rangeFieldListControl.width(400, -1);
            rangeFieldListControl.displayHeight(2, AutoMode::Fixed);
            rangeFieldListControl.text(parmRangeList);
            rangeFieldListControl.label('Ranges');
            rangeFieldListControl.helpText('Comma-separated list of field ranges in the format FieldName=RangeValue.');
            rangeFieldListControl.labelPosition(LabelPosition::Left);
 
            rangeFieldListControl.registerOverrideMethod(
                methodStr(FormStringControl, modified),
                methodStr(DXTSysTableBrowserFrm_Extension, dxtRangeFieldListControlModified),
                this);
        }
    }

    /// <summary>
    /// DXTVisibleFields modified method. To update visible fields, when field list is changed.
    /// </summary>
    /// <param name = "_formControl">FormStringControl</param>
    /// <returns>boolean</returns>
    public boolean dxtVisibleFieldListControlModified(FormStringControl _formControl)
    {
        var locFieldList = strLRTrim(visibleFieldListControl.valueStr());
        if (locFieldList != parmFieldList)
        {
            parmFieldList = locFieldList;
            this.dxtParseFieldListParam();
            this.dxtShowHideFields();
        }
 
        return _formControl.modified();
    }

    /// <summary>
    /// DXTRangeFields modified method. To update ranges, when ranges are changed.
    /// </summary>
    /// <param name = "_formControl">FormStringControl</param>
    /// <returns>boolean</returns>
    public boolean dxtRangeFieldListControlModified(FormStringControl _formControl)
    {
        var locFieldList = strLRTrim(rangeFieldListControl.valueStr());
        if (locFieldList != parmRangeList)
        {
            parmRangeList = locFieldList;
            this.dxtApplyRanges();
            FormDataSource fds = this.dataSource(1);
            fds.executeQuery();
        }
 
        return _formControl.modified();
    }

    /// <summary>
    /// Parse visible field list string.
    /// </summary>
    public void dxtParseFieldListParam()
    {
        visibleFieldList    = new Map(Types::Integer, Types::Integer);
 
        if (parmFieldList)
        {
            container   fieldNames = str2con(parmFieldList, ',');
            FieldName   fieldName;
            FieldId     fieldId;
            int         i;
 
            for (i = 1; i <= conLen(fieldNames); i++)
            {
                fieldName   = strLRTrim(conPeek(fieldNames, i));
                fieldId     = fieldName2Id(tableId, fieldName);
                if (fieldId)
                {
                    if (!visibleFieldList.exists(fieldId))
                    {
                        visibleFieldList.insert(fieldId, 1);
                    }
                }
            }
        }
    }

    /// <summary>
    /// Show/Hide field based on the user preference.
    /// </summary>
    /// <param name = "_initRun">boolean</param>
    public void dxtShowHideFields(boolean _initRun = false)
    {
        int             fieldCount      = formGridControlAllFields.controlCount(),
                        visFldCount     = visibleFieldList.elements(),
                        i;
 
        if (_initRun && !visFldCount)
        {
            return;
        }

        for (i = 1; i <= fieldCount; i++)
        {
            FormControl     formControl     = formGridControlAllFields.controlNum(i);
            FieldBinding    fieldBinding    = formControl.fieldBinding();
            FieldId         fieldId         = fieldBinding.fieldId();

            if (!visFldCount || (fieldId && (visibleFieldList.exists(fieldId) || rangeFieldList.exists(fieldId))))
            {
                formControl.visible(true);
            }
            else
            {
                formControl.visible(false);
            }
        }
    }

}

/// <summary>
/// An extension class of the <c>PrintMgmtReportFormatPopulator</c> class.
/// </summary>
[ExtensionOf(classStr(PrintMgmtReportFormatPopulator))]
public final class VKPrintMgmtReportFormatPopulatorCls_Extension
{
    #PrintMgmtSetup

    /// <summary>
    /// Add custom reports to the print management.
    /// </summary>
    protected void addDocuments()
    {
        this.addOther(PrintMgmtDocumentType::SalesOrderConfirmation, ssrsReportStr(VKSalesConfirm, Report), ssrsReportStr(VKSalesConfirm, Report), #NoCountryRegionId);
        this.addOther(PrintMgmtDocumentType::SalesOrderInvoice, ssrsReportStr(VKSalesInvoice, Report), ssrsReportStr(VKSalesInvoice, Report), #NoCountryRegionId);

        next addDocuments();
    }

}

• Report name in report contract cannot be null or empty.
• Customer CustNum, Invoice InvoiceNum was not delivered because of a print management setup issue. Verify that print management is set up correctly and the destination is valid.

/// <summary>
/// event handler class to print new purchase order report
/// </summary>
internal final class VKPrintMgmtDocTypeCls_EventHandler
{
    /// <summary>
    /// Get new custom default report for purchase order
    /// </summary>
    /// <param name = "_docType">Print mgmt document type</param>
    /// <param name = "_result">delegate for default report</param>
    [SubscribesTo(classstr(PrintMgmtDocType), delegatestr(PrintMgmtDocType, getDefaultReportFormatDelegate))]
    public static void getDefaultReportFormatDelegate(PrintMgmtDocumentType _docType, EventHandlerResult _result)
    {
        switch (_docType)
        {
            case PrintMgmtDocumentType::PurchaseOrderRequisition:
                _result.result(ssrsReportStr(VKPurchPurchaseOrder, Report));
                break;

            case PrintMgmtDocumentType::SalesOrderConfirmation:
                _result.result(ssrsReportStr(VKSalesConfirm, Report));
                break;

            case PrintMgmtDocumentType::SalesOrderInvoice:
                _result.result(ssrsReportStr(VKSalesInvoice, Report));
                break;
        }
    }

}

/// <summary>
/// Extension of PrintMgmtNode_Sales class
/// </summary>
[ExtensionOf(classStr(PrintMgmtNode_Sales))]
final class VKPrintMgmtNode_Sales_Extension
{
     /// <summary>
    /// Adds additional document types for Sales module
    /// </summary>
    /// <returns>Document types list</returns>
    public List getDocumentTypes()
    {
        List docTypes;
        docTypes = new List(Types::Enum);
        docTypes = next getDocumentTypes();
        docTypes.addEnd(PrintMgmtDocumentType::VKCustomerReturnReceived);
        return docTypes;
    }

}