Tuesday, 18 June 2019

Item Onhand qty x++

class ItemOnhandQty
{       
    static void Main(Args _args)
    {
        InventDim           inventDim;
        InventDimParm       inventDimParm;
        Itemid              itemid;
        InventOnHand        inventOnHand;
        InventQty           availQty;

        itemid = 'RSH 01';
        inventDim.InventSiteId = '';
        inventDim.InventLocationId = '';

        inventDimParm.initFromInventDim(inventDim);

        inventOnHand = InventOnhand::newParameters(itemid, inventDim, inventDimParm);
        availQty = inventOnHand.availPhysical();

        info(strFmt('onhand qty–%1', availQty));
    }

}

Monday, 17 June 2019

Creating Item requirements through x++

All projects - Plan - Item Requirements

public class INTC_CreateItemRequirements
{
    public void create(RecId   _recid)
    {
        INTC_MaterialTakeOffTable       materialTakeOffTable, materialTakeOffTableUpdate;
        ProjTable                       projTable;
        SalesLine                       salesLine;
        Str1260                         msg;

        select materialTakeOffTable where materialTakeOffTable.RecId    ==  _recid;
        select projTable where projTable.ProjId ==  materialTakeOffTable.ProjId;
       
        ttsbegin;
        salesLine = this.initializeSalesLine(_recid, projTable);
        salesLine.createLine();

        select forupdate materialTakeOffTableUpdate where materialTakeOffTableUpdate.RecId  == _recid;
        materialTakeOffTableUpdate.ItemRequirement  =   NoYes::Yes;
        materialTakeOffTableUpdate.update();
        ttscommit;
    }

    public SalesLine initializeSalesLine(RecId  _recid, ProjTable _projTable)
    {
        SalesLine                       salesline;
        INTC_MaterialTakeOffTable       materialTakeOffTable;
        ProjTable                       projTable;
        InventDim                       inventDim, inventDimLocal;
        LegalEntity                     legalEntity;

        select materialTakeOffTable where materialTakeOffTable.RecId    ==  _recid;
        select projTable where projTable.ProjId ==  materialTakeOffTable.ProjId;

        inventDim   =   this.getInventDimension(materialTakeOffTable.ItemId);

        if(materialTakeOffTable)
        {
            salesLine.initValue();
            salesLine.setInventDimId("");
            salesLine.ItemId        =   materialTakeOffTable.ItemId;
            salesLine.itemIdChanged();

            if(materialTakeOffTable.AvailableQty > materialTakeOffTable.QtyRequired)
            {
                salesLine.SalesQty      =   materialTakeOffTable.QtyRequired;
                salesLine.QtyOrdered    =   materialTakeOffTable.QtyRequired;
            }
            else if(materialTakeOffTable.QtyRequired > materialTakeOffTable.AvailableQty)
            {
                salesLine.SalesQty      =   materialTakeOffTable.AvailableQty;
                salesLine.QtyOrdered    =   materialTakeOffTable.AvailableQty;
            }
            salesLine.ProjId            =   materialTakeOffTable.ProjId;
            salesLine.CurrencyCode      =   ledger::accountingCurrency(CompanyInfo::Find().RecId);
            salesLine.SalesUnit         =   materialTakeOffTable.Uom;
            salesLine.ProjCategoryId    =   materialTakeOffTable.projCategoryId;

            inventdim.InventSiteId      =   materialTakeOffTable.InventSiteId;
            inventdim.InventLocationId  =   materialTakeOffTable.InventLocationId;
            salesLine.InventDimId       =   InventdIm::findOrCreate(inventDim).inventDimId;
            inventDim.initFromInventTable(InventTable::find(salesLine.ItemId));
            salesLine.initFromProjTable(projTable, false);
            salesLine.TaxGroup          =   projTable.TaxGroupId;
            salesLine.CostPrice         =   materialTakeOffTable.UnitCost;
            salesLine.SalesPrice        =   materialTakeOffTable.UnitCost;
            SalesLineType_ItemReq::setSalesLineReceiptDate(salesLine);
        }
        return  salesLine;
    }

    public InventDim getInventDimension(ItemId   _itemId)
    {
        InventTable                 inventTable = inventTable::find(_itemId);
        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);
        return  inventDim;
    }

}

Thursday, 13 June 2019

create Purchase requisition through x++

