to get package information through command d365

open command prompt as a admin

point to drive where application hosted. In my case it is C:

run below command.

c:\AOSService\PackagesLocalDirectory\Bin\xppbp.exe -metadata=c:\AOSService\PackagesLocalDirectory -all -model="ApplicationSuite.INTC_EXP" -xmlLog=BPCheckLog_ApplicationSuite.xml -module=ApplicationSuite -car=c:\temp\Log_ApplicationSuite.xlsx
c:\AOSService\PackagesLocalDirectory\Bin\xppbp.exe -metadata=c:\AOSService\PackagesLocalDirectory -all -model="Directory.INTC_EXP" -xmlLog=BPCheckLog_Directory.xml -module=Directory -car=c:\temp\Log_Directory.xlsx
c:\AOSService\PackagesLocalDirectory\Bin\xppbp.exe -metadata=c:\AOSService\PackagesLocalDirectory -all -model="INTC_EXP" -xmlLog=BPCheckLog_INTC_EXP.xml -module=INTC_EXP -car=c:\temp\Log_INTC_EXP.xlsx
pause

Create excel template in d365

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

class INTC_MTKOTemplate
{
    #define.ItemNumber("Item number")
    #define.ItemName("Item name")
    #define.QtyRequired("Quantity required")
    #define.Remarks("Remarks")
   
    public static void main(Args    args)
    {
        MemoryStream            memoryStream = new MemoryStream();
        INTC_MTKOTemplate       mtkoTemplate = INTC_MTKOTemplate::construct();

        mtkoTemplate.generateTemplate(memoryStream);
    }

    public static INTC_MTKOTemplate construct()
    {
        return new INTC_MTKOTemplate();
    }

    public void generateTemplate(MemoryStream   _memoryStream = new MemoryStream())
    {
        using (var package = new ExcelPackage(_memoryStream))
        {
            var                 currentRow = 1;
            var                 worksheets = package.get_Workbook().get_Worksheets();
            var                 worksheet = worksheets.Add('Template');
            var                 cells = worksheet.get_Cells();
            System.String       coloum;
            ExcelRange          cell;

            coloum = #ItemNumber;
            cell = cells.get_Item(currentRow, 1);
            cell.set_Value(coloum);
            cell = null;

            coloum = #ItemName;
            cell = cells.get_Item(currentRow, 2);
            cell.set_Value(coloum);
            cell = null;

            coloum = #QtyRequired;
            cell = cells.get_Item(currentRow, 3);
            cell.set_Value(coloum);
            cell = null;

            coloum = #Remarks;
            cell = cells.get_Item(currentRow, 4);
            cell.set_Value(coloum);
            cell = null;

            package.Save();

            file::SendFileToUser(_memoryStream, 'MTKO lines template.xlsx');
        }
    }

}

Export data to excel in d365

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

class INTC_ExpenseTemplate
{
    #define.TransactionDate("Transaction date")
    #define.ExpenseType("Expense type")
    #define.Amount("Amount")
    #define.ProjId("Project Id")
    #define.SalesTaxGroup("Sales tax group")
    #define.TaxItemGroup("Tax item group")
    #define.ReceiptNumber("Receipt number")
    #define.AdditionalInformation("Additional information")
   
    public static void main(Args  _args)
    {
        TrvExpTrans             trvExpTrans;
        TrvExpTable             trvExpTable;
        MemoryStream            memoryStream = new MemoryStream();
        INTC_ExpenseTemplate    expenseTemplate = INTC_ExpenseTemplate::construct();

        trvExpTrans     =   _args.record();
        expenseTemplate.generateTemplate(trvExpTrans.ExpNumber, memoryStream);
    }

    public static INTC_ExpenseTemplate construct()
    {
        return new INTC_ExpenseTemplate();
    }

