Sysoperation framework with Aot query

public class UpdatePriceFormulaIdOnItemsService__Custom extends SysOperationServiceBase
{
    #OCCRetrycount
    public void processOperation(UpdatePriceFormulaIdOnItemsContract__Custom _contract)
    {
        Query               orderQuery;

        orderQuery      = _contract.getQuery();
        container       compCon = str2con(_contract.parmCompany(), SysAppUtilities__Custom::semiColon);
        QueryRun    queryRun = new QueryRun(orderQuery);
        while (queryRun.Next())
        {
            InventTable inventTable = queryRun.get(tableNum(InventTable));
            try
            {
                PriceFormulaId__Custom  priceFormulaIdMaster = this.getPriceFormulaId(inventTable);

                //DSSE
                if (inventTable &&
                    inventTable.PriceFormulaIdMaster__Custom != priceFormulaIdMaster)
                {
                    ttsbegin;
                    inventTable.selectForUpdate(true);
                    inventTable.PriceFormulaIdMaster__Custom = priceFormulaIdMaster;
                    inventTable.PriceFormulaId__Custom = priceFormulaIdMaster;
                    inventTable.doUpdate();
                    ttscommit;
                }

                for (int i=1; i<=conLen(compCon); i++)
                {
                    DataAreaId  company = conPeek(compCon, i);
                    changecompany(company)
                    {
                        InventTable inventTableSales = InventTable::find(inventTable.ItemId);
                        PriceFormulaId__Custom  priceFormulaId = this.getPriceFormulaId(inventTableSales);

                        if (inventTableSales &&
                            inventTableSales.PriceFormulaId__Custom != priceFormulaId)
                        {
                            ttsbegin;
                            inventTableSales.selectForUpdate(true);
                            inventTableSales.PriceFormulaIdMaster__Custom = priceFormulaIdMaster;
                            inventTableSales.PriceFormulaId__Custom = priceFormulaId;
                            inventTableSales.doUpdate();
                            ttscommit;
                        }
                    }
                }

                info(strfmt("@_CustomtITServices:SucessUpdateItem", inventTable.ItemId));
            }
            catch (Exception::Deadlock)
            {
                retry;
            }
            catch (Exception::UpdateConflict)
            {
                if (appl.ttsLevel() == 0)
                {
                    if (xSession::currentRetryCount() >= #RetryNum)
                    {
                        warning(strFmt("@_CustomtITServices:FaliedUpdateItem", inventTable.ItemId));
                        continue;
                    }
                    else
                    {
                        retry;
                    }
                }
                else
                {
                    warning(strFmt("@_CustomtITServices:FaliedUpdateItem", inventTable.ItemId));
                    continue;
                }
            }
            catch (Exception::Error)
            {
                warning(strFmt("@_CustomtITServices:FaliedUpdateItem", inventTable.ItemId));
                continue;
            }
        }
    }

    public PriceFormulaId__Custom getPriceFormulaId(InventTable _inventTable)
    {
        DimensionValue      brandDim;
        EcoResCategoryId    ecoResCategoryId;
        container           catCon  = conNull();

        if (_inventTable)
        {
            brandDim            = _CustomtITServicesUtility__Custom::getDimension_CustomplayValue(_inventTable.DefaultDimension, SysAppUtilities__Custom::dimensionAttributeNameBrand);
            catCon              = _CustomtITServicesUtility__Custom::getProdCategories(_inventTable.ItemId);
        }

        ItemPriceFormula__Custom    itemPriceFormula;
        
        if (_inventTable.ItemId)
        {
            itemPriceFormula    = ItemPriceFormula__Custom::findByItem(_inventTable.ItemId);
        }
           
        if (!itemPriceFormula && catCon != conNull() && brandDim)
        {
            for (int i=1; i<=conLen(catCon); i++)
            {
                ecoResCategoryId    = EcoResCategory::find(conPeek(catCon, i)).RecId;
                itemPriceFormula    = ItemPriceFormula__Custom::findByCategoryBrand(ecoResCategoryId, brandDim);
                if (itemPriceFormula)
                {
                    break;
                }
            }
        }

        if (!itemPriceFormula && brandDim)
        {
            itemPriceFormula    = ItemPriceFormula__Custom::findByBrand(brandDim);
        }
        
        if (!itemPriceFormula && catCon != conNull())
        {
            for (int i=1; i<=conLen(catCon); i++)
            {
                ecoResCategoryId    = conPeek(catCon, i);
                itemPriceFormula    = ItemPriceFormula__Custom::findByCategory(ecoResCategoryId);
                if (itemPriceFormula)
                {
                    break;
                }
            }
        }

        return itemPriceFormula.PriceFormulaId;
    }

}
=====================
public class UpdatePriceFormulaIdOnItemsController__Custom extends SysOperationServiceController
{
    // <summary>
    /// Creates a new instance of <c>UpdateEndOfLifeOnItemsController__Custom</c> class.
    /// </summary>
    /// <param name = "_args">A controller arguments.</param>
    /// <returns>A instance of <c>SysOperationController</c> class.</returns>
    public static UpdatePriceFormulaIdOnItemsController__Custom construct(Args _args)
    {
        UpdatePriceFormulaIdOnItemsController__Custom controller = new UpdatePriceFormulaIdOnItemsController__Custom();
        controller.parmArgs(_args);

        return controller;
    }