class INTC_CreatePurchaseRequisition
{
    PurchReqTable                       purchReqTable;
    PurchReqLine                        purchReqLine;
    INTC_MaterialTakeOffTable           materialTakeOffTable;
    Name                                procurementCategoryId;
    INTC_MTKONumber                     mtkoNumber;

    public void createHeader(RecId  _recId)
    {
        select  materialTakeOffTable where materialTakeOffTable.RecId   ==  _recId;
        if(materialTakeOffTable.INTC_MTKONumber   !=  mtkoNumber)
        {
            purchReqTable.clear();
            purchReqTable.initValue();

            purchReqTable.PurchReqId        =   NumberSeq::newGetNum(PurchReqTable::numRefPurchReqId()).num();
            purchReqTable.PurchReqName      =   ProjTable::find(materialTakeOffTable.ProjId).Name;
            purchReqTable.ProjId            =   materialTakeOffTable.ProjId;
            purchReqTable.INTC_MTKONumber   =   materialTakeOffTable.INTC_MTKONumber;

            purchReqTable.insert();
            info(strFmt("Purchase requisition # %1 created", purchReqTable.PurchReqId));
        }
        mtkoNumber   =   materialTakeOffTable.INTC_MTKONumber;
        this.createLines(_recId);
    }

    public void createLines(RecId  _recId)
    {
        INTC_MaterialTakeOffTable           materialTakeOffTableUpdate;
        InventTable                         inventTable;
        InventDim                           inventDim;
        ProjTable                           projTable   =   ProjTable::find(materialTakeOffTable.ProjId);
        ProjInvoiceTable                    projInvoiceTable;

        select projInvoiceTable where projInvoiceTable.ProjInvoiceProjId    ==   projTable.ProjInvoiceProjId;
        inventTable =   InventTable::find(materialTakeOffTable.ItemId);

        purchReqLine.clear();
        purchReqLine.initValue();
       
        purchReqLine.initFromPurchReqTable(purchReqTable);
        purchReqLine.initFromInventTable(inventTable);

        purchReqLine.ItemId                 =   materialTakeOffTable.ItemId;
        purchReqLine.BuyingLegalEntity      =   CompanyInfo::find().RecId;
        purchReqLine.InventDimIdDataArea    =   curext();
        purchReqLine.PurchQty               =   materialTakeOffTable.QtyToOrder;
        inventDim.InventSiteId              =   materialTakeOffTable.InventSiteId;
        inventDim.InventLocationId          =   materialTakeOffTable.InventLocationId;
        purchReqLine.InventDimId            =   inventDim::findOrCreate(inventDim).inventDimId;
        purchReqLine.CurrencyCode           =   Ledger::accountingCurrency(CompanyInfo::current());
        purchReqLine.ProjSalesCurrencyId    =   projInvoiceTable.CurrencyId;
        purchReqLine.ProjCategoryId         =   materialTakeOffTable.ProjCategoryId;
        purchReqLine.ProjId                 =   materialTakeOffTable.ProjId;
        purchReqLine.ProcurementCategory    =   materialTakeOffTable.ProcureCategoryRecId;
        purchReqLine.PurchPrice             =   this.unitCost(materialTakeOffTable.ItemId, materialTakeOffTable.InventSiteId, materialTakeOffTable.InventLocationId);
        purchReqLine.LineAmount             =   purchReqLine.PurchPrice * materialTakeOffTable.QtyToOrder;
 
        purchReqLine.insert();

        select forupdate materialTakeOffTableUpdate where materialTakeOffTableUpdate.RecId  ==  _recId;
        ttsbegin;
        materialTakeOffTableUpdate.PurchReqId   =   purchReqTable.PurchReqId;
        materialTakeOffTableUpdate.update();
        ttscommit;
    }

    private real unitCost(ItemId _itemId, InventSiteId _site, InventlocationId _warehouse)
    {
        InventDim       inventDim;
        InventDimParm   inventDimParm;
        InventOnHand    inventOnHand;
        InventSum       inventSum;

        select firstOnly inventSum where inventSum.ItemId == _itemId;

        inventdim.InventSiteId      = _site;
        inventDim.InventLocationId  = _warehouse;

        inventDimParm.initFromInventDim(inventDim);
        inventOnHand = InventOnHand::newItemDim(inventSum.ItemId, inventDim, inventDimParm);

        return inventOnHand.costPricePcs();
    }

}