    public void generateTemplate(TrvExpNumber  _expNum, MemoryStream   _memoryStream = new MemoryStream())
    {
        using (var package = new ExcelPackage(_memoryStream))
        {
            var                 currentRow = 1;
            var                 worksheets = package.get_Workbook().get_Worksheets();
            var                 worksheet = worksheets.Add('Template');
            var                 cells = worksheet.get_Cells();
            System.String       coloum;
            TrvExpTrans         trvExpTrans;

            OfficeOpenXml.ExcelRange cell = cells.get_Item(currentRow, 1);
            System.String value = #TransactionDate;
            cell.set_Value(value);
            cell = null;

            value = #ExpenseType;
            cell = cells.get_Item(currentRow, 2);
            cell.set_Value(value);

            value = #Amount;
            cell = cells.get_Item(currentRow, 3);
            cell.set_Value(value);

            value = #ProjId;
            cell = cells.get_Item(currentRow, 4);
            cell.set_Value(value);

            value = #SalesTaxGroup;
            cell = cells.get_Item(currentRow, 5);
            cell.set_Value(value);

            value = #TaxItemGroup;
            cell = cells.get_Item(currentRow, 6);
            cell.set_Value(value);

            value = #ReceiptNumber;
            cell = cells.get_Item(currentRow, 7);
            cell.set_Value(value);

            value = #AdditionalInformation;
            cell = cells.get_Item(currentRow, 8);
            cell.set_Value(value);

            while select trvExpTrans where trvExpTrans.ExpNumber    ==  _expNum
            {
                currentRow++;
                coloum = #TransactionDate;
                cell = cells.get_Item(currentRow, 1);
                cell.set_Value(trvExpTrans.TransDate);
                cell = null;

                coloum = #ExpenseType;
                cell = cells.get_Item(currentRow, 2);
                cell.set_Value(trvExpTrans.CostType);
                cell = null;

                coloum = #Amount;
                cell = cells.get_Item(currentRow, 3);
                cell.set_Value(trvExpTrans.AmountCurr);
                cell = null;

                coloum = #ProjId;
                cell = cells.get_Item(currentRow, 4);
                cell.set_Value(trvExpTrans.ProjId);
                cell = null;

                coloum = #SalesTaxGroup;
                cell = cells.get_Item(currentRow, 5);
                cell.set_Value(trvExpTrans.TaxGroup);
                cell = null;

                coloum = #TaxItemGroup;
                cell = cells.get_Item(currentRow, 6);
                cell.set_Value(trvExpTrans.TaxItemGroup);
                cell = null;

                coloum = #ReceiptNumber;
                cell = cells.get_Item(currentRow, 7);
                cell.set_Value(trvExpTrans.ReceiptNumber);
                cell = null;

                coloum = #AdditionalInformation;
                cell = cells.get_Item(currentRow, 8);
                cell.set_Value(trvExpTrans.AdditionalInformation);
                cell = null;
            }
            package.Save();
            file::SendFileToUser(_memoryStream, 'Expense lines template.xlsx');
        }
    }

}

read multi selected records from grid x++

public void clicked()
{
INTC_UnitDetails        unitDetails;
MultiSelectionHelper    helper = MultiSelectionHelper::construct();
boolean                 validate;

helper.parmDatasource(INTC_UnitDetails_ds);

unitDetails = helper.getFirst();
while (unitDetails.RecId != 0)
{
if(unitDetails.WCNDate != dateNull() || unitDetails.DLNDate != dateNull())
{
validate    =   true;
info(strFmt("%1", unitDetails.RecId));
}
else
{
validate    =   false;
}
unitDetails = helper.getNext();
}
if(validate == true)
{
super();
}
else
{
warning("PCN date or DLN date should not empty");
}
}

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;
        }

Form post_init in D365

[PostHandlerFor(formStr(PSAUpdatePercent), formMethodStr(PSAUpdatePercent, init))]
    public static void PSAUpdatePercent_Post_init(XppPrePostArgs args)
    {
        real                            percent;
        FormRun                         formRun =   args.getThis();
        FormRealControl                 realControl, currentPercent;
        real                            currentValue;
        PSAContractLineItems            pasContractLineItems=   formRun.args().record();
        INTC_UnitDetails_EventHandler   eventHanlderClass   =    new INTC_UnitDetails_EventHandler();

        percent         =   eventHanlderClass.getPercent(pasContractLineItems.RecId);
        realControl     =   formRun.design().controlName('RevisedPercent');
        currentPercent  =   formRun.design().controlName('currentPercent');
        currentValue    =   currentPercent.realValue();

        realControl.realValue(percent-currentValue);
    }

