D365F&O - X++ - Create Service class for consuming 3rd party API using Basic Authentication method

 We are going to create a service that sends data in following format:

{
  "amount" : {
    "currency" : "AED",
    "value" : 5000
  },
  "CustomerName" : "Test Customer",
  "SalesOrderID" : "SO-0001"
}

1- First of all, we are going to create request contract to send the above JSON to the postman.

2- create a class for request amount since it has 2 values that are combined and make one amount.

[DataContract]
class SalesOrderAmountDetailsContract
{
    Amount lineAmount;
    CurrencyCode currencyCode;

    /// <summary>
    /// Line Amount parameter
    /// </summary>
    /// <param name = "_lineAmount">lineAmount</param>
    /// <returns>lineAmount</returns>
    [DataMember('value')]
    public Amount parmlineAmount(Amount _lineAmount = lineAmount)
    {
        lineAmount = _lineAmount;
        return lineAmount;
    }

    /// <summary>
    /// Currency Code parameter
    /// </summary>
    /// <param name = "_CurrencyCode">CurrencyCode</param>
    /// <returns>CurrencyCode</returns>
    [DataMember('currency')]
    public CurrencyCode parmCurrencyCode(CurrencyCode _currencyCode = currencyCode)
    {
        currencyCode = _currencyCode;
        return currencyCode;
    }

}

3- Create another request contract that has the variables for other two values and one object for

SalesOrderAmountDetailsContract class.

[DataContract]
class SalesOrderRequestContract
{
    SalesOrderAmountDetailsContract amountDetails;
    str CustomerName;
    str SalesOrderID;

    /// <summary>
    /// Amount Details Contract parameter
    /// </summary>
    /// <param name = "_AmountDetails">AmountDetails</param>
    /// <returns>AmountDetails</returns>
    [DataMember('amount')]
    public SalesOrderAmountDetailsContract parmAmountDetails(
        SalesOrderAmountDetailsContract _amountDetails = amountDetails)
    {
        amountDetails = _amountDetails;
        return amountDetails;
    }

    /// <summary>
    /// CustomerName parameter
    /// </summary>
    /// <param name = "_CustomerName">CustomerName</param>
    /// <returns>CustomerName</returns>
    [DataMember('CustomerName')]
    public str parmCustomerName(str _CustomerName = CustomerName)
    {
        CustomerName = _CustomerName;
        return CustomerName;
    }

    /// <summary>
    /// Merchant Account parameter
    /// </summary>
    /// <param name = "_SalesOrderID">SalesOrderID</param>
    /// <returns>SalesOrderID</returns>
    [DataMember('SalesOrderID')]
    public str parmSalesOrderID(str _SalesOrderID = SalesOrderID)
    {
        SalesOrderID = _SalesOrderID;
        return SalesOrderID;
    }

}

3- Lets assume the response is going to be status. Create a response contract class

to receive the response.

[DataContract]
class SalesOrderResponseContract
{    
    str status;

    /// <summary>
    /// status parameter
    /// </summary>
    /// <param name = "status">status</param>
    /// <returns>status</returns>
    [DataMember('status')]
    public str parmstatus(str _status = status)
    {
       status = _status;
        return status;
    }
}

4- create a service class in which we are going to send the request and recieve the response.

class SalesOrderRefundService
{
    /// <summary>
    /// Consume client API
    /// This method is used for sending sales order details
    /// and getting relevant information in response
    /// </summary>
    public void processRefund(SalesTable _SalesTable)
    {
        str requestJson, responseJson;
        //Classes Require for consume API
        System.Net.HttpWebRequest       request;
        System.Net.HttpWebResponse      response;
        CLRObject                       clrObj;
        System.Exception                exception;
        System.Net.WebHeaderCollection  httpHeader;
        System.IO.Stream                requestStream;
       
        System.Byte[]         bytes;
        System.Text.Encoding     utf8;
        System.Text.Encoding encoding = System.Text.Encoding::get_UTF8();

        SalesOrderRequestContract       RequestContract = new SalesOrderRequestContract();
        SalesOrderAmountDetailsContract     AmountDetailsContract =  new SalesOrderAmountDetailsContract();
        SalesOrderResponseContract  ResponseContract = new SalesOrderResponseContract();
        str username =  "TestUser";
        str password =  "1234567890";

        // Set Request parameters values
        AmountDetailsContract.parmCurrencyCode(_SalesTable.CurrencyCode);
        AmountDetailsContract.parmlineAmount(_SalesTable.RefundAmount);

        RequestContract.parmAmountDetails(AmountDetailsContract);
        RequestContract.parmCustomerName(_SalesTable.Custname());
        RequestContract.parmSalesOrderID(_SalesTable.salesID);

        // Convert contract class object to Json
        requestJson =  FormJsonSerializer::serializeClass(RequestContract);        
        try
        {
            // Web API Request Section
            httpHeader = new System.Net.WebHeaderCollection();
            new InteropPermission(InteropKind::ClrInterop).assert();

            // API EndPoint
            clrObj = System.Net.WebRequest::Create("https://test.com/refunds");
            request = clrObj;

            // Set API Header
            str credentials = username + ':' + password;
            System.Byte[] byteArraynew    = encoding.GetBytes(credentials);
            credentials         = System.Convert::ToBase64String(byteArraynew);
           
            httpHeader.Add("Authorization", 'Basic ' + credentials);
            request.set_Headers(httpHeader);
            request.ContentType = "application/json";
           
           
            // Set Post Parameters
            request.Method = "POST";
            utf8 = System.Text.Encoding::get_UTF8();
            bytes = utf8.GetBytes(requestJson);
            request.set_ContentLength(bytes.get_Length());
            requestStream = request.GetRequestStream();
            requestStream.Write(bytes, 0, bytes.get_Length());            

            // Response Section

            // Get API Response
            response = request.GetResponse();

            // Read Response
            System.IO.StreamReader streamRead;
            streamRead = new System.IO.StreamReader(response.GetResponseStream());

            // Json Decode
            responseJson = streamRead.ReadToEnd();
            ResponseContract = FormJsonSerializer::deserializeObject(
                classStr(SalesOrderResponseContract),responseJson);
            info(ResponseContract.parmstatus());
        }
        catch
        {
            exception = CLRInterop::getLastException().GetBaseException();
            Error(exception.get_Message());
        }
       
    }    

}


Comments

Popular posts from this blog

D365F&O - X++ - Best Practice Warning BP Rule: [BPErrorUnknownLabel]: Path:

D365F&O - X++ - How to Enable/Disable button on form based on a condition in D365F&O using Event handlers.

D365FO - X++ - Generate CAR (Customized Analysis Report) report of custom model