Wednesday, 12 June 2019

get Item Inventory dimensions (site, warehouse, invent dim Id) through x++

public class INTC_ItemInventoryDimensions
{     
    public static void main(Args _args)
    {
        InventTable                 inventTable = inventTable::find('A0003');//itemId
        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 : %1, Site : %2, Warehouse : %3', inventDim.inventDimId, inventDim.InventSiteId,  inventDim.InventLocationId));
    }

}

To test service class with multiple list of contract parameters x++

class TestTransferJournal
{     
    public static void main(Args _args)
    { 
        BW_TransferJournalService       service     =   new BW_TransferJournalService();
        BW_TransferJournalContract      contract    =   new BW_TransferJournalContract();
        BW_TransferJournalContract      contract1   =   new BW_TransferJournalContract();
        list                            listvalue   =   new list(types::class);
        str                             msg;

        contract.parmitemid('I-0001');
        contract.parmTransferQty(14);

        contract1.parmitemid('I-0003');
        contract1.parmTransferQty(15);

        listvalue.addend(contract);
        listvalue.addend(contract1);
        msg =   service.cerateTransferJournal(listvalue, "IMEC", "Pota", "TEST00004");
        info(msg);
    }
}

Create and post Transfer order in D365 custom service

public class BW_TransferJournalService
{
    [
        SysEntryPointAttribute(true),
        AifCollectionTypeAttribute('_transferJournalContractList',Types::Class,classStr(BW_TransferJournalContract)),
        AifCollectionTypeAttribute('return',Types::String)
    ]
    public str cerateTransferJournal(   List                    _transferJournalContractList,
                                        InventLocationIdFrom    _fromLoction,
                                        InventLocationIdTo      _toLocation,
                                        str                     _pgRequestNum)
    {
        InventTransferTable             inventTransferTable;
        InventTransferLine              inventTransferLine;
        InventJournalNameId             inventJournalName;
        InventDim                       inventDim;
        JournalCheckPost                journalCheckPost;
        Str1260                         msg, msgPost;
        BW_TransferJournalContract      transferJournalContract;
        ListEnumerator                  listEnumerator  = _transferJournalContractList.getEnumerator();
        numberSeq                       numberSeq;
        NumberSequenceReference         numberSequenceReference;
        InventTransferUpd               inventTransferUpd;

        try
        {
            ttsBegin;
            if (!_transferJournalContractList.empty())
            {
                inventTransferTable.clear();
                inventTransferTable.initValue();
                numberSequenceReference                     =   InventParameters::numRefTransferId();
                numberSeq                                   =   numberSeq::newGetNumFromCode(numberSequenceReference.numberSequenceTable().NumberSequence);
                inventTransferTable.TransferId              =   numberSeq.num();
                inventTransferTable.InventLocationIdFrom    =   _fromLoction;
                inventTransferTable.modifiedField(fieldNum(InventTransferTable, InventLocationIdFrom));
                inventTransferTable.InventLocationIdTo      =   _toLocation;
                inventTransferTable.modifiedField(fieldNum(InventTransferTable, InventLocationIdTo));
                inventTransferTable.TransferStatus          =   InventTransferStatus::Created;
                inventTransferTable.InventLocationIdTransit =   InventLocation::find(inventTransferTable.InventLocationIdFrom).InventLocationIdTransit;
                inventTransferTable.BW_PGRequestNum         =   _pgRequestNum;
                inventTransferTable.BW_RequestorId          =   curUserId();
                inventTransferTable.initFromAddress();
                inventTransferTable.initToAddress();
                inventTransferTable.initDeliveryMode();
                inventTransferTable.insert();

                while (listEnumerator.moveNext())
                {
                    transferJournalContract = listEnumerator.current();
                    ttsbegin;
                    inventTransferLine.clear();
                    inventTransferLine.initValue();
                    inventTransferLine.initFromInventTransferTable(inventTransferTable, NoYes::Yes);
                    inventTransFerLine.TransferId       =   inventTransferTable.TransferId;
                    inventTransFerLine.LineNum          =   InventTransferLine::lastLineNum(inventTransferTable.TransferId) + 1;
                    inventTransferLine.ItemId           =   transferJournalContract.parmItemId();
                    inventTransferLine.initFromInventTable(InventTable::find(transferJournalContract.parmItemId()));
                    inventTransferLine.QtyTransfer      =   transferJournalContract.parmTransferQty();
                    inventTransferLine.QtyRemainReceive =   transferJournalContract.parmTransferQty();
                    inventTransferLine.QtyRemainShip    =   transferJournalContract.parmTransferQty();
                    inventTransferLine.QtyShipNow       =   0;
                    inventTransferLine.QtyReceiveNow    =   0;
                    inventTransferLine.RemainStatus     =   InventTransferRemainStatus::Shipping;

                    inventDim = InventDim::findOrCreateBlank();
                    inventDim.initProductDimensionsFromInventTable(InventTable::find(transferJournalContract.parmItemId()));
                    inventTransferLine.InventDimId = inventDim::findOrCreate(inventDim).inventDimId;
                    inventTransferLine.initFromInventTransferTable(InventTransferTable::find(inventTransferTable.TransferId), true);
                 
                    InventMovement::bufferSetRemainQty(inventTransferLine,InventMovSubType::None);
                    InventMovement::bufferSetRemainQty(inventTransferLine,InventMovSubType::TransferOrderTransitFrom);

                    if (inventTransferLine.validateWrite())
                    {
                        inventTransferLine.insert();
                    }
                    ttscommit;
                }
                msg = strFmt("%1", "1|"+" "+inventTransferTable.TransferId);
            }
            else
            {
                throw error('Error:Empty contract');
            }
            ttsCommit;
        }
        catch
        {
            msg = "0|"+" "+infolog.text(infologLine());
            infolog.clear();
        }
        return msg;
    }