Form data source OnInitialized D365

[FormDataSourceEventHandler(formDataSourceStr(ProjProjectsListPage, ProjTable), FormDataSourceEventType::Initialized)]
    public static void ProjTable_OnInitialized(FormDataSource sender, FormDataSourceEventArgs e)
    {
        ProjTable                   projTable     = sender.cursor();
        FormDataSource              projTable_ds  = sender.formRun().dataSource('ProjTable');
        FormRun                     element       = sender.formRun();
        FormControl                 groupChangeButton;
   
        groupChangeButton = element.design().controlName("ProjGroupChange");
        groupChangeButton.visible(false);
    }

Pre prompt, Pre run x++

//called before contract initialized

public void prePromptModifyContract()
{
SrsReportHelper::addParameterValueRangeToQuery(this.getFirstQuery(),tableNum(SSRSReportTest),fieldNum(SSRSReportTest, RecId),SysQuery::value(this.parmArgs().record().RecId));
}

//called before report get initialized (dp class)

protected void preRunModifyContract()
{
SSRSTestContract contract;

contract = this.parmReportContract().parmRdpContract() as SSRSTestContract;

contract.parmType(this.parmArgs().parm());
}

//to call report in controller

ssrsTestController.parmReportName(ssrsReportStr(Report, Design));

passing args on_clicked event handler D365

[FormControlEventHandler(formControlStr(PSAContractStatus, INTC_UnitDetails), FormControlEventType::Clicked)]
    public static void INTC_UnitDetails_OnClicked(FormControl sender, FormControlEventArgs e)
    {
        str         contractId;
        ProjTable   projTable;
        Args        args       = new Args();
        Form        formToCall = new Form('INTC_UnitDetailsTracking');

        FormButtonControl callerButton = sender as FormButtonControl;
        FormRun form = callerButton.formRun();

        //FormDataSource hcmWorker_ds = form.dataSource(formDataSourceStr(HcmWorker, HcmWorker)) as FormDataSource;
        //HcmWorker hcmWorker = hcmWorker_ds.cursor();

        contractId  =   form.design().controlName('ContractEdit').valueStr();
        select projTable   where projTable.ProjInvoiceProjId    ==  contractId;

        args.caller(form);
        args.object(formToCall );
        args.record(projTable);

        form = ClassFactory.formRunClass(args);
        form.init();
        form.run();
        form.wait();
    }

item on hand costPrice by site warehouse x++

class OnhandItemPriceTest
{
    public static void Main(Args _args)
    {
        InventDim       inventDim;
        InventDimParm   inventDimParm;
        InventOnHand    inventOnHand;
        InventSum       inventSum;

        select firstOnly inventSum where inventSum.ItemId == 'RSH 01';

        inventDim.InventLocationId  = "MainOffice";
        inventdim.InventSiteId      = "MainOffice";

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

        info(strfmt("%1", inventOnHand.costPricePcs()));
    }

}

on hand item unit x++

class ItemOnhandUnitTest
{       
    public static void main(Args _args)
    {
        UnitOfMeasureSymbol         unitIdSecondary;
        UnitOfMeasureSymbol         unitIdTemp;
        boolean                     allowEditUnit;

        [unitIdTemp, allowEditUnit] = InventOnhand::inventModuleUnitsSelectionToUnitIdAllowEdit(InventModuleUnits::InventoryUnit, "RSH 01", unitIdSecondary);

        info(strFmt("%1", unitIdTemp));
    }

}

tree lookup for reference group d365

//class declreation
EcoResCategoryHierarchy         procurementCategoryHierarchy;
SalesTableForm                  salesTableForm;

//form init
public void init()
    {
        super();
        procurementCategoryHierarchy    = EcoResCategoryHierarchy::find(EcoResCategoryHierarchyRole::getHierarchiesByRole(EcoResCategoryNamedHierarchyRole::Procurement).CategoryHierarchy);
        salesTableForm                  = SalesTableForm::construct(SalesTableFormId::None, element.args().record());
    }