    /// <summary>
    /// Instantiate controller.
    /// </summary>
    protected void new()
    {
        super(classStr(UpdatePriceFormulaIdOnItemsService__Custom), methodStr(UpdatePriceFormulaIdOnItemsService__Custom, processOperation));

        this.parmDialogCaption("@_CustomtITServices:UpdatePriceFormulaIdItem");
    }

    /// <summary>
    /// Runs the class with the specified arguments.
    /// </summary>
    /// <param name = "_args">The specified arguments.</param>
    public static void main(Args _args)
    {
        UpdatePriceFormulaIdOnItemsController__Custom controller = UpdatePriceFormulaIdOnItemsController__Custom::newFromArgs(_args);
        controller.parmExecutionMode(SysOperationExecutionMode::Synchronous);
        controller.startOperation();
    }

    /// <summary>
    /// Instantiate and initialize controller class.
    /// </summary>
    /// <param name = "_args">The specified arguments.</param>
    /// <returns>
    /// returns controller class.
    /// </returns>
    public static UpdatePriceFormulaIdOnItemsController__Custom newFromArgs(Args _args)
    {
        UpdatePriceFormulaIdOnItemsController__Custom controller = UpdatePriceFormulaIdOnItemsController__Custom::construct(_args);
        return controller;
    }

}
==================
[DataContractAttribute, SysOperationContractProcessingAttribute(ClassStr(UpdatePriceFormulaIdOnItemsUIbuilder__Custom))]
public class UpdatePriceFormulaIdOnItemsContract__Custom
{
    str     packedQuery;
    Str                     company;
    /// <summary>
    ///    Initialize query
    /// </summary>
    public void initQuery()
    {
        Query   newQuery;
        newQuery = new Query(queryStr(InventTable));
        this.setQuery(newQuery);
    }

    /// <summary>
    ///     Get/Set the packed query
    /// </summary>
    /// <param name = "_packedQuery">query</param>
    /// <returns>string</returns>
    [
    DataMemberAttribute,
    AifQueryTypeAttribute('_packedQuery', queryStr(InventTable))
    ]
    public str parmPackedQuery(str _packedQuery = packedQuery)
    {
        packedQuery = _packedQuery;

        return packedQuery;
    }

    /// <summary>
    ///     Get the query
    /// </summary>
    /// <returns>Query</returns>
    public Query getQuery()
    {
        return
        new Query(SysOperationHelper::base64Decode(packedQuery));
    }

    /// <summary>
    ///     Set the query
    /// </summary>
    /// <param name = "_query">query</param>
    public void setQuery(Query _query)
    {
        packedQuery = SysOperationHelper::base64Encode(_query.pack());
    }

    // <summary>
    /// Gets or sets the value of the datacontract parameter company.
    /// </summary>
    /// <param name="_company">
    /// The new value of the datacontract parameter company; optional.
    /// </param>
    /// <returns>
    ///  The current value of datacontract parameter company
    /// </returns>
    [
        DataMemberAttribute,
        SysOperationLabelAttribute(literalStr("@_CustomtITServices:Company")),
        SysOperation_CustomplayOrderAttribute("1")
    ]
    public Str parmCompany(Str _company = company)
    {
        company = _company;
        return company;
    }

}

Query with join with multiple data sources in AX (Inner join, not exists join)

    public void initializeQueryDS()
    {
        query = new Query();
        QueryBuildDataSource qbds;
        QueryBuildDataSource qbdsSessionLine;

        switch(routing)
        {
            case Routing::Sales:
                qbds = query.addDataSource(tableNum(SalesLine));

                qbdsSessionLine = qbds.addDataSource(tableNum(WorkbenchSessionLine));
                qbdsSessionLine.joinMode(JoinMode::NoExistsJoin);
                qbdsSessionLine.relations(true);
                qbdsSessionLine.fetchMode(QueryFetchMode::One2One);

                TblNum = tableNum(SalesLine);
                break;
            case Routing::Return:
                qbds = query.addDataSource(tableNum(SalesLine));
                TblNum = tableNum(SalesLine);
                break;
        }
    }