    [
        SysEntryPointAttribute(true),
        AifCollectionTypeAttribute('return',Types::Class,classStr(BW_TransferOrderDetailsContract))
    ]
    public List getTransferOrderDetails(JournalId     _transferId)
    {
        InventTransferTable             inventTransferTable;
        InventTransferLine              inventTransferLine;
        List                            detailsList  =   new List(Types::Class);
        str                             valueCentre, subValueCentre, unitCode;
        InventTable                     inventTable;
        InventTableModule               inventTableModule;
        Str1260                         msg;
        AmountMST                       purchPrice, salesPrice;
     
        if (_transferId)
        {
            while select inventTransferTable
                join  inventTransferLine
                where inventTransferTable.TransferId  ==  _transferId
                && inventTransferLine.TransferId ==  inventTransferTable.TransferId
            {
                if(inventTransferLine)
                {
                    BW_TransferOrderDetailsContract       transferOrderDetailsContract  = new   BW_TransferOrderDetailsContract();
                 
                    transferOrderDetailsContract.parmItemId(inventTransferLine.ItemId);
                    transferOrderDetailsContract.parmQty(inventTransferLine.QtyTransfer);
                    transferOrderDetailsContract.parmFromSerialNum(inventTransferLine.BW_FromSerialNum);
                    transferOrderDetailsContract.parmToSerialNum(inventTransferLine.BW_ToSerialNum);
                    transferOrderDetailsContract.parmBatchNum(inventTransferLine.BW_BatchNum);
                    transferOrderDetailsContract.parmExpDateOfStock(inventTransferLine.BW_ExpDateOfStock);
                    transferOrderDetailsContract.parmMessage("1");
                    detailsList.addEnd(transferOrderDetailsContract);
                }
                else
                {
                    BW_TransferOrderDetailsContract       transferOrderDetailsContract  = new   BW_TransferOrderDetailsContract();
                    msg = "0| Transfer order Line/Lines not available in database";
                    transferOrderDetailsContract.parmMessage(msg);
                    detailsList.addEnd(transferOrderDetailsContract);
                }
            }
        }
        else
        {
            BW_TransferOrderDetailsContract       transferOrderDetailsContract  = new   BW_TransferOrderDetailsContract();
            msg = "0| Transfer order is not available in database";
            transferOrderDetailsContract.parmMessage(msg);
            detailsList.addEnd(transferOrderDetailsContract);
        }
        return detailsList;
    }