//field methods under datasource
[DataField]
        class ProcurementCategoryId
        {
            public Common lookupReference(FormReferenceControl _formReferenceControl)
            {
                Common ret;
                   
                ret = EcoResCategory::lookupCategoryHierarchy(
                        _formReferenceControl,
                        procurementCategoryHierarchy,
                        false,
                        true,
                        true,
                        null,
                        CompanyInfo::find().RecId,//purchReqLine.BuyingLegalEntity,
                        CompanyInfo::find().RecId//purchReqLine.ReceivingOperatingUnit
                    );
                   
                return ret;
            }

            public Common resolveReference(FormReferenceControl _formReferenceControl)
            {
                Common ret;
           
                ret = EcoResCategory::resolveCategoryHierarchy(
                        _formReferenceControl,
                        procurementCategoryHierarchy,
                        false,
                        true,
                        true
                    );
           
                return ret.RecId? ret : null;
            }

        }

//Item modified
public void modified()
{
EcoResProductCategory       ecoresCatergory;
InventTable                 inventTable;
super();
select inventTable
join ecoresCatergory
where inventTable.ItemId ==  INTC_MaterialTakeOffTable.ItemId
&& ecoresCatergory.Product ==  inventTable.Product;

INTC_MaterialTakeOffTable.ProcureCategoryRecId    =   ecoresCatergory.Category;
}

currency exchange rate in D365

[Extensionof(tableStr(Currency))]
final class Currency_Extension
{
    public static ExchRate exchRate(CurrencyCode            _currencyCode,
                                    TransDate               _exchRateDate            = systemDateGet(),
                                    ExchRatesTriangulation  _exchRatesTriangulation  = UnknownNoYes::Unknown,
                                    boolean                 _showerror               = true,
                                    GovernmentExchRate      _governmentExchRate      = NoYes::No)
   
    {
        ExchangeRateHelper exchangeRateHelper = ExchangeRateHelper::newExchangeDate( Ledger::current(),
                                                                                     _currencyCode,
                                                                                     _exchRateDate);
        if (!_showerror)
        {
            exchangeRateHelper.parmErrorType(AifErrorType::None);
        }

        return exchangeRateHelper.getExchangeRate1();
    }

}

OnLookup D365

class INTC_JournalNameLookup_EventHandler
{
    [FormControlEventHandler(formControlStr(ProjParameters, ProjParameters_INTC_JournalName), FormControlEventType::Lookup)]
    public static void ProjParameters_INTC_JournalName_OnLookup(FormControl sender, FormControlEventArgs e)
    {
        FormRun                     element = sender.formRun();
        SysTableLookup              sysTableLookup  = SysTableLookup::newParameters(tableNum(LedgerJournalName),sender);
        Query                       query;
        QueryBuildDataSource        qbds;

        sysTableLookup.addLookupfield(fieldnum(LedgerJournalName,JournalName),true);
        sysTableLookup.addLookupfield(fieldnum(LedgerJournalName,Name));

        query = new Query();
        qbds  = query.addDataSource(tableNum(LedgerJournalName));

        sysTableLookup.parmQuery(query);
        sysTableLookup.parmUseLookupValue(true);
        sysTableLookup.performFormLookup();

        FormControlCancelableSuperEventArgs ce = e as FormControlCancelableSuperEventArgs;
        ce.CancelSuperCall();
    }

}

To update SID in SQL server

SQL ---> new query

OnInitialize - access form controls in D365

go to Form- Events - OnInitialize - copy event handler

[FormEventHandler(formStr(ProjTableCreate), FormEventType::Initialized)]
    public static void ProjTableCreate_OnInitialized(xFormRun sender, FormEventArgs e)
    {
        MenuItemName        menuItemName    =   sender.args().menuItemName();

        if(menuItemName ==  "ProjTableCreateSubproject")
        {
            sender.design().controlName('ProjTable_INTC_Code').visible(false);
        }
        else
        {
            sender.design().controlName('ProjTable_INTC_Code').visible(true);
        }
    }

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));
    }

}

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;
    }

}

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();
    }

}

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;
    }


}