    public void initializeQueryRange()
    {
        if(inventLocationId != strMin())
        {  
            QueryBuildDataSource qbdsSalesLine,qbdsInventDim;

            qbdsSalesLine = query.dataSourceTable(tableNum(SalesLine));
            qbdsInventDim = qbdsSalesLine.addDataSource(tableNum(InventDim));
            qbdsInventDim.joinMode(JoinMode::InnerJoin);
            qbdsInventDim.relations(true);
            qbdsInventDim.fetchMode(QueryFetchMode::One2One);
            qbdsInventDim.addRange(fieldNum(InventDim, InventLocationId)).value(inventLocationId);
        }

        if(shipDate != dateNull())
        {
            QueryBuildDataSource qbds;

            qbds = query.dataSourceTable(tableNum(SalesLine));
            qbds.addRange(fieldNum(SalesLine, ShippingDateConfirmed)).value(SysQuery::value(shipDate));
        }

        if(dlvModeFrom.elements())
        {
            container   conMOD;
            Enumerator  enumerator  =   dlvModeFrom.getEnumerator();

            while (enumerator.moveNext())
            {
                conMOD += enumerator.current();
            }

            QueryBuildDataSource qbds;
            qbds = query.dataSourceTable(tableNum(SalesLine));

            qbds.addRange(fieldNum(SalesLine, DlvMode)).value(con2Str(conMOD));
        }

    }

    public WorkbenchSessionLine initFromCommon(Common _callerTable)
    {
        WorkbenchSessionLine line;

        switch (_callerTable.TableId)
        {
            case tableNum(SalesLine):
                line.RefRecId    = _callerTable.(fieldNum(SalesLine, RecId));
                line.RefTableId    = _callerTable.TableId;

                line.InventTransId    = _callerTable.(fieldNum(SalesLine, InventTransId));

                if(routing == Routing::Sales)
                {
                    line.ReferenceType = RefType::SalesOrder;
                }
                else if(routing == Routing::Return)
                {
                    line.ReferenceType = RefType::ReturnOrder;
                }
                break;

            default:
                break;
        }

        return line;
    }

    public void createWorkbenchSession(WorkbenchSessionContract _contract)
    {
        WorkbenchSessionTable header;
        WorkbenchSessionLine line;

        RecordInsertList lineRecordList = new RecordInsertList(tableNum(WorkbenchSessionLine), true, true, true, false, true, line);

        contract = _contract;
       
        this.initializeParameters();
        this.initializeQueryDS();
        this.initializeQueryRange();

        try
        {
            ttsbegin;

            NumberSeq numberSeq = NumberSeq::newGetNum(TMSParameters::numRefInternalSessionID());

            header.initValue();

            header.DynamicsInternalSessionID = numberSeq.num();

            numberSeq.used();

            header.SessionStatus = SessionStatus::Open;

            header.LE_ID = curExt();

            if (routing == Routing::Sales || routing == Routing::Return)
            {
                header.CombineOrders = true;
            }
           
            header.insert();

            queryRun = new QueryRun(query);

            while(queryRun.next())
            {
                Common common = queryRun.get(TblNum);

                line = this.initFromCommon(common);

                line.WorkbenchSessionTable = header.RecId;

                lineRecordList.add(line);
            }

            lineRecordList.insertDatabase();

            ttscommit;
            
            this.openWorkbenchSessionForm(header);
        }
        catch
        {

        }
    }

Run Query run

QueryRun queryRun = new QueryRun(this.getQueryOrderHoldRules());

        while (queryRun.next())
        {
            MCRHoldCodeTable mcrHoldCodeTable = queryRun.get(tableNum(MCRHoldCodeTable));

            this.checkExistingOrdeHolds(mcrHoldCodeTable);

        }

Query run with dynamic ranges

public Query getQueryOrderHoldRules()
    {
        Query                   query;
        QueryBuildDataSource    qbdsMCRHoldCodeTable;

        query = new Query();

        qbdsMCRHoldCodeTable = query.addDataSource(tableNum(MCRHoldCodeTable));

        switch (documentStatus)
        {
            case CredManDocumentStatusCheck::Confirmation:
                qbdsMCRHoldCodeTable.addRange(fieldNum(MCRHoldCodeTable, SAZConfirmation)).value(SysQuery::value(NoYes::Yes));
                break;
            case CredManDocumentStatusCheck::PickingList:
                qbdsMCRHoldCodeTable.addRange(fieldNum(MCRHoldCodeTable, SAZPickingList)).value(SysQuery::value(NoYes::Yes));
                break;
            case CredManDocumentStatusCheck::PackingSlip:
                qbdsMCRHoldCodeTable.addRange(fieldNum(MCRHoldCodeTable, SAZPackingSlip)).value(SysQuery::value(NoYes::Yes));
                break;

            case CredManDocumentStatusCheck::WHSShipment:
                qbdsMCRHoldCodeTable.addRange(fieldNum(MCRHoldCodeTable, SAZWHSShipment)).value(SysQuery::value(NoYes::Yes));
                break;

            case CredManDocumentStatusCheck::Invoice:
                qbdsMCRHoldCodeTable.addRange(fieldNum(MCRHoldCodeTable, SAZInvoice)).value(SysQuery::value(NoYes::Yes));
                break;

            default:
                break;
        }

        qbdsMCRHoldCodeTable.addRange(fieldNum(MCRHoldCodeTable, SAZHoldCodeRule)).value(SysQuery::valueNot(SAZHoldCodeRule::None));

        return query;

    }