    /*-----------------------------Posting transfer Order---------------------------------------------------*/
    [
        SysEntryPointAttribute(true),
        AifCollectionTypeAttribute('return',Types::String)
    ]
    public str postTransferOrder(InventTransferId   _transferId)
    {
        InventTransferTable             inventTransferTable;
        InventTransferUpd               inventTransferUpd;
        InventTransferParmTable         inventTransferParmTable;
        Str1260                         msg, msgPost;

        try
        {
            ttsBegin;
            if (_transferId)
            {
                select inventTransferTable where inventTransferTable.TransferId ==  _transferId;

                if(inventTransferTable.TransferStatus   !=   InventTransferStatus::Received)
                {
                    inventTransferParmTable.TransferId      = inventTransferTable.TransferId;
                    inventTransferParmTable.EditLines       = true;
                    inventTransferParmTable.AutoReceiveQty  = true;
                    inventTransferParmTable.ExplodeLines    = true;
                    inventTransferParmTable.UpdateType      = InventTransferUpdateType::Shipment;
                    inventTransferParmTable.TransDate       = systemDateGet();
                    inventTransferParmTable.ShipUpdateQty   = InventTransferShipUpdateQty::All;
                    //inventTransferParmTable.insert();
                    inventTransferUpd = InventTransferUpdShip::newParmBuffer(inventTransferParmTable);
                    inventTransferUpd.run();
                    msg = strFmt("1| Transfer order - %1 is posted", _transferId);
                }
                else
                {
                    msg = strFmt("0| Transfer order - %1 is already Received", _transferId);
                }
             
            }
            else
            {
                throw error('0| Error: Transfer order not available');
            }
            ttsCommit;
        }
        catch
        {
            msg = "0|"+" "+infolog.text(infologLine());
            infolog.clear();
        }
        return msg;
    }

}

Import data from Excel, custom lookup for dialog field in D365

In my scenario while importing data from excel I need custom lookup for parameter.
So, below code is combination of importing data from excel and custom lookup for field.

using System.IO;
using OfficeOpenXml;
using OfficeOpenXml.ExcelPackage;
using OfficeOpenXml.ExcelRange;

public class INTC_MaterialTakeOffImport
{
    public static void main(Args _args)
    {
        INTC_MaterialTakeOffImport  materialTakeOffImport = new INTC_MaterialTakeOffImport();
        try
        {
            ProjTable                   projTable;
            INTC_MaterialTakeOffTable   materialTakeOff;
            ProjId                      projId;

            if(_args.record().TableId   ==  tableNum(ProjTable))
            {
                projTable   =   _args.record();
                projId      =   projTable.ProjId;
            }
            else if(_args.record().TableId   ==  tableNum(INTC_MaterialTakeOffTable))
            {
                materialTakeOff     =   _args.record();
                projId              =   materialTakeOff.ProjId;
            }
            if(projId)
            {
                materialTakeOffImport.import(projId);
            }
            else
            {
                Error("ProjId not exist");
            }
        }
        catch
        {
            Error("Data uploading failed");
        }
    }

    public void import(ProjId       _projId)
    {
        System.IO.Stream stream;
        ExcelSpreadsheetName            sheeet;
        FileUploadBuild                 fileUpload;
        DialogGroup                     dlgUploadGroup;
        FileUploadBuild                 fileUploadBuild;
        FormBuildControl                formBuildControl;
        DialogFIeld                     mtkoNumber;
        DialogFIeld                     modelId;
        DialogFIeld                     specId;
        DialogFIeld                     procurementCategoryId;

        INTC_MaterialTakeOffTable       materialTakeOffTable;
        InventTable                     inventTable;
        InventTableModule               inventTableModule;
        numberSeq                       numSeq;
        INTC_MTKONumber                 seqId;
        numSeq  =   numberSeq::newGetNum(ProjParameters::numRefMKTONum());

        Dialog dialog       =   new Dialog("Material take off Import");
        dlgUploadGroup      =   dialog.addGroup("@SYS54759");
        formBuildControl    =   dialog.formBuildDesign().control(dlgUploadGroup.name());
        mtkoNumber          =   dialog.addField( extendedTypeStr(INTC_MTKONumber), 'MTKO Number');
        mtkoNumber.allowEdit(false);
        mtkoNumber.value(numSeq.num());
        modelId                 =   dialog.addField( extendedTypeStr(INTC_ModelId), 'Model Id');
        specId                  =   dialog.addField( extendedTypeStr(INTC_SpecId), 'Specs Id');
        procurementCategoryId   =   dialog.addField(extendedTypeStr(Name),'Procurement Category Id');
        procurementCategoryId.registerOverrideMethod(methodstr(FormStringControl, lookUp),methodstr(INTC_MaterialTakeOffImport, procurementCategoryLookup),this);
        fileUploadBuild         =   formBuildControl.addControlEx(classstr(FileUpload), "Upload");
        fileUploadBuild.style(FileUploadStyle::MinimalWithFilename);
        fileUploadBuild.fileTypesAccepted(".xlsx");

        if (dialog.run() && dialog.closedOk())
        {
            FileUpload                          fileUploadControl   = dialog.formRun().control(dialog.formRun().controlId("Upload"));
            FileUploadTemporaryStorageResult    fileUploadResult    = fileUploadControl.getFileUploadResult();

            if (fileUploadResult != null && fileUploadResult.getUploadStatus())
            {
                stream = fileUploadResult.openResult();
                using (ExcelPackage Package = new ExcelPackage(stream))
                {
                    int rowCount, i;
                    Package.Load(stream);
                    ExcelWorksheet worksheet        = package.get_Workbook().get_Worksheets().get_Item(1);
                    OfficeOpenXml.ExcelRange range  = worksheet.Cells;
                    rowCount = worksheet.Dimension.End.Row  - worksheet.Dimension.Start.Row + 1;

                    for (i = 2; i<= rowCount; i++)
                    {
                        select firstonly inventTable where inventTable.ItemId ==  range.get_Item(i, 1).value;
                        if(inventTable)
                        {
                            select inventTableModule
                            join inventTable
                            where inventTable.ItemId    ==  inventTableModule.ItemId
                            && inventTableModule.ModuleType  ==  ModuleInventPurchSales::Purch
                            && inventTableModule.ItemId ==  inventTable.ItemId;

                            ttsbegin;
                            materialTakeOffTable.ProjId                 =   _projId;
                            materialTakeOffTable.INTC_MTKONumber        =   mtkoNumber.value();
                            materialTakeOffTable.ModelId                =   modelId.value();
                            materialTakeOffTable.INTC_SpecId            =   specId.value();
                            materialTakeOffTable.ProcurementCategoryId  =   procurementCategoryId.value();
                            materialTakeOffTable.ItemId                 =   range.get_Item(i, 1).value;
                            materialTakeOffTable.Remarks                =   range.get_Item(i, 2).value;
                            materialTakeOffTable.QtyRequired            =   range.get_Item(i, 3).value;
                            materialTakeOffTable.Uom                    =   inventTableModule.UnitId;
                            materialTakeOffTable.UnitCost               =   inventTableModule.Price;
                            materialTakeOffTable.CategoryId             =   inventTable.projCategoryId;
                            materialTakeOffTable.AvailableQty           =   this.onhandQty(range.get_Item(i, 1).value);
                            materialTakeOffTable.QtyToOrder             =   materialTakeOffTable.QtyRequired - materialTakeOffTable.AvailableQty;
                            materialTakeOffTable.TotalCost              =   materialTakeOffTable.QtyRequired * inventTableModule.Price;

                            materialTakeOffTable.insert();
                            ttscommit;
                        }
                        else
                        {
                            warning(strFmt("Item Id #%1 not found in data base, line is not imported", range.get_Item(i, 1).value));
                        }
                    }
                    info("MTKO data uploaded");
                }
            }
            else
            {
                error("file not selected");
            }
        }
    }

   //Customlookup for procurement category Id
    public void procurementCategoryLookup(FormStringControl _control)
    {
        SysTableLookup          sysTableLookUp;
        QueryBuildDataSource    qbds;
        Query                   query = new Query();

        qbds = query.addDataSource(tableNum(ProjCategory));
        qbds.addRange(fieldNum(ProjCategory, CategoryType)).value(strFmt("%1", ProjCategoryType::Item));

        sysTableLookUp = SysTableLookup::newParameters(tableNum(ProjCategory), _control, true);
        sysTableLookUp.addLookupfield(fieldNum(ProjCategory, CategoryId),true);
        sysTableLookUp.addLookupfield(fieldNum(ProjCategory, Name));
        sysTableLookUp.parmQuery(query);
        sysTableLookUp.performFormLookup();
    }

    public InventQty onhandQty(ItemId    _itemId)
    {
        InventDim           inventDim;
        InventDimParm       inventDimParm;
        Itemid              itemid;
        InventOnHand        inventOnHand;
        InventQty           availQty;

        itemid = _itemId;
        inventDim.InventSiteId = '';
        inventDim.InventLocationId = '';

        inventDimParm.initFromInventDim(inventDim);

        inventOnHand    = InventOnhand::newParameters(itemid, inventDim, inventDimParm);
        availQty        = inventOnHand.availPhysical();

        return  availQty;
    }


}

Number seq in D365

**add a method in parameter table by using Extension 

[ExtensionOf(tableStr(ProjParameters))]
final class ProjParameters_Extension
{
    client server static NumberSequenceReference numRefMKTONum()
    {
        return NumberSeqReference::findReference(extendedTypeNum(INTC_MTKONumber));
    }
}


**over ride load module method of numberSeqModule class by using COC

[ExtensionOf(classStr(NumberSeqModuleProject))]
final class NumberSeqModuleProject_Extension
{
    protected void loadModule()
    {
        NumberSeqDatatype datatype = NumberSeqDatatype::construct();
        next loadModule();
        datatype.parmDatatypeId(extendedTypeNum(INTC_MTKONumber));
        datatype.parmReferenceHelp(literalStr('MTKO Number'));
        datatype.parmWizardIsContinuous(false);
        datatype.parmWizardIsManual(NoYes::No);
        datatype.parmWizardIsChangeDownAllowed(NoYes::No);
        datatype.parmWizardIsChangeUpAllowed(NoYes::No);
        datatype.parmSortField(1);
        datatype.addParameterType(NumberSeqParameterType::DataArea, true, false);
        this.create(datatype);
    }


}

**create a runnable class and load num seq by using below code

class INTC_loadNumberSeq
{
    public static void main(Args _args)
    {
        NumberSeqModuleProject    project   =   new NumberSeqModuleProject();

        project.load();
        Info('loaded');

        //numberSeq           numSeq;
        //INTC_MTKONumber     seqId;

        //numSeq  =   numberSeq::newGetNum(ProjParameters::numRefMKTONum());

        ///info(numSeq.num());
         
    }


}

**Once sequence loaded Generate num seq from Organisation and administration module 

multi select report with str replace contract parameter x++

**Contract class

[
    DataContractAttribute,
    SysOperationContractProcessingAttribute(classstr(INTC_MaterialTakeOffUIBuilder))
]
public class INTC_MaterialTakeOffContract
{
    Str1260               projId;
    Str1260               mtkoNumber;

    [
        DataMemberAttribute("ProjId"),
        SysOperationLabelAttribute(literalStr('ProjId')),
        SysOperationDisplayOrderAttribute('1')
    ]
    public Str1260 parmProjId(Str1260 _projId = projId)
    {
        projId = _projId;
        return strReplace(projId,";",",");
    }

    [
        DataMemberAttribute("MTKO Number"),
        SysOperationLabelAttribute(literalStr('MTKO Number')),
        SysOperationDisplayOrderAttribute('2')
    ]
    public Str1260 parmMTKONumber(Str1260 _mtkoNumber = mtkoNumber)
    {
        mtkoNumber = _mtkoNumber;
        return strReplace(mtkoNumber,";",",");
    }

}


**UI Builder class

public class INTC_MaterialTakeOffUIBuilder extends SrsReportDataContractUIBuilder
{
    DialogField                         dialogProjId, dialogMTKONum;
    INTC_MaterialTakeOffContract        contract;

    public void projLookup(FormStringControl _control)
    {
        Query                   query;
        container               projCon;
        QueryBuildDataSource    qbds;
   
        //Create AOT query as require
        query = new Query(queryStr(INTC_ProjLookupQuery));
        SysLookupMultiSelectGrid::lookup( query, _control, _control, _control, projCon);
    }

    public void mtkoNumLookup(FormStringControl _control)
    {
        Query                   query;
        container               mtkoCon;
        QueryBuildDataSource    qbds;
   
        //Create AOT query as require
        query = new Query(queryStr(INTC_MTKOLookupQuery));
        qbds    =   query.dataSourceTable(tableNum(INTC_MaterialTakeOffTable));
        if(dialogProjId.value())
        {
            qbds.addRange(fieldNum(INTC_MaterialTakeOffTable, ProjId)).value(dialogProjId.value());
        }
        SysLookupMultiSelectGrid::lookup( query, _control, _control, _control, mtkoCon);
    }

    public void build()
    {
        super();
        contract = this.dataContractObject();
    }

    public void postBuild()
    {
        super();
   
        dialogProjId        = this.bindInfo().getDialogField(contract,methodStr(INTC_MaterialTakeOffContract, parmProjId));
        dialogMTKONum       = this.bindInfo().getDialogField(contract,methodStr(INTC_MaterialTakeOffContract, parmMTKONumber));
   
        dialogProjId.registerOverrideMethod(methodStr(FormStringControl, lookup),methodStr(INTC_MaterialTakeOffUIBuilder, projLookup),this);
        dialogMTKONum.registerOverrideMethod(methodStr(FormStringControl, lookup),methodStr(INTC_MaterialTakeOffUIBuilder, mtkoNumLookup),this);
    }

}


**Dp class

[SRSReportParameterAttribute(classStr(INTC_MaterialTakeOffContract))]
public class INTC_MaterialTakeOffDp extends SrsReportDataProviderPreProcess//SrsReportDataProviderPreProcessTempDB//SRSReportDataProviderBase// SrsReportDataProviderPreProcess//
{
INTC_MaterialTakeOffTmp materialTakeOffTmp;
Str1260 projId, mtkoNumber;

public void processReport()
{
Query query = new Query();
QueryBuildDataSource qbds;
QueryBuildRange qbr;
QueryRun qRun;
INTC_MaterialTakeOffContract materialTakeOffContract;
INTC_MaterialTakeOffTable materialTakeOffTable;
RecordInsertList recordInsertList = null;
Name itemName;

materialTakeOffContract = this.parmDataContract() as INTC_MaterialTakeOffContract;

projId = materialTakeOffContract.parmProjId();
mtkoNumber = materialTakeOffContract.parmMTKONumber();
qbds = query.addDataSource(tableNum(INTC_MaterialTakeOffTable));
if(projId)
{
qbds.addRange(fieldNum(INTC_MaterialTakeOffTable, ProjId)).value(projId);
}

if(mtkoNumber)
{
qbds.addRange(fieldNum(INTC_MaterialTakeOffTable, INTC_MTKONumber)).value(mtkoNumber);
}
recordInsertList = new RecordInsertList(tablenum(INTC_MaterialTakeOffTmp), false,false,false,false,false);
qRun = new QueryRun(query);
while(qRun.next())
{
materialTakeOffTable = qRun.get(tableNum(INTC_MaterialTakeOffTable));

itemName = InventTable::find(materialTakeOffTmp.ItemId).itemName();

materialTakeOffTmp.ProjId = materialTakeOffTable.ProjId;
materialTakeOffTmp.INTC_MTKONumber = materialTakeOffTable.INTC_MTKONumber;
materialTakeOffTmp.INTC_SpecId = materialTakeOffTable.INTC_SpecId;
materialTakeOffTmp.CategoryId = materialTakeOffTable.CategoryId;
materialTakeOffTmp.ProcurementCategoryId = materialTakeOffTable.ProcurementCategoryId;
materialTakeOffTmp.ItemId = materialTakeOffTable.ItemId;
materialTakeOffTmp.ItemName = itemName;
materialTakeOffTmp.Remarks = materialTakeOffTable.Remarks;
materialTakeOffTmp.Uom = materialTakeOffTable.Uom;
materialTakeOffTmp.QtyRequired = materialTakeOffTable.QtyRequired;
materialTakeOffTmp.AvailableQty = materialTakeOffTable.AvailableQty;
materialTakeOffTmp.QtyToOrder = materialTakeOffTable.QtyToOrder;
materialTakeOffTmp.UnitCost = materialTakeOffTable.UnitCost;
materialTakeOffTmp.TotalCost = materialTakeOffTable.TotalCost;

recordInsertList.add(materialTakeOffTmp);
}
ttsbegin;
recordInsertList.insertDatabase();
ttscommit;
}

[SRSReportDataSetAttribute(tablestr(“INTC_MaterialTakeOffTmp”))]
public INTC_MaterialTakeOffTmp getMaterialTakeOffContract()
{
materialTakeOffTmp.setConnection(this.parmUserConnection());
select materialTakeOffTmp;
return materialTakeOffTmp;
}

}