S5. Method Listing | User Guide

GET App.ApiTest

Used to Test Connectivity and API Protocol Handshaking

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
IsError bool	Set IsError = 1 to Generate an Error Response
InputData string	Will Be Included in Response Headers and XML Payload 'ReturnData' Field

Responses

XwsResultCode	XwsResultInfo
0	Success
4001	Simulated Error
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=App.ApiTest&ProjectId=1000"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "App.ApiTest"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000' } 

    print("Now invoking App.ApiTest")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "App.ApiTest"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - App.ApiTest */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "App.ApiTest";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'App.ApiTest';
   $projectId = '1000';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="App" ServiceMethod="App.ApiTest" RequestId="7CBE1506FA18484B8D74855395AD693C" RequestDate="2019-11-21T00:16:34Z" ResponseDate="2019-11-21T00:16:34Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191121-001634284-7CBE1506FA18484B8D74855395AD693C--App-ApiTest" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
         <TestData IsError="" InputData="" ReturnData=""></TestData>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	App.ApiTest
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET System.AppVersionHistory

Shows full version installation and update history, listing records for the base install and every product update.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId int	Project ID - If blank, system API settings will be used.

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=System.AppVersionHistory"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "System.AppVersionHistory"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters = None

    print("Now invoking System.AppVersionHistory")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "System.AppVersionHistory"

   // add additional parameters
   additionalParameters := make(map[string]string)

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - System.AppVersionHistory */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "System.AppVersionHistory";

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: null);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'System.AppVersionHistory';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="System" ServiceMethod="System.AppVersionHistory" RequestId="93BE21C168CC4C2BAE2FD0A4E6D6A9AE" RequestDate="2019-11-19T23:58:31Z" ResponseDate="2019-11-19T23:58:31Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191119-235831136-93BE21C168CC4C2BAE2FD0A4E6D6A9AE--System-AppVersionHistory" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <AppVersionHistory>
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-11-03T01:47:31Z" UpdateDate="2019-11-03T01:47:31Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.1002.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-10-02T14:16:36Z" UpdateDate="2019-10-02T14:16:36Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0910.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-07-29T05:43:56Z" UpdateDate="2019-07-29T05:43:56Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0728.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-07-01T05:47:52Z" UpdateDate="2019-07-01T05:47:52Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0628.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-06-14T15:40:30Z" UpdateDate="2019-06-14T15:40:30Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0602.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-06-07T13:11:20Z" UpdateDate="2019-06-07T13:11:20Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0521.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-05-23T19:09:00Z" UpdateDate="2019-05-23T19:09:00Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0515.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-05-03T09:15:46Z" UpdateDate="2019-05-03T09:15:46Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0501.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-04-16T09:08:01Z" UpdateDate="2019-04-16T09:08:01Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0409.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-04-06T03:20:55Z" UpdateDate="2019-04-06T03:20:55Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0402.01" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-02-01T00:20:49Z" UpdateDate="2019-02-01T00:20:49Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0125.02" VersionPack="" LicenseKey="" />
           <AppVersionInfo ProductId="XDOC" InstallDate="2019-01-10T05:59:36Z" UpdateDate="2019-01-10T05:59:36Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.0105.01" VersionPack="" LicenseKey="" />
       </AppVersionHistory>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	System.AppVersionHistory
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET System.AppVersionInfo

Outputs current production version information.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId int	Project ID - If blank, system API settings will be used.

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=System.AppVersionInfo"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "System.AppVersionInfo"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters = None

    print("Now invoking System.AppVersionInfo")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "System.AppVersionInfo"

   // add additional parameters
   additionalParameters := make(map[string]string)

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - System.AppVersionInfo */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "System.AppVersionInfo";

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: null);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'System.AppVersionInfo';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="System" ServiceMethod="System.AppVersionInfo" RequestId="D71104ECB6FA4F2DB4B84B583F44ABC2" RequestDate="2019-11-20T00:00:18Z" ResponseDate="2019-11-20T00:00:18Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191120-000018574-D71104ECB6FA4F2DB4B84B583F44ABC2--System-AppVersionInfo" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <AppVersionInfo ObjectId="" ProductId="XDOC" InstallDate="2019-11-03T01:47:31Z" UpdateDate="2019-11-03T01:47:31Z" ProductName="XDOC" ProductEdition="" VersionNbr="6100" VersionBuild="6100.0.2019.1002.01" VersionPack="" LicenseKey=""></AppVersionInfo>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	System.AppVersionInfo
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET System.SecurityProfileInfo

Used to get Security Profile Information in XML format including Project Grants.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId int	Project ID - If blank, system API settings will be used.

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=System.SecurityProfileInfo"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "System.SecurityProfileInfo"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters = None

    print("Now invoking System.SecurityProfileInfo")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "System.SecurityProfileInfo"

   // add additional parameters
   additionalParameters := make(map[string]string)

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - System.SecurityProfileInfo */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "System.SecurityProfileInfo";

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: null);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'System.SecurityProfileInfo';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="System" ServiceMethod="System.SecurityProfileInfo" RequestId="EBD6B7E45703461CA76234E579AF70EA" RequestDate="2019-11-20T00:09:56Z" ResponseDate="2019-11-20T00:09:56Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191120-000956168-EBD6B7E45703461CA76234E579AF70EA--System-SecurityProfileInfo" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <SecurityProfileList>
           <SecurityProfile ProfileId="2171219202804260003" Name="Advanced" Code="Advanced" SecurityLevel="0" RoleId="2022000000000000004" RoleName="Advanced" RoleSecurityLevel="15" ProjectGrantCount="2">
               <ProjectGrantList>
                   <ProjectGrant ProjectId="1003" ProjectCode="ImageFlowSvc" ProjectName="ImageFlowSvc" ProjectDescription="" />
                   <ProjectGrant ProjectId="1000" ProjectCode="LD" ProjectName="Loan Documents" ProjectDescription="Loan Documents" />
               </ProjectGrantList>
           </SecurityProfile>
           <SecurityProfile ProfileId="2026000000000000007" Name="Guest" Code="GUEST" SecurityLevel="20" RoleId="2022000000000000007" RoleName="Guest" RoleSecurityLevel="15" ProjectGrantCount="2">
               <ProjectGrantList>
                   <ProjectGrant ProjectId="1003" ProjectCode="ImageFlowSvc" ProjectName="ImageFlowSvc" ProjectDescription="" />
                   <ProjectGrant ProjectId="1000" ProjectCode="LD" ProjectName="Loan Documents" ProjectDescription="Loan Documents" />
               </ProjectGrantList>
           </SecurityProfile>
           <SecurityProfile ProfileId="2170608164050926000" Name="Standard" Code="Standard" SecurityLevel="0" RoleId="2022000000000000005" RoleName="Standard" RoleSecurityLevel="15" ProjectGrantCount="2">
               <ProjectGrantList>
                   <ProjectGrant ProjectId="1003" ProjectCode="ImageFlowSvc" ProjectName="ImageFlowSvc" ProjectDescription="" />
                   <ProjectGrant ProjectId="1000" ProjectCode="LD" ProjectName="Loan Documents" ProjectDescription="Loan Documents" />
               </ProjectGrantList>
           </SecurityProfile>
           <SecurityProfile ProfileId="2190130152626260006" Name="TESTPROFILE" Code="TESTPROFILE" SecurityLevel="0" RoleId="2190130152407220005" RoleName="TESTROLE" RoleSecurityLevel="0" ProjectGrantCount="2">
               <ProjectGrantList>
                   <ProjectGrant ProjectId="1003" ProjectCode="ImageFlowSvc" ProjectName="ImageFlowSvc" ProjectDescription="" />
                   <ProjectGrant ProjectId="1000" ProjectCode="LD" ProjectName="Loan Documents" ProjectDescription="Loan Documents" />
               </ProjectGrantList>
           </SecurityProfile>
           <SecurityProfile ProfileId="2190627223726260007" Name="Underwriter" Code="Underwriter" SecurityLevel="0" RoleId="2190627223740220006" RoleName="Underwriter" RoleSecurityLevel="0" ProjectGrantCount="1">
               <ProjectGrantList>
                   <ProjectGrant ProjectId="1000" ProjectCode="LD" ProjectName="Loan Documents" ProjectDescription="Loan Documents" />
               </ProjectGrantList>
           </SecurityProfile>
           <SecurityProfile ProfileId="2026000000000000005" Name="User" Code="USER" SecurityLevel="20" RoleId="2022000000000000005" RoleName="Standard" RoleSecurityLevel="15" ProjectGrantCount="2">
               <ProjectGrantList>
                   <ProjectGrant ProjectId="1003" ProjectCode="ImageFlowSvc" ProjectName="ImageFlowSvc" ProjectDescription="" />
                   <ProjectGrant ProjectId="1000" ProjectCode="LD" ProjectName="Loan Documents" ProjectDescription="Loan Documents" />
               </ProjectGrantList>
           </SecurityProfile>
           <SecurityProfile ProfileId="2180817221236260005" Name="ZTestCxab" Code="ZTestCxab" SecurityLevel="0" RoleId="2180817221159220004" RoleName="ZTestCxab" RoleSecurityLevel="0" ProjectGrantCount="4">
               <ProjectGrantList>
                   <ProjectGrant ProjectId="1003" ProjectCode="ImageFlowSvc" ProjectName="ImageFlowSvc" ProjectDescription="" />
                   <ProjectGrant ProjectId="1001" ProjectCode="LD2" ProjectName="Loan Docs 2" ProjectDescription="" />
                   <ProjectGrant ProjectId="1000" ProjectCode="LD" ProjectName="Loan Documents" ProjectDescription="Loan Documents" />
                   <ProjectGrant ProjectId="1002" ProjectCode="XBigData" ProjectName="XBig Data" ProjectDescription="" />
               </ProjectGrantList>
           </SecurityProfile>
       </SecurityProfileList>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	System.SecurityProfileInfo
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Project.DocumentStackList

Returns a list of Document Stacks for the project, optionally filtered by the Include related usage parameters.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
UsageFlags int	UsageFlags is a bit mask indicating which stacks to include in the results; 1 = Marked for use in Security Profiles, 2 = Marked for use in Printing, 4 = Marked for use in Bundling, 8 = Marked for use in Viewing (Viewers)

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Project.DocumentStackList&ProjectId=1000"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Project.DocumentStackList"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000' } 

    print("Now invoking Project.DocumentStackList")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Project.DocumentStackList"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Project.DocumentStackList */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Project.DocumentStackList";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Project.DocumentStackList';
   $projectId = '1000';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Project" ServiceMethod="Project.DocumentStackList" RequestId="4DCC129B72EE4CB1806086DC2A4922BB" RequestDate="2019-11-20T23:40:50Z" ResponseDate="2019-11-20T23:40:50Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191120-234050814-4DCC129B72EE4CB1806086DC2A4922BB--Project-DocumentStackList" ReturnData="2170608163643986000" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <DocumentStackList>
           <DocumentStack StackId="2171219221043860011" ProjectId="1000" Code="Adv-Edit" Name="Adv-Edit" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2171219221427860012" ProjectId="1000" Code="Adv-Upload" Name="Adv-Upload" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2171219220731860010" ProjectId="1000" Code="Adv-View" Name="Adv-View" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726165930860003" ProjectId="1000" Code="Guest-Edit" Name="Guest-Edit" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726170000860004" ProjectId="1000" Code="Guest-EditType" Name="Guest-EditType" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726165852860002" ProjectId="1000" Code="Guest-Upload" Name="Guest-Upload" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726165554860001" ProjectId="1000" Code="Guest-View" Name="Guest-View" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170925182043860007" ProjectId="1000" Code="Misc" Name="MIsc" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170925183014860008" ProjectId="1000" Code="None" Name="None" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170628231735986000" ProjectId="1000" Code="Sec-0-Docs" Name="Sec-0-Docs" Description="" SecurityLevel="0" Sequence="0" UsageFlags="11" UseInProfile="1" UseInView="1" UseInBundle="0" UseInPrint="1" />
           <DocumentStack StackId="2170608165458986001" ProjectId="1000" Code="Std-Edit" Name="Std-Edit" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170608165635986003" ProjectId="1000" Code="Std-EditType" Name="Std-EditType" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170608165544986002" ProjectId="1000" Code="Std-Upload" Name="Std-Upload" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170608163643986000" ProjectId="1000" Code="Std-View" Name="Std-View" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
       </DocumentStackList>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Project.DocumentStackList
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Project.DocumentStackProfileList

Equivalent to DocumentStackList, but only includes Stacks marked for use in Profiles.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId int	Project ID

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Project.DocumentStackProfileList"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Project.DocumentStackProfileList"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters = None

    print("Now invoking Project.DocumentStackProfileList")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Project.DocumentStackProfileList"

   // add additional parameters
   additionalParameters := make(map[string]string)

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Project.DocumentStackProfileList */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Project.DocumentStackProfileList";

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: null);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Project.DocumentStackProfileList';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Project" ServiceMethod="Project.DocumentStackProfileList" RequestId="3F2862300CC84986B4C5598113604B19" RequestDate="2019-11-20T23:56:20Z" ResponseDate="2019-11-20T23:56:20Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191120-235620799-3F2862300CC84986B4C5598113604B19--Project-DocumentStackProfileList" ReturnData="2170608163643986000" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <DocumentStackList>
           <DocumentStack StackId="2171219221043860011" ProjectId="1000" Code="Adv-Edit" Name="Adv-Edit" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2171219221427860012" ProjectId="1000" Code="Adv-Upload" Name="Adv-Upload" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2171219220731860010" ProjectId="1000" Code="Adv-View" Name="Adv-View" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726165930860003" ProjectId="1000" Code="Guest-Edit" Name="Guest-Edit" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726170000860004" ProjectId="1000" Code="Guest-EditType" Name="Guest-EditType" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726165852860002" ProjectId="1000" Code="Guest-Upload" Name="Guest-Upload" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170726165554860001" ProjectId="1000" Code="Guest-View" Name="Guest-View" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170925182043860007" ProjectId="1000" Code="Misc" Name="MIsc" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170925183014860008" ProjectId="1000" Code="None" Name="None" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170628231735986000" ProjectId="1000" Code="Sec-0-Docs" Name="Sec-0-Docs" Description="" SecurityLevel="0" Sequence="0" UsageFlags="11" UseInProfile="1" UseInView="1" UseInBundle="0" UseInPrint="1" />
           <DocumentStack StackId="2170608165458986001" ProjectId="1000" Code="Std-Edit" Name="Std-Edit" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170608165635986003" ProjectId="1000" Code="Std-EditType" Name="Std-EditType" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170608165544986002" ProjectId="1000" Code="Std-Upload" Name="Std-Upload" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
           <DocumentStack StackId="2170608163643986000" ProjectId="1000" Code="Std-View" Name="Std-View" Description="" SecurityLevel="0" Sequence="0" UsageFlags="1" UseInProfile="1" UseInView="0" UseInBundle="0" UseInPrint="0" />
       </DocumentStackList>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Project.DocumentStackProfileList
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Project.DocumentStackTypeList

Returns a list of Document Type definitions for the project and Document Stack.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
StackCode *Required string	The StackCode can either be the internal Document Stack 19 digit id, or the Document Stack Code, which is unique by Project.

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Project.DocumentStackTypeList&ProjectId=1000&StackCode=Xdoc_stack"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Project.DocumentStackTypeList"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000', 'StackCode' : 'Xdoc_stack' } 

    print("Now invoking Project.DocumentStackTypeList")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Project.DocumentStackTypeList"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"
   additionParameters["StackCode"] = "Xdoc_stack"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Project.DocumentStackTypeList */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Project.DocumentStackTypeList";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
               { "StackCode", "Xdoc_stack" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Project.DocumentStackTypeList';
   $projectId = '1000';
   $stackCode = 'Xdoc_stack';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'StackCode' => $stackCode);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Project" ServiceMethod="Project.DocumentStackTypeList" RequestId="FE24D76210C94B3BA91A3E9E71771434" RequestDate="2019-11-20T23:53:06Z" ResponseDate="2019-11-20T23:53:06Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191120-235306143-FE24D76210C94B3BA91A3E9E71771434--Project-DocumentStackTypeList" ReturnData="100010005" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <DocumentTypeList>
           <DocumentType SchemaId="100010190" ProjectId="1000" Code="1003-Final" Name="1003 - Final" Label="1003 - Final" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2100101000000920002" CategoryName="Underwriting" CategoryLabel="Underwriting" CategorySequence="10" FieldCount="1" />
           <DocumentType SchemaId="100010085" ProjectId="1000" Code="BankStatements" Name="Bank Statements" Label="Bank Statements" Description="" IsActive="1" IsVersion="1" AutoMerge="1" Sequence="100" CategoryId="2100101000000920005" CategoryName="Asset Docs" CategoryLabel="Asset Docs" CategorySequence="40" FieldCount="2" />
           <DocumentType SchemaId="100010065" ProjectId="1000" Code="Appraisal" Name="Appraisal" Label="Appraisal" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2100101000000920006" CategoryName="Collateral" CategoryLabel="Collateral" CategorySequence="50" FieldCount="0" />
           <DocumentType SchemaId="100010005" ProjectId="1000" Code="1008" Name="1008" Label="1008" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2100101000000920002" CategoryName="Underwriting" CategoryLabel="Underwriting" CategorySequence="10" FieldCount="0" />
       </DocumentTypeList>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Project.DocumentStackTypeList
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Project.DocumentTypeList

Returns a list of Document Type definitions (Document Schemas) for the project.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Project.DocumentTypeList&ProjectId=1000"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Project.DocumentTypeList"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000' } 

    print("Now invoking Project.DocumentTypeList")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Project.DocumentTypeList"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Project.DocumentTypeList */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Project.DocumentTypeList";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Project.DocumentTypeList';
   $projectId = '1000';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Project" ServiceMethod="Project.DocumentTypeList" RequestId="96126F54603E4D70AF357B41605DFF46" RequestDate="2021-01-25T19:06:04Z" ResponseDate="2021-01-25T19:06:04Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20210125-190604000-96126F54603E4D70AF357B41605DFF46--Project-DocumentTypeList" ReturnData="100011460" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    <ResponseData>
        <DocumentTypeList>
            <DocumentType SchemaId="100010000" ProjectId="1000" Code="Unfiled" Name="Unfiled" Label="Unfiled" Description="" IsActive="1" IsVersion="0" AutoMerge="0" Sequence="0" CategoryId="2180101100000920002" CategoryName="Unfiled" CategoryLabel="Unfiled" CategorySequence="10" FieldCount="0" />
            <DocumentType SchemaId="100010001" ProjectId="1000" Code="Unknown" Name="Unknown" Label="Unknown" Description="" IsActive="1" IsVersion="0" AutoMerge="0" Sequence="0" CategoryId="2180101100000920002" CategoryName="Unfiled" CategoryLabel="Unfiled" CategorySequence="10" FieldCount="0" />
            <DocumentType SchemaId="100010005" ProjectId="1000" Code="1003Final" Name="1003 - Final" Label="1003 - Final" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920003" CategoryName="Underwriting" CategoryLabel="Underwriting" CategorySequence="20" FieldCount="1" />
            <DocumentType SchemaId="100010010" ProjectId="1000" Code="1003Initial" Name="1003 - Initial" Label="1003 - Initial" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920003" CategoryName="Underwriting" CategoryLabel="Underwriting" CategorySequence="20" FieldCount="1" />
            <DocumentType SchemaId="100010015" ProjectId="1000" Code="1008" Name="1008" Label="1008" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920003" CategoryName="Underwriting" CategoryLabel="Underwriting" CategorySequence="20" FieldCount="0" />
            <DocumentType SchemaId="100010020" ProjectId="1000" Code="1098" Name="1098" Label="1098" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920004" CategoryName="CreditDocs" CategoryLabel="CreditDocs" CategorySequence="30" FieldCount="1" />
            <DocumentType SchemaId="100010025" ProjectId="1000" Code="1099MISC" Name="1099 MISC" Label="1099 MISC" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920005" CategoryName="Income Docs" CategoryLabel="Income Docs" CategorySequence="40" FieldCount="0" />
            <DocumentType SchemaId="100010030" ProjectId="1000" Code="4506Transcripts" Name="4506 Transcripts" Label="4506 Transcripts" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920005" CategoryName="Income Docs" CategoryLabel="Income Docs" CategorySequence="40" FieldCount="1" />
            <DocumentType SchemaId="100010035" ProjectId="1000" Code="4506TFinal" Name="4506T - Final" Label="4506T - Final" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920005" CategoryName="Income Docs" CategoryLabel="Income Docs" CategorySequence="40" FieldCount="1" />
            <DocumentType SchemaId="100010040" ProjectId="1000" Code="4506TInitial" Name="4506T - Initial" Label="4506T - Initial" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="1" />
            <DocumentType SchemaId="100010045" ProjectId="1000" Code="AbstractNoticeAgr" Name="Abstract Notice Agreement" Label="Abstract Notice Agreement" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="0" />
            <DocumentType SchemaId="100010050" ProjectId="1000" Code="AckofIntenttoProceed" Name="Acknowledgement of Intent to Proceed" Label="Acknowledgement of Intent to Proceed" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="0" />
            <DocumentType SchemaId="100010055" ProjectId="1000" Code="AckOfNoticeOfRightToCancel" Name="Acknowledgement Of Notice Of Right To Cancel" Label="Acknowledgement Of Notice Of Right To Cancel" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="0" />
            <DocumentType SchemaId="100010060" ProjectId="1000" Code="AddendumstoNote" Name="Addendums to Note" Label="Addendums to Note" Description="" IsActive="1" IsVersion="0" AutoMerge="0" Sequence="100" CategoryId="2180101100000920011" CategoryName="Closing Docs" CategoryLabel="Closing Docs" CategorySequence="100" FieldCount="0" />
            <DocumentType SchemaId="100010065" ProjectId="1000" Code="AdvanceFeeAgrandReceipts" Name="Advance Fee Agreement and Receipts" Label="Advance Fee Agreement and Receipts" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="0" />
            <DocumentType SchemaId="100010070" ProjectId="1000" Code="AffiliatedBusinessArrangementDisclosure" Name="Affiliated Business Arrangement Disclosure" Label="Affiliated Business Arrangement Disclosure" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="0" />
            <DocumentType SchemaId="100010075" ProjectId="1000" Code="AIRHVCCLetter" Name="AIR-HVCC Letter" Label="AIR-HVCC Letter" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920007" CategoryName="Collateral" CategoryLabel="Collateral" CategorySequence="60" FieldCount="0" />
            <DocumentType SchemaId="100010080" ProjectId="1000" Code="AirportNoisePollutionAgr" Name="Airport Noise Pollution Agreement" Label="Airport Noise Pollution Agreement" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="0" />
            <DocumentType SchemaId="100010085" ProjectId="1000" Code="AmendatoryClause" Name="Amendatory Clause" Label="Amendatory Clause" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920003" CategoryName="Underwriting" CategoryLabel="Underwriting" CategorySequence="20" FieldCount="0" />
            <DocumentType SchemaId="100010090" ProjectId="1000" Code="AmortizationScheduleFinal" Name="Amortization Schedule - Final" Label="Amortization Schedule - Final" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920011" CategoryName="Closing Docs" CategoryLabel="Closing Docs" CategorySequence="100" FieldCount="0" />
            <DocumentType SchemaId="100010095" ProjectId="1000" Code="AmortizationScheduleInitial" Name="Amortization Schedule - Initial" Label="Amortization Schedule - Initial" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920008" CategoryName="Disclosures" CategoryLabel="Disclosures" CategorySequence="70" FieldCount="0" />
            <DocumentType SchemaId="100010100" ProjectId="1000" Code="Appraisal" Name="Appraisal" Label="Appraisal" Description="" IsActive="1" IsVersion="1" AutoMerge="0" Sequence="100" CategoryId="2180101100000920007" CategoryName="Collateral" CategoryLabel="Collateral" CategorySequence="60" FieldCount="1" />
        </DocumentTypeList>
    </ResponseData>
    <ResponseDebug FirstObjectId="100010000" LastObjectId="100011460" ObjectCount="302" />
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Project.DocumentTypeList
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.BundleSchedule

Creates a new Bundle Package for the container and input Bundle Profile. Returns the Package Id of the generated package

This method kicks off the Bundle Workflow for the package - Bundle Generate, and then Bundle Deliver.

Workflow tasks are visible in the Workflow Monitor.

Bundle Package Info and Status is visible in the Bundle Manager.

Use Container.BundleStatus with the generated PackageId for API monitoring of the status.

Cannot be used with Bundle Profiles that have a delivery type of 'download'.

Note: This method is only available in XDOC build 6111 or higher

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
ContainerKey *Required string	Key to Reference Loan Container; A Unique ID Provided by the LOS. ContainerKey or ContainerRef must be specified.
ContainerRef string	Alternate User Friendly Unique Key for the Loan; This is the Loan Number in the User Interface. ContainerKey or ContainerRef must be specified.
BundleProfile *Required string	Profile Code or Internal Profile Id
BatchName string	Name for the Batch
BatchNbr long	Number for the Batch

Responses

XwsResultCode	XwsResultInfo
0	Success
4000	Param Value Missing
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed
500	Profile Not Found / Profile Not Valid / Container Not Found

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.BundleSchedule&ProjectId=1000&ContainerKey=901001&BundleProfile=MyBundleProfile"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Container.BundleSchedule"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000', 'ContainerKey' : '901001', 'BundleProfile' : 'MyBundleProfile' } 

    print("Now invoking Container.BundleSchedule")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Container.BundleSchedule"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"
   additionParameters["ContainerKey"] = "901001"
   additionParameters["BundleProfile"] = "MyBundleProfile"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.BundleSchedule */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Container.BundleSchedule";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
               { "ContainerKey", "901001" },
               { "BundleProfile", "MyBundleProfile" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.BundleSchedule';
   $projectId = '1000';
   $containerKey = '901001';
   $bundleProfile = 'MyBundleProfile';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'ContainerKey' => $containerKey, 'BundleProfile' => $bundleProfile);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.BundleSchedule" RequestId="B15A5C195B264C5697F8F271AB0DEA80" RequestDate="2021-03-09T20:11:21Z" ResponseDate="2021-03-09T20:11:21Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20210309-201121932-B15A5C195B264C5697F8F271AB0DEA80--Container-BundleSchedule" ReturnData="2210309201121490041" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    <ResponseData>
        <BundlePackage PackageId="2210309201121490041" PackageDate="2021-03-09T12:11:21Z" ApiStatus="processing" ProjectId="1000" ProfileId="2210309183536690387" ProfileName="Test Profile" ContainerId="2210225222049500002" ContainerKey="201001" ContainerRef="901001" ContainerExtra="Homebuilder, Cindy" IsComplete="0" Success="0" StatusCode="0" StatusLabel="processing" DeliveryType="file" />
    </ResponseData>
    <ResponseDebug />
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.BundleSchedule
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.BundleStatus

Returns Status Info of a Container Bundle Package

A Quick Status Indicator is Returned in the XML Response within the BundlePackage envelope under the StatusLabel attribute and also in the XwsReturnData Response Header Value:

'processing' - bundling is in process
'success' - package generated and delivered successfully
'error' - package generate or delivery failed
'cancelled' - bundling process has been cancelled in the Bundle Manager
'paused' - bundling process has been paused in the Bundle Manager

Note: This method is only available in XDOC build 6111 or higher

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
PackageId *Required long	19 digit internal PackageId from BundleSchedule method

Responses

XwsResultCode	XwsResultInfo
0	Success
4000	Missing Object Id / PackageId Not Found
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.BundleStatus&ProjectId=1000&PackageId=2210325181447490100"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Container.BundleStatus"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000', 'PackageId' : '2210325181447490100' } 

    print("Now invoking Container.BundleStatus")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Container.BundleStatus"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"
   additionParameters["PackageId"] = "2210325181447490100"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.BundleStatus */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Container.BundleStatus";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
               { "PackageId", "2210325181447490100" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.BundleStatus';
   $projectId = '1000';
   $packageId = '2210325181447490100';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'PackageId' => $packageId);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.BundleStatus" RequestId="43951C7859464E52B9563916EE87774C" RequestDate="2021-03-08T19:53:57Z" ResponseDate="2021-03-08T19:53:57Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20210308-195357243-43951C7859464E52B9563916EE87774C--Container-BundleStatus" ReturnData="success" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    <ResponseData>
        <BundlePackage ObjectId="2210226191751490007" PackageId="2210226191751490007" PackageDate="2021-02-26T11:17:51Z" ApiStatus="success" ProjectId="1000" ProfileId="2210219183026690343" ProfileName="CA Audit" ContainerId="2210226190306500004" ContainerKey="201003" ContainerRef="901003" ContainerExtra="President, Joe" FileCount="9" PageCount="75" CompleteDate="2021-02-26T11:18:00Z" IsComplete="1" Success="1" StatusCode="1" StatusLabel="success" ErrorDocCount="0" ErrorPageCount="0" PackageFileName="901003.zip" PackageFileExt="zip" DeliveryType="file" DeliveryAddress="D:\TEMP" xGenerateStartDate="2021-02-26T11:17:54Z" xGenerateEndDate="2021-02-26T11:17:54Z" xDeliveryStartDate="2021-02-26T11:18:00Z" xDeliveryEndDate="2021-02-26T11:18:00Z" DeliverySuccess="1" DeliveryResultCode="0" />
    </ResponseData>
    <ResponseDebug />
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.BundleStatus
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.BundleStatusBatch

Returns Status Info of a Container Bundle Batch

Note: This method is only available in XDOC build 6111 or higher

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
BatchName *Required string	Name for the Batch
BatchNbr long	Number for the Batch

Responses

XwsResultCode	XwsResultInfo
0	Success
4000	Missing Object Id / PackageId Not Found
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.BundleStatusBatch&ProjectId=1000&BatchName="

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Container.BundleStatusBatch"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000', 'BatchName' : '' } 

    print("Now invoking Container.BundleStatusBatch")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Container.BundleStatusBatch"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"
   additionParameters["BatchName"] = ""

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.BundleStatusBatch */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Container.BundleStatusBatch";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
               { "BatchName", "" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.BundleStatusBatch';
   $projectId = '1000';
   $batchName = '';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'BatchName' => $batchName);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.BundleStatusBatch" RequestId="7BC7F45B4C60459098947AF63FF59000" RequestDate="2023-03-03T22:57:00Z" ResponseDate="2023-03-03T22:57:00Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20230303-225700010-7BC7F45B4C60459098947AF63FF59000--Container-BundleStatusBatch" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    <ResponseData>
        <BundleBatch ProjectId="1000" BatchName="bw2001" BatchNbr="2002" Total="1" Working="0" Complete="1" Success="1" Error="0" Delivered="1" Generated="1" FirstPackageId="2230127010607490075" LastPackageId="2230127010607490075" FirstGenerateDate="2023-01-27T01:06:11Z" LastGenerateDate="2023-01-27T01:06:11Z" FirstDeliveryDate="2023-01-27T01:06:14Z" LastDeliveryDate="2023-01-27T01:06:11Z">
            <BundleList>
                <BundlePackage PackageId="2230127010607490075" PackageDate="2023-01-27T01:06:07Z" ApiStatus="success" IsComplete="1" Success="1" ProjectId="1000" ProfileId="2230127004939690444" ProfileName="AxTest-AllDocs" ContainerId="2210916161323500005" ContainerKey="201002" ContainerRef="901002" ContainerExtra="Homeowner, John" FileCount="32" PageCount="172" CompleteDate="2023-01-27T01:06:14Z" StatusCode="1" StatusLabel="success" ErrorDocCount="0" ErrorPageCount="0" PackageFileName="901002_20230127010610.zip" PackageFileExt="zip" DeliveryType="download" DeliveryAddress="" GenerateStartDate="2023-01-27T01:06:10Z" GenerateEndDate="2023-01-27T01:06:11Z" DeliveryStartDate="2023-01-27T01:06:14Z" DeliveryEndDate="2023-01-27T01:06:14Z" DeliverySuccess="1" DeliveryResultCode="0" />
            </BundleList>
        </BundleBatch>
    </ResponseData>
    <ResponseDebug />
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.BundleStatusBatch
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.ContainerInfo

Used to get Container Information in XML format including optionally the Document List, Document Fields, and Document Versions.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
ContainerId long	Internal XDOC ID to Reference Loan Container. ContainerId, ContainerKey or ContainerRef must be specified.
ContainerKey *Required string	Key to Reference Loan Container; A Unique ID Provided by the LOS. ContainerId, ContainerKey or ContainerRef must be specified.
ContainerRef string	Alternate User Friendly Unique Key for the Loan; This is the Loan Number in the User Interface. ContainerId, ContainerKey or ContainerRef must be specified.
DataIncludeFlags int	Allows specification of whether to include the Document List, Fields, and Versions; 1 = Document Listing, 2 = Document Fields, 4 = Document Versions

Responses

XwsResultCode	XwsResultInfo
0	Success
1202	Param Value Missing
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.ContainerInfo&ProjectId=1000&ContainerKey=901001"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Container.ContainerInfo"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000', 'ContainerKey' : '901001' } 

    print("Now invoking Container.ContainerInfo")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Container.ContainerInfo"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"
   additionParameters["ContainerKey"] = "901001"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.ContainerInfo */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Container.ContainerInfo";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
               { "ContainerKey", "901001" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.ContainerInfo';
   $projectId = '1000';
   $containerKey = '901001';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'ContainerKey' => $containerKey);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.ContainerInfo" RequestId="70FBDC9EC1FF441284CB8D800FC33318" RequestDate="2019-11-21T00:10:42Z" ResponseDate="2019-11-21T00:10:42Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191121-001042987-70FBDC9EC1FF441284CB8D800FC33318--Container-ContainerInfo" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <Container ContainerId="2190607223637500019" ContainerKey="901001" ProjectId="1000" CaptureDate="2019-06-07T15:36:37Z" CaptureUserId="" CaptureUserName="" TotalDocumentCount="8" LastDocumentAddDate="2019-11-08T11:00:16Z" LastDocumentSchemaId="100010080" LastDocumentSchemaName="AUS Findings" ></Container>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.ContainerInfo
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.DocumentDownload

Writes the binary data of the specified documents to the response stream for download.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
DocumentId *Required string	Multiple Documents can be specified by sending multiple DocumentId parameters. If sending multiple DocumentId parameters, then multiple BookmarkLabel parameters can also be sent that match the DocumentId parameter array.
BookmarkLabel string	If no BookmarkLabel parameters are sent, then the Bookmarks will default to the Document Definition Label or Name.
FormatPdf bool	If FormatPdf = 1, then document will be returned in PDF format. Otherwise, TIF.
AsAttachment bool	Specifying AsAttachment = 1 will result in the Content-Disposition HTTP header on the Response being set to “attachment”. In most browsers, this will result in the Browser giving the user an “open or save” dialog.
FileName string	The default file name that will appear in the browser “open or save” dialog is using AsAttachment.

Responses

XwsResultCode	XwsResultInfo
0	Success
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed
404	Document Not Found

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.DocumentDownload&ProjectId=1000&DocumentId=2190819175244460059" --output xdoc_document.tif

import requests
import xmltodict

def DocumentDownload(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters, pFilePath):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    if response.headers['Xwssuccess'][0] == "1":
        open(pFilePath, 'wb').write(response.content)
        print("Download Successful!")
    else:
        # print XML response
        print(f'API Response XML Envelope:\n{response.text}\n')

        # parse XML response
        xmlDict = xmltodict.parse(response.text)
        resultCode = xmlDict['ServiceResponse']['@ResultCode']
        resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')


if __name__ == "__main__":
    serviceEndpoint = "http://xdoc.example.com/XDocApi/"
    methodSignature = "Container.DocumentDownload"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrFMJkfjwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCDHmkfbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters = {'ProjectId': '1000',
                            'DocumentId': '2210120202005460257'}

    print("Now invoking Container.DocumentDownload\n")
    DocumentDownload(serviceEndpoint,
                     methodSignature,
                     securityContext,
                     securityToken,
                     additionalParameters,
                     "xdoc_document.tif")

package main

import (
   "fmt"
   "io"
   "io/ioutil"
   "net/http"
   "net/url"
   "os"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
   filePath        string
)

func init() {
   serviceEndpoint = "http://xdoc.example.com/XDocApi/"
   securityContext = "SecurityContext"
   securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WKDMLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8Nffby8gKsU+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt7V+x2/Hvz4wxW0"
   filePath = "xdoc_document.tif"
}

func DownloadDocument(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string, pFilePath string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr := requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // check headers for success
   if response.Header["Xwssuccess"][0] == "1" {

      // create the file
      file, err := os.Create(pFilePath)
      check(err)
      defer file.Close()

      // Write the body to file
      _, err = io.Copy(file, response.Body)
      check(err)

      fmt.Println("Document Download Successful!")

   } else {
      fmt.Println("\nAn error occured retrieving the Document")

      // read response body
      responseXML, err := ioutil.ReadAll(response.Body)
      check(err)
      defer response.Body.Close()

      // print response XML payload
      fmt.Println("\nAPI Response XML Envelope: ")
      fmt.Println(string(responseXML) + "\n")
   }
}

func main() {

   // set service method
   serviceMethod = "Container.DocumentDownload"

   // add additional parameters
   additionalParameters := make(map[string]string
   additionalParameters["ProjectId"] = "1000"
   additionalParameters["DocumentId"] = "2210120202005460257"

   // make request to download file
   DownloadDocument(serviceMethod, securityContext, securityToken, additionalParameters, filePath)

}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.DocumentDownload */

namespace xdoc_download_doc_demo
{
   class Program
   {
      // create HTTP client
      private static readonly HttpClient client = new HttpClient();

      // utility to invoke an API service method
      private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
      {
         // set API service endpoint (input your XDOC server domain here)
         string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

         // add service method to invoke URL
         string requestURL = serviceEndpoint + "XM=" + pXM;

         // add security context to invoke URL
         requestURL += "&XSC=" + pXSC;

         // add security token to invoke URL (if provided)
         if (!string.IsNullOrEmpty(pXST))
         {
            requestURL += "&XST=" + pXST;
         }

         // add user token to invoke URL (if provided)
         // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
         if (!string.IsNullOrEmpty(pXUT))
         {
            requestURL += "&XUT=" + pXUT;
         }

         // add in any addition parameters provided to the invoke URL
         if (pAdditionalParams != null)
         {
            foreach (KeyValuePair<string, string> param in pAdditionalParams)
            {
               requestURL += "&" + param.Key + "=" + param.Value;
            }
         }

         // write final URL to console for debug
         Console.WriteLine($"Invoke URL: {requestURL}\n");

         // Create a new WebClient instance
         WebClient myWebClient = new WebClient();

         // Download Document (will contain XML response upon error)
         myWebClient.DownloadFile(requestURL, "xdoc_document.tif");

      }

      // utility method to perform token encryption
      private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
      {
         // Using AES 256 bit encryption settings
         using (RijndaelManaged aesAlg = new RijndaelManaged())
         {
            aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
            aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
            aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
            aesAlg.Key = pEncryptionKey;
            aesAlg.IV = pIV;
            aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

            // create an encryptor to perform the stream transform.
            ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

            // Create the streams used for encryption.
            using (MemoryStream msEncrypt = new MemoryStream())
            {
               using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
               {
                  using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                  {
                     swEncrypt.Write(pPlainTextToken);
                  }
                  // return the encrypted byte array converted to a base 64 encoded string
                  return System.Convert.ToBase64String(msEncrypt.ToArray());
               }
            }
         }
      }

      // utility to ensure correct length for IV and encryption key
      private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
      {
         // working variables
         byte[] tempBytes;
         int tempBytesSize = 0;
         byte[] finalBytes;

         // key initialization
         string key = pInput + String.Empty;

         // check to truncate if too long
         if (key.Length > pFinalBytesRequiredLength)
         {
            key = key.Substring(0, pFinalBytesRequiredLength);
         }

         // convert to byte array
         finalBytes = new byte[pFinalBytesRequiredLength];
         tempBytes = Encoding.UTF8.GetBytes(key);
         tempBytesSize = tempBytes.Length;
         for (int i = 0; i < tempBytesSize; i++)
         {
            finalBytes[i] = tempBytes[i];
         }

         // pad with zeros if needed
         if (tempBytesSize < pFinalBytesRequiredLength)
         {
            for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
            {
               finalBytes[i] = 0x00;
            }
         }
         return finalBytes;
      }

      static void Main(string[] args)
      {
         // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
         string sContext = "SecurityContext"; // must match 'security context' value in UI settings
         string sAppID = "MyAppID"; // identier for app utilizing the API
         string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
         string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
         string sClient = "127.0.0.1"; // set your IP address here
         string sEncryptionKey = "lPd7lEgTkdgsaKf8EksfGh5sHWmwGd2s"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
         string sIV = "@B5lFm3kGNmEU9vX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

         // construct XML security token
         // notes: the security token may also be constructed using JSON or a form-url-encoded format
         string sToken = "<SecurityToken>";
         sToken += $"<Context>{sContext}</Context>";
         sToken += $"<AppId>{sAppID}</AppId>";
         sToken += $"<AppKey>{sAppKey}</AppKey>";
         sToken += $"<GenDT>{sDTS}</GenDT>";
         sToken += $"<Client>{sClient}</Client>";
         sToken += "</SecurityToken>";
         Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

         // add null padding or trucate to ensure correct length
         byte[] IV = EnsureCorrectLength(sIV, 16);
         byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

         // Notes: The IV and encryption key in this example are already the correct length
         // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
         // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
         // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

         // encrypt security token and convert to a base64 encoded string
         string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
         Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

         // URL encode the token
         string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
         Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

         // prepare request parameter values
         string serviceMethod = "Container.DocumentDownload";

         var additionalParams = new Dictionary<string, string> {
            {"ProjectId","1000"},
            {"DocumentId","2210121205932460328"},
            {"Filename","xdoc_document.pdf"},
            {"FormatPdf","1"},
            {"xDebug","1"}
         };

         // make the service method call
         InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
      }
   }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.DocumentDownload';
   $projectId = '1000';
   $documentId = '2190819175244460059';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'DocumentId' => $documentId);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.DocumentDownload" RequestId="66130520F402475F8A4D84B06BB9EFAF" RequestDate="2021-01-25T19:37:22Z" ResponseDate="2021-01-25T19:37:22Z" Success="0" Abort="0" HasWarning="0" ErrorIsUnexpected="0" ApiStatusCode="F" ApiLogRef="20210125-193722134-66130520F402475F8A4D84B06BB9EFAF--Container-DocumentDownload" ReturnData="" ResultCode="404" ResultInfo="DocumentNotFound" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    </ResponseData>
</ServiceResponse>

Note: Upon success the document data will be returned in the response stream. An XML response is only returned upon error.

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.DocumentDownload
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.DocumentDownloadStack

Downloads all documents for the Container and specified Document Stack.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
ContainerKey *Required string	Key to Reference Loan Container; A Unique ID Provided by the LOS. ContainerId or ContainerKey must be specified
ContainerId long	Internal XDOC ID to Reference Loan Container. ContainerId or ContainerKey must be specified.
StackCode string	The StackCode can either be the internal Document Stack 19 digit id, or the Document Stack Code, which is unique by Project.
FormatPdf bool	If FormatPdf = 1, then document will be returned in PDF format. Otherwise, TIF.
AsAttachment bool	Specifying AsAttachment = 1 will result in the Content-Disposition HTTP header on the Response being set to “attachment”. In most browsers, this will result in the Browser giving the user an “open or save” dialog.
FileName string	The default file name that will appear in the browser “open or save” dialog is using AsAttachment.

Responses

XwsResultCode	XwsResultInfo
0	Success
401	Object Id Missing / Missing StackCode Parameter
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed
404	Documents Not Found

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.DocumentDownloadStack&ProjectId=1000&ContainerKey=901001" --output xdoc_document.tif

import requests
import xmltodict

def DocumentDownload(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters, pFilePath):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    if response.headers['Xwssuccess'][0] == "1":
        open(pFilePath, 'wb').write(response.content)
        print("Download Successful!")
    else:
        # print XML response
        print(f'API Response XML Envelope:\n{response.text}\n')

        # parse XML response
        xmlDict = xmltodict.parse(response.text)
        resultCode = xmlDict['ServiceResponse']['@ResultCode']
        resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')


if __name__ == "__main__":
    serviceEndpoint = "http://xdoc.example.com/XDocApi/"
    methodSignature = "Container.DocumentDownloadStack"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrFMJkfjwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCDHmkfbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters = {'ProjectId': '1000',
                            'DocumentId': '2210120202005460257'}

    print("Now invoking Container.DocumentDownloadStack\n")
    DocumentDownload(serviceEndpoint,
                     methodSignature,
                     securityContext,
                     securityToken,
                     additionalParameters,
                     "xdoc_document.tif")

package main

import (
   "fmt"
   "io"
   "io/ioutil"
   "net/http"
   "net/url"
   "os"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
   filePath        string
)

func init() {
   serviceEndpoint = "http://xdoc.example.com/XDocApi/"
   securityContext = "SecurityContext"
   securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WKDMLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8Nffby8gKsU+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt7V+x2/Hvz4wxW0"
   filePath = "xdoc_document.tif"
}

func DownloadDocument(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string, pFilePath string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr := requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // check headers for success
   if response.Header["Xwssuccess"][0] == "1" {

      // create the file
      file, err := os.Create(pFilePath)
      check(err)
      defer file.Close()

      // Write the body to file
      _, err = io.Copy(file, response.Body)
      check(err)

      fmt.Println("Document Download Successful!")

   } else {
      fmt.Println("\nAn error occured retrieving the Document")

      // read response body
      responseXML, err := ioutil.ReadAll(response.Body)
      check(err)
      defer response.Body.Close()

      // print response XML payload
      fmt.Println("\nAPI Response XML Envelope: ")
      fmt.Println(string(responseXML) + "\n")
   }
}

func main() {

   // set service method
   serviceMethod = "Container.DocumentDownloadStack"

   // add additional parameters
   additionalParameters := make(map[string]string
   additionalParameters["ProjectId"] = "1000"
   additionalParameters["DocumentId"] = "2210120202005460257"

   // make request to download file
   DownloadDocument(serviceMethod, securityContext, securityToken, additionalParameters, filePath)

}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.DocumentDownloadStack */

namespace xdoc_download_doc_demo
{
   class Program
   {
      // create HTTP client
      private static readonly HttpClient client = new HttpClient();

      // utility to invoke an API service method
      private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
      {
         // set API service endpoint (input your XDOC server domain here)
         string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

         // add service method to invoke URL
         string requestURL = serviceEndpoint + "XM=" + pXM;

         // add security context to invoke URL
         requestURL += "&XSC=" + pXSC;

         // add security token to invoke URL (if provided)
         if (!string.IsNullOrEmpty(pXST))
         {
            requestURL += "&XST=" + pXST;
         }

         // add user token to invoke URL (if provided)
         // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
         if (!string.IsNullOrEmpty(pXUT))
         {
            requestURL += "&XUT=" + pXUT;
         }

         // add in any addition parameters provided to the invoke URL
         if (pAdditionalParams != null)
         {
            foreach (KeyValuePair<string, string> param in pAdditionalParams)
            {
               requestURL += "&" + param.Key + "=" + param.Value;
            }
         }

         // write final URL to console for debug
         Console.WriteLine($"Invoke URL: {requestURL}\n");

         // Create a new WebClient instance
         WebClient myWebClient = new WebClient();

         // Download Document (will contain XML response upon error)
         myWebClient.DownloadFile(requestURL, "xdoc_document.tif");

      }

      // utility method to perform token encryption
      private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
      {
         // Using AES 256 bit encryption settings
         using (RijndaelManaged aesAlg = new RijndaelManaged())
         {
            aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
            aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
            aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
            aesAlg.Key = pEncryptionKey;
            aesAlg.IV = pIV;
            aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

            // create an encryptor to perform the stream transform.
            ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

            // Create the streams used for encryption.
            using (MemoryStream msEncrypt = new MemoryStream())
            {
               using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
               {
                  using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                  {
                     swEncrypt.Write(pPlainTextToken);
                  }
                  // return the encrypted byte array converted to a base 64 encoded string
                  return System.Convert.ToBase64String(msEncrypt.ToArray());
               }
            }
         }
      }

      // utility to ensure correct length for IV and encryption key
      private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
      {
         // working variables
         byte[] tempBytes;
         int tempBytesSize = 0;
         byte[] finalBytes;

         // key initialization
         string key = pInput + String.Empty;

         // check to truncate if too long
         if (key.Length > pFinalBytesRequiredLength)
         {
            key = key.Substring(0, pFinalBytesRequiredLength);
         }

         // convert to byte array
         finalBytes = new byte[pFinalBytesRequiredLength];
         tempBytes = Encoding.UTF8.GetBytes(key);
         tempBytesSize = tempBytes.Length;
         for (int i = 0; i < tempBytesSize; i++)
         {
            finalBytes[i] = tempBytes[i];
         }

         // pad with zeros if needed
         if (tempBytesSize < pFinalBytesRequiredLength)
         {
            for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
            {
               finalBytes[i] = 0x00;
            }
         }
         return finalBytes;
      }

      static void Main(string[] args)
      {
         // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
         string sContext = "SecurityContext"; // must match 'security context' value in UI settings
         string sAppID = "MyAppID"; // identier for app utilizing the API
         string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
         string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
         string sClient = "127.0.0.1"; // set your IP address here
         string sEncryptionKey = "lPd7lEgTkdgsaKf8EksfGh5sHWmwGd2s"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
         string sIV = "@B5lFm3kGNmEU9vX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

         // construct XML security token
         // notes: the security token may also be constructed using JSON or a form-url-encoded format
         string sToken = "<SecurityToken>";
         sToken += $"<Context>{sContext}</Context>";
         sToken += $"<AppId>{sAppID}</AppId>";
         sToken += $"<AppKey>{sAppKey}</AppKey>";
         sToken += $"<GenDT>{sDTS}</GenDT>";
         sToken += $"<Client>{sClient}</Client>";
         sToken += "</SecurityToken>";
         Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

         // add null padding or trucate to ensure correct length
         byte[] IV = EnsureCorrectLength(sIV, 16);
         byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

         // Notes: The IV and encryption key in this example are already the correct length
         // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
         // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
         // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

         // encrypt security token and convert to a base64 encoded string
         string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
         Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

         // URL encode the token
         string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
         Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

         // prepare request parameter values
         string serviceMethod = "Container.DocumentDownloadStack";

         var additionalParams = new Dictionary<string, string> {
            {"ProjectId","1000"},
            {"DocumentId","2210121205932460328"},
            {"Filename","xdoc_document.pdf"},
            {"FormatPdf","1"},
            {"xDebug","1"}
         };

         // make the service method call
         InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
      }
   }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.DocumentDownloadStack';
   $projectId = '1000';
   $containerKey = '901001';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'ContainerKey' => $containerKey);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.DocumentDownloadStack" RequestId="B1D9D3004B404EEFA7CDD8E0814486D2" RequestDate="2021-01-25T20:14:17Z" ResponseDate="2021-01-25T20:14:17Z" Success="0" Abort="0" HasWarning="0" ErrorIsUnexpected="0" ApiStatusCode="F" ApiLogRef="20210125-201417612-B1D9D3004B404EEFA7CDD8E0814486D2--Container-DocumentDownloadStack" ReturnData="" ResultCode="404" ResultInfo="DocumentNotFound" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    </ResponseData>
</ServiceResponse>

Note: Upon success the document data will be returned in the response stream. An XML response is only returned upon error.

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.DocumentDownloadStack
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.DocumentDownloadType

Same as DocumentDownload, but allows specification of the document by Container and DocumentType instead of the DocumentId.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
ContainerKey *Required string	Key to Reference Loan Container; A Unique ID Provided by the LOS. ContainerId or ContainerKey must be specified
ContainerId long	Internal XDOC ID to Reference Loan Container. ContainerId or ContainerKey must be specified.
DocumentType *Required string	DocumentType can be set to the Schema Id, Code, or Alternate ID of the Document Definition. If multiple documents exist for the DocumentType, all will be returned unless LastDocumentOnly is set = 1.
FormatPdf bool	If FormatPdf = 1, then document will be returned in PDF format. Otherwise, TIF.
BookmarkLabel string	If no BookmarkLabel parameters are sent, then the Bookmarks will default to the Document Definition Label or Name.
AsAttachment bool	Specifying AsAttachment = 1 will result in the Content-Disposition HTTP header on the Response being set to “attachment”. In most browsers, this will result in the Browser giving the user an “open or save” dialog.
FileName string	FileName is the default file name that will appear in the browser “open or save” dialog is using AsAttachment.
LastDocumentOnly bool	If LastDocumentOnly = 1, then only the latest document of that DocumentType will be sent.

Responses

XwsResultCode	XwsResultInfo
0	Success
401	Object Id Missing / Missing DocumentType Parameter
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed
404	Document Not Found

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.DocumentDownloadType&ProjectId=1000&ContainerKey=901001&DocumentType=Appraisal" --output xdoc_document.tif

import requests
import xmltodict

def DocumentDownload(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters, pFilePath):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    if response.headers['Xwssuccess'][0] == "1":
        open(pFilePath, 'wb').write(response.content)
        print("Download Successful!")
    else:
        # print XML response
        print(f'API Response XML Envelope:\n{response.text}\n')

        # parse XML response
        xmlDict = xmltodict.parse(response.text)
        resultCode = xmlDict['ServiceResponse']['@ResultCode']
        resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')


if __name__ == "__main__":
    serviceEndpoint = "http://xdoc.example.com/XDocApi/"
    methodSignature = "Container.DocumentDownloadType"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrFMJkfjwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCDHmkfbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters = {'ProjectId': '1000',
                            'DocumentId': '2210120202005460257'}

    print("Now invoking Container.DocumentDownloadType\n")
    DocumentDownload(serviceEndpoint,
                     methodSignature,
                     securityContext,
                     securityToken,
                     additionalParameters,
                     "xdoc_document.tif")

package main

import (
   "fmt"
   "io"
   "io/ioutil"
   "net/http"
   "net/url"
   "os"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
   filePath        string
)

func init() {
   serviceEndpoint = "http://xdoc.example.com/XDocApi/"
   securityContext = "SecurityContext"
   securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WKDMLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8Nffby8gKsU+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt7V+x2/Hvz4wxW0"
   filePath = "xdoc_document.tif"
}

func DownloadDocument(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string, pFilePath string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr := requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // check headers for success
   if response.Header["Xwssuccess"][0] == "1" {

      // create the file
      file, err := os.Create(pFilePath)
      check(err)
      defer file.Close()

      // Write the body to file
      _, err = io.Copy(file, response.Body)
      check(err)

      fmt.Println("Document Download Successful!")

   } else {
      fmt.Println("\nAn error occured retrieving the Document")

      // read response body
      responseXML, err := ioutil.ReadAll(response.Body)
      check(err)
      defer response.Body.Close()

      // print response XML payload
      fmt.Println("\nAPI Response XML Envelope: ")
      fmt.Println(string(responseXML) + "\n")
   }
}

func main() {

   // set service method
   serviceMethod = "Container.DocumentDownloadType"

   // add additional parameters
   additionalParameters := make(map[string]string
   additionalParameters["ProjectId"] = "1000"
   additionalParameters["DocumentId"] = "2210120202005460257"

   // make request to download file
   DownloadDocument(serviceMethod, securityContext, securityToken, additionalParameters, filePath)

}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.DocumentDownloadType */

namespace xdoc_download_doc_demo
{
   class Program
   {
      // create HTTP client
      private static readonly HttpClient client = new HttpClient();

      // utility to invoke an API service method
      private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
      {
         // set API service endpoint (input your XDOC server domain here)
         string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

         // add service method to invoke URL
         string requestURL = serviceEndpoint + "XM=" + pXM;

         // add security context to invoke URL
         requestURL += "&XSC=" + pXSC;

         // add security token to invoke URL (if provided)
         if (!string.IsNullOrEmpty(pXST))
         {
            requestURL += "&XST=" + pXST;
         }

         // add user token to invoke URL (if provided)
         // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
         if (!string.IsNullOrEmpty(pXUT))
         {
            requestURL += "&XUT=" + pXUT;
         }

         // add in any addition parameters provided to the invoke URL
         if (pAdditionalParams != null)
         {
            foreach (KeyValuePair<string, string> param in pAdditionalParams)
            {
               requestURL += "&" + param.Key + "=" + param.Value;
            }
         }

         // write final URL to console for debug
         Console.WriteLine($"Invoke URL: {requestURL}\n");

         // Create a new WebClient instance
         WebClient myWebClient = new WebClient();

         // Download Document (will contain XML response upon error)
         myWebClient.DownloadFile(requestURL, "xdoc_document.tif");

      }

      // utility method to perform token encryption
      private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
      {
         // Using AES 256 bit encryption settings
         using (RijndaelManaged aesAlg = new RijndaelManaged())
         {
            aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
            aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
            aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
            aesAlg.Key = pEncryptionKey;
            aesAlg.IV = pIV;
            aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

            // create an encryptor to perform the stream transform.
            ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

            // Create the streams used for encryption.
            using (MemoryStream msEncrypt = new MemoryStream())
            {
               using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
               {
                  using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                  {
                     swEncrypt.Write(pPlainTextToken);
                  }
                  // return the encrypted byte array converted to a base 64 encoded string
                  return System.Convert.ToBase64String(msEncrypt.ToArray());
               }
            }
         }
      }

      // utility to ensure correct length for IV and encryption key
      private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
      {
         // working variables
         byte[] tempBytes;
         int tempBytesSize = 0;
         byte[] finalBytes;

         // key initialization
         string key = pInput + String.Empty;

         // check to truncate if too long
         if (key.Length > pFinalBytesRequiredLength)
         {
            key = key.Substring(0, pFinalBytesRequiredLength);
         }

         // convert to byte array
         finalBytes = new byte[pFinalBytesRequiredLength];
         tempBytes = Encoding.UTF8.GetBytes(key);
         tempBytesSize = tempBytes.Length;
         for (int i = 0; i < tempBytesSize; i++)
         {
            finalBytes[i] = tempBytes[i];
         }

         // pad with zeros if needed
         if (tempBytesSize < pFinalBytesRequiredLength)
         {
            for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
            {
               finalBytes[i] = 0x00;
            }
         }
         return finalBytes;
      }

      static void Main(string[] args)
      {
         // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
         string sContext = "SecurityContext"; // must match 'security context' value in UI settings
         string sAppID = "MyAppID"; // identier for app utilizing the API
         string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
         string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
         string sClient = "127.0.0.1"; // set your IP address here
         string sEncryptionKey = "lPd7lEgTkdgsaKf8EksfGh5sHWmwGd2s"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
         string sIV = "@B5lFm3kGNmEU9vX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

         // construct XML security token
         // notes: the security token may also be constructed using JSON or a form-url-encoded format
         string sToken = "<SecurityToken>";
         sToken += $"<Context>{sContext}</Context>";
         sToken += $"<AppId>{sAppID}</AppId>";
         sToken += $"<AppKey>{sAppKey}</AppKey>";
         sToken += $"<GenDT>{sDTS}</GenDT>";
         sToken += $"<Client>{sClient}</Client>";
         sToken += "</SecurityToken>";
         Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

         // add null padding or trucate to ensure correct length
         byte[] IV = EnsureCorrectLength(sIV, 16);
         byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

         // Notes: The IV and encryption key in this example are already the correct length
         // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
         // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
         // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

         // encrypt security token and convert to a base64 encoded string
         string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
         Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

         // URL encode the token
         string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
         Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

         // prepare request parameter values
         string serviceMethod = "Container.DocumentDownloadType";

         var additionalParams = new Dictionary<string, string> {
            {"ProjectId","1000"},
            {"DocumentId","2210121205932460328"},
            {"Filename","xdoc_document.pdf"},
            {"FormatPdf","1"},
            {"xDebug","1"}
         };

         // make the service method call
         InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
      }
   }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.DocumentDownloadType';
   $projectId = '1000';
   $containerKey = '901001';
   $documentType = 'Appraisal';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'ContainerKey' => $containerKey, 'DocumentType' => $documentType);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.DocumentDownloadType" RequestId="3B9E96EC4B69435ABDD3FA31C9C58493" RequestDate="2021-01-25T20:17:32Z" ResponseDate="2021-01-25T20:17:32Z" Success="0" Abort="0" HasWarning="0" ErrorIsUnexpected="0" ApiStatusCode="F" ApiLogRef="20210125-201732534-3B9E96EC4B69435ABDD3FA31C9C58493--Container-DocumentDownloadType" ReturnData="" ResultCode="404" ResultInfo="DocumentNotFound" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    </ResponseData>
</ServiceResponse>

Note: Upon success the document data will be returned in the response stream. An XML response is only returned upon error.

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.DocumentDownloadType
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Container.DocumentInfo

Used to get Document Information in XML format for 1 specific document.

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
DocumentId *Required long	Document ID
DataIncludeFlags int	Allows specification of whether to include the Document List, Fields, and Versions; 1 = Document Listing, 2 = Document Fields, 4 = Document Versions

Responses

XwsResultCode	XwsResultInfo
0	Success
1202	Param Value Missing
1203	Param Value Invalid
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Container.DocumentInfo&ProjectId=1000&DocumentId=2190819175244460059"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Container.DocumentInfo"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000', 'DocumentId' : '2190819175244460059' } 

    print("Now invoking Container.DocumentInfo")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Container.DocumentInfo"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"
   additionParameters["DocumentId"] = "2190819175244460059"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Container.DocumentInfo */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Container.DocumentInfo";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
               { "DocumentId", "2190819175244460059" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Container.DocumentInfo';
   $projectId = '1000';
   $documentId = '2190819175244460059';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'DocumentId' => $documentId);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Container" ServiceMethod="Container.DocumentInfo" RequestId="EF19DB024FB242A6ADD98DF8870B8B5D" RequestDate="2019-11-20T23:59:07Z" ResponseDate="2019-11-20T23:59:07Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20191120-235907909-EF19DB024FB242A6ADD98DF8870B8B5D--Container-DocumentInfo" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
   <ResponseData>
       <Document DocumentId="2190627202600460846" DocNbr="10004136" ContainerId="2190524174540500013" ContainerKey="201005" VersionOn="1" VersionNbr="1" PageCount="1" CaptureDate="2019-06-27T13:26:00Z" CaptureUserId="10" CaptureUserName="admin" CaptureChannel="" CaptureAddressType="4" CaptureAddress="" SchemaId="100010001" SchemaCode="Unfiled" SchemaName="Unfiled" SchemaLabel="Unfiled" SchemaIsVersioned="0" SchemaSequence="0" BucketId="1000004" BucketCode="New" BucketName="New" CategoryId="2100101000000920001" CategoryName="Unfiled" CategoryLabel="Unfiled" CategorySequence="1"></Document>
   </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Container.DocumentInfo
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

POST Document.DocumentAdd

Upload a new document to the repository

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
ContainerKey *Required string	Key to Reference Loan Container; A Unique ID Provided by the LOS. ContainerKey or ContainerRef must be specified.
ContainerRef string	Alternate User Friendly Unique Key for the Loan; This is the Loan Number in the User Interface. ContainerKey or ContainerRef must be specified.
DocumentType *Required string	Type of document being added. Must match either the Schema Id, Code, or Alternate ID of the Document Definition
BucketCode string	Bucket assignment for the document. If empty, will use the default from the Project Settings
BatchCode string	Batch assignment for the document. Typically Batch assignment features are not used in most confiugrations
CaptureUser string	Username of the user adding the document.
CaptureDate datetime	Date and Time (UTC) the document was created / captured. If empty, defaults to the current date/time.
CaptureMethod string	The method the document was received.
FieldType string	Type of field being set. Must match either the Schema Id, Code, or Alternate ID of the Field Definition
FieldValue string	Value for Field Specified by 'FieldType'
ExternalRef string	Arbitrary External System Identifier or reference.
FileName string	Original source file name.
FileData string	Written directly to the Request Input Stream. For Text based data, this can also be included as a Request Parameter.
FileExtension *Required string	Since the FileData is written to the Request Input Stream, this parameter tells XDOC the file format so it can properly convert to TIF.
ProcessInColor bool	If set = 1, indicates to render the document in Color.
ProcessBarcodes bool	If set = 1, indicates to process barcodes and apply barcode identification algorithms to try to automatically identify the Container. Note: if the Container Key is specified and valid, this parameter is ignored.
ProcessAltIdExt bool	If set = 1, indicates to use the secondary alternate ids for document type identifcation during barcode id processing.
ProcessingFlags int	Additional processing bit flags; 1 Indicates to add the document even if the Container is not found in the Integrated Application, 2 Indicates to add the document even if the Document type is not found, 4 Indicates to use the Default Document Type.

Responses

XwsResultCode	XwsResultInfo
0	Success - Check ResultInfo envelope in xml response payload for DocumentAdded and FileAdded attribute values
10211	File Type Not Allowed
20221	Document Type Not Found
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed
404	Document Not Found / File Extension Not Found

Example Request

cURL

Python

Go

C#

PHP


curl --data-binary @file.pdf -d "XM=Document.DocumentAdd&ProjectId=1000&ContainerKey=901001&DocumentType=Appraisal&FileExtension=pdf" "https://xdoc.example.com/XDocApi/"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
   apiServiceEndpoint = pServiceEndpoint
   parameters = {'xm': pXM,
                 'xsc': pXSC,
                 'xst': pXST}
   if pAdditionalParameters:
      parameters.update(pAdditionalParameters)

   with open('file.pdf', 'rb') as f:
      response = requests.post(apiServiceEndpoint,
                              params=parameters, data=f)

   return response


if __name__ == "__main__":
   serviceEndpoint = "https://xdoc.example.com/XDocApi/"
   methodSignature = "Document.DocumentAdd"
   securityContext = "SecurityContext"
   securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
   additionalParameters =  { 'ProjectId' : '1000', 'ContainerKey' : '901001', 'DocumentType' : 'Appraisal', 'FileExtension' : 'pdf' } 

   print("Now invoking Document.DocumentAdd")
   responseXML = invokeServiceMethod(serviceEndpoint,
                                     methodSignature,
                                     securityContext,
                                     securityToken,
                                     additionalParameters)

   # print invoke URL
   print(f'API Invoke URL:\n{responseXML.url}\n')

   # print response HTTP headers
   print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

   # print XML response
   print(f'API Response XML Envelope:\n{responseXML.text}\n')

   # parse XML response
   xmlDict = xmltodict.parse(responseXML.text)
   resultCode = xmlDict['ServiceResponse']['@ResultCode']
   resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

   # check XwsResultCode in XML payload
   if resultCode != "0":
      print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
   else:
      print("Call was successful!")

package main

import (
   "bytes"
   "crypto/tls"
   "encoding/xml"
   "fmt"
   "io"
   "mime/multipart"
   "net/http"
   "net/url"
   "os"
   "path/filepath"
   "time"
)

var (
   serviceEndpoint string
   securityContext string
   securityToken   string
   projectID       string
   containerKey    string
)

//ServiceResponse Holds Data from XDOC HTTP API Response
type ServiceResponse struct {
   XMLName     xml.Name `xml:"ServiceResponse"`
   Success     string   `xml:"Success,attr"`
   Abort       string   `xml:"Abort,attr"`
   ServiceName string   `xml:"ServiceName,attr"`
   ErrorInfo   string   `xml:"ErrorInfo,attr"`
   ResultInfo  string   `xml:"ResultInfo,attr"`
}

func init() {
   serviceEndpoint = "https://xdoc.example.com.com/XDocApi/"
   securityContext = "SecurityContext"
   securityToken = "cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0"
   projectID = "1000"
   containerKey = "901001"
}

//DocumentAdd uses the XDOC API Document.DocumentAdd service method to add a document to a loan from an uploaded file or inputted text
func DocumentAdd(pXDOCServer string, pXSC string, pXST string, pContainerKey string, pProjectID string, pDocumentType string, pAdditionalParameters map[string]string, pUseLocalFile bool, pFilePath string, pDocBody string) (string, *ServiceResponse, string, http.Header, error) {
   // Init Parameters
   xParameters := map[string]string{
      "xm":           "Document.DocumentAdd",
      "xsc":          pXSC,
      "xst":          pXST,
      "ContainerKey": pContainerKey,
      "ProjectId":    pProjectID,
      "DocumentType": pDocumentType}

   if pUseLocalFile {
      xParameters["FileName"] = filepath.Base(pFilePath)
      xParameters["FileExtension"] = filepath.Ext(pFilePath)[1:]
   } else {
      xParameters["FileName"] = "test.txt"
      xParameters["FileExtension"] = "txt"
      xParameters["FileData"] = pDocBody
   }

   // Add in additional parameters
   for xKey, xVal := range pAdditionalParameters {
      xParameters[xKey] = xVal
   }

   // Encode parameters
   xURLParams := url.Values{}
   for xKey, xVal := range xParameters {
      xURLParams.Add(xKey, xVal)
   }

   xURL, _ := url.ParseRequestURI(pXDOCServer)
   xURL.RawQuery = xURLParams.Encode()
   xURLString := xURL.String()

   // Create an HTTP client
   tr := &http.Transport{
      TLSClientConfig: &tls.Config{InsecureSkipVerify: false},
   }
   xHTTPClient := &http.Client{Transport: tr,
      Timeout: time.Second * 2,
   }

   // Create HTTP Request
   var xRequest *http.Request
   var err error

   // Encode file in multi-part request
   if pUseLocalFile {
      xRequest, err = encodeMultipartRequest(xURLString, pFilePath)
      if err != nil {
         return xURLString, nil, "", nil, fmt.Errorf("error encoding multi-part request: %s", err.Error())
      }
   } else {
      // Using FileData parameter to create doc from text
      xRequest, err = http.NewRequest("POST", xURLString, nil)
      if err != nil {
         return xURLString, nil, "", nil, fmt.Errorf("error creating request: %s", err.Error())
      }
   }

   xResponse, err := xHTTPClient.Do(xRequest)
   if err != nil {
      return xURLString, nil, "", nil, fmt.Errorf("error making request: %s", err.Error())
   }

   xResponseBodyBuffer := new(bytes.Buffer)
   xResponseBodyBuffer.ReadFrom(xResponse.Body)
   defer xResponse.Body.Close()

   xResponseData := new(ServiceResponse)
   err = xml.Unmarshal(xResponseBodyBuffer.Bytes(), &xResponseData)
   if err != nil {
      return xURLString, xResponseData, xResponseBodyBuffer.String(), nil, fmt.Errorf("error unmarshalling xml response: %s\n response body: %s", err.Error(), xResponseBodyBuffer.String())
   }

   return xURLString, xResponseData, xResponseBodyBuffer.String(), xResponse.Header, nil
}

func encodeMultipartRequest(uri string, filePath string) (multiPartRequest *http.Request, err error) {
   file, err := os.Open(filePath)
   if err != nil {
      return nil, err
   }
   defer file.Close()

   body := &bytes.Buffer{}
   writer := multipart.NewWriter(body)
   part, err := writer.CreateFormFile("file", filepath.Base(filePath))
   if err != nil {
      return nil, err
   }
   _, err = io.Copy(part, file)

   err = writer.Close()
   if err != nil {
      return nil, err
   }

   multiPartRequest, err = http.NewRequest("POST", uri, body)
   multiPartRequest.Header.Set("Content-Type", writer.FormDataContentType())

   return multiPartRequest, err
}

func main() {

   xInvokeURL, xResponseData, xResponseBody, xResponseHeaders, err := DocumentAdd(serviceEndpoint, securityContext, securityToken, containerKey, projectID, "Appraisal", nil, true, "test.pdf", "")
   if err != nil {
      panic(err)
   }

   // print invoke URL
   fmt.Printf("API Invoke URL: %s", xInvokeURL)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range xResponseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(xResponseBody)

   // check XwsResultCode in header
   if xResponseHeaders["Xwsresultcode"][0] != "0" {
      fmt.Printf("\nCall failed with result code %s. Additional info: %s", xResponseHeaders["Xwsresultcode"][0], xResponseHeaders["Xwsresultinfo"][0])
   } else {
      fmt.Printf("\n\nCall was successful! Response Data: %+v", xResponseData)
   }
}

using System;
using System.Xml;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Security.Cryptography;

/* XDOC API DEMO - Add a Document */
namespace xdoc_add_doc_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // utility to invoke an API service method
        private static async void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {

            // set API service endpoint
            string serviceEndpoint = "https://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            // open file for request
            var filename = "DocToAdd.pdf"; // file must exist
            var fileData = File.OpenRead(filename);

            // make asynchronous POST request
            var response = await client.PostAsync(requestURL, new StreamContent(fileData));
            response.EnsureSuccessStatusCode();

            // Read the service response xml data if you need the ResponseData,
            // or want to inspect the error trace in case of an error.
            Console.WriteLine($"XML Response from XDOC Server: \n{await response.Content.ReadAsStringAsync()}");

        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {

            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // prepare request parameter values
            string serviceMethod = "Document.DocumentAdd";
            var additionalParams = new Dictionary<string, string> {
               {"DocumentType","Appraisal"}, // this document type must exist in the project
               {"FileName","DocToAdd.pdf"}, // file must exist locally
               {"ProjectId","1000"}, // the security context must be for this project
               {"ContainerKey","901001"}, // this container must exist
               {"ProcessingFlags","1"}
            };

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);

            // sleep while waiting for async call to return
            Thread.Sleep(10000);

        }
    }
}

<?php
   // set parameter values
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Document.DocumentAdd';
   $projectId = '1000';
   $containerKey = '901001';
   $documentType = 'Appraisal';
   $fileExtension = 'pdf';
   $FileName = 'document.pdf';

   // add parameters to array
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'ContainerKey' => $containerKey, 'DocumentType' => $documentType, 'FileExtension' => $fileExtension);

   // construct multipart request data
   $delimiter = '-------------' . uniqid();
   $request = construct_multipart_request($parameters, $fileName, $delimiter);

   // init cURL and set options
   $curl = curl_init();
   curl_setopt_array($curl, array(
     CURLOPT_URL => $apiEndpoint,
     CURLOPT_RETURNTRANSFER => 1,
     CURLOPT_TIMEOUT => 10,
     CURLOPT_POST => 1,
     CURLOPT_POSTFIELDS => $request,
     CURLOPT_HTTPHEADER => array(
       "Content-Type: multipart/form-data; boundary=" . $delimiter,
       "Content-Length: " . strlen($request)
     ),
   ));

   // make POST using cURL
   $response = curl_exec($curl);

   // show XML response in browser
   header('Content-type: application/xml');
   echo $responseXML;

   // parse XML Response
   $xmlData = new SimpleXMLElement($responseXML);

   // utility function to create the multipart/form-data request
   function construct_multipart_request($parameters, $filepath, $delimiter){

      $request = '';

      foreach ($parameters as $param => $content) {
        $request .= "--" . $delimiter . "\r\n"
            . 'Content-Disposition: form-data; name="' . $param . "\"" . "\r\n" . "\r\n"
            . $content . "\r\n";
      }

      $request .= "--" . $delimiter . "\r\n"
               . 'Content-Disposition: form-data; name="' . $filepath . '"; filename="' . $filepath . '"' . "\r\n"
               . 'Content-Transfer-Encoding: binary' . "\r\n\r\n"
               . file_get_contents($filepath) . "\r\n"
               . "--" . $delimiter . "--" . "\r\n";

      return $request;
   }
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Document" ServiceMethod="Document.DocumentAdd" RequestId="D35C993862084856ABECA682C550236D" RequestDate="2021-01-25T20:21:45Z" ResponseDate="2021-01-25T20:21:45Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20210125-202145672-D35C993862084856ABECA682C550236D--Document-DocumentAdd" ReturnData="2210125202145460394" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    <ResponseData>
        <Document ApplicationFlags="0" ApiProcessingFlags="0" ApiWorkflowFlags="0" XwsAxFlags="0" ProjectId="1000" CaptureDate="2021-01-25T12:21:45Z" CaptureUser="" CaptureMethod="" ContainerId="2201023041032500004" ContainerKey="201002" ContainerRef="901002" ContainerFindVal="" DocumentId="2210125202145460394" SchemaId="100011464" DocumentType="AutoTestingDoc" ExtRef="" SourceFileName="" SourceFileExtension="tif" BucketId="1000004" BucketCode="" BatchId="" BatchCode="" DocNbr="10002386" BucketFlags="0" FileId="2210125202145410361" FileWfFlags="12" XmitId="2210125202145400361" XmitType="19" RawFileRenderId="2210125202145440960" RawFileRelativePath="20210125/2210125202145440960.tif" RawFileAbsolutePath="D:/XDOCData/store/default/inbox/20210125/2210125202145440960.tif" ImageFileRenderId="2210125202145440961" ImageFileRelativePath="20210125/2210125202145440961.tif" ImageFileAbsolutePath="D:/XDOCData/store/default/inbox/20210125/2210125202145440961.tif" />
        <ResultInfo FileAdded="1" DocumentAdded="1" ContainerFound="1" BatchFound="0" DocumentTypeFound="1" DefaultDocumentTypeUsed="0" RenderAttempted="0" WorkflowInitiated="1" ServiceName="XDocBaseApiServerSvc" ServiceMethod="DocumentAdd" ReturnData="2210125202145460394" ResultWasSet="1" ResultState="0" />
        <TraceStats>
            <BaseStats ProcessTime="46" DatabaseActionTime="14" DatabaseQueryTime="0" FileConvertTime="0" FilePackageTime="0" FileTempCopyTime="0" TiffReaderTime="0" BarcodeReadTime="0" ContainerLookupTime="14" DocumentStoreWriteTime="1" DocumentStoreWriteRawTime="1" DocumentStoreWriteImageTime="0" />
        </TraceStats>
    </ResponseData>
</ServiceResponse>

Note: A successful upload is indicated by the attribute FileAdded="1". The attribute DocumentAdded="1" indicates that the document has been added to the specified container.

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Document.DocumentAdd
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

POST Document.DocumentAddXml

Upload a new document to the repository. Same as DocumentAdd, but the input parameters and file data are specified in XML written directly to the Request Input Stream.

Request Body

                  <RequestData>
   <DocumentAdd
      ProjectId="1000"
      ContainerKey="201001"
      DocumentType="w2"
      CaptureUser="admin"
      CaptureDate="2010-11-23T12:52:56Z"
      CaptureMethod="scan"
      ExternalReference="doc12345"
      ProcessingFlags="1"
      FileExtension="pdf"
      FileName="Doc.pdf" >
      <FieldList>
         <Field FieldType="status" FieldValue="approved" />
         <Field FieldType="requiresReview" FieldValue="1" />
      </FieldList>
      <FileData>
         Base64 Encoded File Data Goes Here
      </FileData>
   </DocumentAdd>
</RequestData>

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID

Responses

XwsResultCode	XwsResultInfo
0	Success - Check ResultInfo envelope in xml response payload for DocumentAdded and FileAdded attribute values
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Document.DocumentAddXml&ProjectId=1000"

import requests
import xmltodict


def addDocXml(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters, pXml):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    headers = {'Content-Type': 'application/xml'}
    response = requests.post(apiServiceEndpoint,
                             headers=headers,
                             params=parameters,
                             data=pXml)

    return response


if __name__ == "__main__":
    serviceEndpoint = "http://xdoc.example.com/XDocApi/"
    methodSignature = "Document.DocumentAddXml"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUdkdkU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8gmhSUCD8NffbyNiF+U+xTV2ez2flm8noMmWyABHLRaVNgqz/3pKeqecGJgoweR/964NWG9O+IX5NKyuErsPjMZjnU+jfM/VSGhyxU5zzsx0ifIG"
    additionalParameters = {'ProjectId': '1000'}

    print("Now invoking DocumentAddXml\n")

    xml = """<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<DocumentAdd
   ProjectId="1000"
   ContainerKey="201001"
   DocumentType="appraisal"
   CaptureUser=""
   CaptureDate=""
   CaptureMethod="print"
   ExternalReference="docAddXml1"
   ProcessingFlags="1"
   FileExtension="pdf"
   FileName="Doc.pdf3454"
   >
  <FieldList>
    <!-- <Field FieldType="status" FieldValue="approved" />
    <Field FieldType="requiresReview" FieldValue="1" />-->
  </FieldList>

<FileData>
Base64 Encoded File Data Goes Here
</FileData>

</DocumentAdd>
"""
    responseXML = addDocXml(serviceEndpoint,
                            methodSignature,
                            securityContext,
                            securityToken,
                            additionalParameters,
                            xml)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(
            f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main

import (
	"bytes"
	"crypto/tls"
	"encoding/xml"
	"fmt"
	"net/http"
	"net/url"
	"time"
)

var (
	serviceEndpoint string
	securityContext string
	securityToken   string
	projectID       string
	containerKey    string
)

//ServiceResponse Holds Data from XDOC HTTP API Response
type ServiceResponse struct {
	XMLName     xml.Name `xml:"ServiceResponse"`
	Success     string   `xml:"Success,attr"`
	Abort       string   `xml:"Abort,attr"`
	ServiceName string   `xml:"ServiceName,attr"`
	ErrorInfo   string   `xml:"ErrorInfo,attr"`
	ResultInfo  string   `xml:"ResultInfo,attr"`
}

func init() {
	serviceEndpoint = "http://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOhkdi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8hlnbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzgUoBU5yhkdzvYDKzR1ZoBjhqMMQObpf0pEvf7jC5eGhqspxtEtAOxS/SMPWFV3q2"
	projectID = "1000"
	containerKey = "201101"
}

//DocumentAdd uses the XDOC API Document.DocumentAddXml service method to add a document to a loan from xml
func DocumentAddXml(pXDOCServer string, pXSC string, pXST string, pContainerKey string, pProjectID string, pDocumentType string, pAdditionalParameters map[string]string, pXML string) (string, *ServiceResponse, string, http.Header, error) {

	// Init Parameters
	xParameters := map[string]string{
		"xm":           "Document.DocumentAddXml",
		"xsc":          pXSC,
		"xst":          pXST,
		"ContainerKey": pContainerKey,
		"ProjectId":    pProjectID,
		"DocumentType": pDocumentType}

	// Add in additional parameters
	for xKey, xVal := range pAdditionalParameters {
		xParameters[xKey] = xVal
	}

	// Encode parameters
	xURLParams := url.Values{}
	for xKey, xVal := range xParameters {
		xURLParams.Add(xKey, xVal)
	}

	xURL, _ := url.ParseRequestURI(pXDOCServer)
	xURL.RawQuery = xURLParams.Encode()
	xURLString := xURL.String()

	// Create an HTTP client, skip security check for bad ssl
	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	xHTTPClient := &http.Client{Transport: tr,
		Timeout: time.Second * 2,
	}

	// Create HTTP Request
	var xRequest *http.Request
	var err error

	xRequest, err = http.NewRequest("POST", xURLString, bytes.NewBuffer([]byte(pXML)))
	if err != nil {
		return xURLString, nil, "", nil, fmt.Errorf("error creating request: %s", err.Error())
	}

	xResponse, err := xHTTPClient.Do(xRequest)
	if err != nil {
		return xURLString, nil, "", nil, fmt.Errorf("error making request: %s", err.Error())
	}

	xResponseBodyBuffer := new(bytes.Buffer)
	xResponseBodyBuffer.ReadFrom(xResponse.Body)
	defer xResponse.Body.Close()

	xResponseData := new(ServiceResponse)
	err = xml.Unmarshal(xResponseBodyBuffer.Bytes(), &xResponseData)
	if err != nil {
		return xURLString, xResponseData, xResponseBodyBuffer.String(), nil, fmt.Errorf("error unmarshalling xml response: %s\n response body: %s", err.Error(), xResponseBodyBuffer.String())
	}

	return xURLString, xResponseData, xResponseBodyBuffer.String(), xResponse.Header, nil
}

func main() {

	xmlBody := `<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
	<DocumentAdd
	   ProjectId="1000"
	   ContainerKey="201001"
	   DocumentType="appraisal"
	   CaptureUser=""
	   CaptureDate=""
	   CaptureMethod="print"
	   ExternalReference="docAddXml1"
	   ProcessingFlags="1"
	   FileExtension="pdf"
	   FileName="Doc.pdf3454"
	   >
	  <FieldList>
		<!-- <Field FieldType="status" FieldValue="approved" />
		<Field FieldType="requiresReview" FieldValue="1" />-->
	  </FieldList>
	
	<FileData>
	Base64 Encoded File Data Goes Here
	</FileData>
	
	</DocumentAdd>
	`

	// make request
	xInvokeURL, xResponseData, xResponseBody, xResponseHeaders, err := DocumentAddXml(serviceEndpoint, securityContext, securityToken, containerKey, projectID, "Appraisal", nil, xmlBody)
	if err != nil {
		panic(err)
	}

	// print invoke URL
	fmt.Printf("API Invoke URL: %s", xInvokeURL)

	// print response HTTP headers
	fmt.Println("API Response HTTP Headers:")
	for headerName, headerValue := range xResponseHeaders {
		fmt.Printf("%s:%s; ", headerName, headerValue[0])
	}

	// print response XML payload
	fmt.Println("\n\nAPI Response XML Envelope: ")
	fmt.Println(xResponseBody)

	// check XwsResultCode in header
	if xResponseHeaders["Xwsresultcode"][0] != "0" {
		fmt.Printf("\nCall failed with result code %s. Additional info: %s", xResponseHeaders["Xwsresultcode"][0], xResponseHeaders["Xwsresultinfo"][0])
	} else {
		fmt.Printf("\n\nCall was successful! Response Data: %+v", xResponseData)
	}
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Document.DocumentAddXml */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Document.DocumentAddXml";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?php
   // set parameter values
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Document.DocumentAddXml';
   $projectId = '1000';
   $FileName = 'document.pdf';

   // add parameters to array
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId);

   // construct multipart request data
   $delimiter = '-------------' . uniqid();
   $request = construct_multipart_request($parameters, $fileName, $delimiter);

   // init cURL and set options
   $curl = curl_init();
   curl_setopt_array($curl, array(
     CURLOPT_URL => $apiEndpoint,
     CURLOPT_RETURNTRANSFER => 1,
     CURLOPT_TIMEOUT => 10,
     CURLOPT_POST => 1,
     CURLOPT_POSTFIELDS => $request,
     CURLOPT_HTTPHEADER => array(
       "Content-Type: multipart/form-data; boundary=" . $delimiter,
       "Content-Length: " . strlen($request)
     ),
   ));

   // make POST using cURL
   $response = curl_exec($curl);

   // show XML response in browser
   header('Content-type: application/xml');
   echo $responseXML;

   // parse XML Response
   $xmlData = new SimpleXMLElement($responseXML);

   // utility function to create the multipart/form-data request
   function construct_multipart_request($parameters, $filepath, $delimiter){

      $request = '';

      foreach ($parameters as $param => $content) {
        $request .= "--" . $delimiter . "\r\n"
            . 'Content-Disposition: form-data; name="' . $param . "\"" . "\r\n" . "\r\n"
            . $content . "\r\n";
      }

      $request .= "--" . $delimiter . "\r\n"
               . 'Content-Disposition: form-data; name="' . $filepath . '"; filename="' . $filepath . '"' . "\r\n"
               . 'Content-Transfer-Encoding: binary' . "\r\n\r\n"
               . file_get_contents($filepath) . "\r\n"
               . "--" . $delimiter . "--" . "\r\n";

      return $request;
   }
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Document" ServiceMethod="Document.DocumentAddXml" RequestId="54646C8399824A6DB6A99BE15AA774DF" RequestDate="2021-01-25T20:30:13Z" ResponseDate="2021-01-25T20:30:13Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20210125-203013094-54646C8399824A6DB6A99BE15AA774DF--Document-DocumentAddXml" ReturnData="2210125203013460395" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    <Document ApplicationFlags="0" ApiProcessingFlags="1" ApiWorkflowFlags="0" ProjectId="1000" CaptureDate="2021-01-25T12:30:13Z" CaptureUser="" CaptureMethod="print" ContainerId="2201023041026500002" ContainerKey="201001" ContainerRef="901001" ContainerFindVal="" DocumentId="2210125203013460395" SchemaId="100010100" DocumentType="appraisal" ExtRef="" SourceFileName="DruTest.pdf3454" SourceFileExtension="pdf" BucketId="1000004" BucketCode="" BatchId="" BatchCode="" DocNbr="10002387" BucketFlags="0" FileId="2210125203013410362" FileWfFlags="12" XmitId="2210125203013400362" XmitType="8" RawFileRenderId="2210125203013440963" RawFileRelativePath="20210125/2210125203013440963.pdf" RawFileAbsolutePath="D:/XDOCData/store/default/inbox/20210125/2210125203013440963.pdf" ImageFileRenderId="2210125203013440964" ImageFileRelativePath="20210125/2210125203013440964.tif" ImageFileAbsolutePath="D:/XDOCData/store/default/inbox/20210125/2210125203013440964.tif" />
    <ResultInfo FileAdded="1" DocumentAdded="1" ContainerFound="1" BatchFound="0" DocumentTypeFound="1" DefaultDocumentTypeUsed="0" RenderAttempted="0" WorkflowInitiated="1" ServiceName="XDocBaseApiServerSvc" ServiceMethod="DocumentAdd" ReturnData="2210125203013460395" ResultWasSet="1" ResultState="0" />
    <TraceStats>
        <BaseStats ProcessTime="25" DatabaseActionTime="11" DatabaseQueryTime="0" FileConvertTime="0" FilePackageTime="0" FileTempCopyTime="0" TiffReaderTime="0" BarcodeReadTime="0" ContainerLookupTime="5" DocumentStoreWriteTime="1" DocumentStoreWriteRawTime="1" DocumentStoreWriteImageTime="0" />
    </TraceStats>
</ResponseData>
</ServiceResponse>

Note: A successful upload is indicated by the attribute FileAdded="1". The attribute DocumentAdded="1" indicates that the document has been added to the specified container.

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Document.DocumentAddXml
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr

GET Document.DocumentDelete

Deletes a document. Deleting a document in XDOC performs a “soft delete”, which marks the document as deleted and logs the action

Parameters

Name	Description
XM *Required string	Method Signature
ProjectId *Required int	Project ID
DocumentId *Required long	Document Id to Reference
ActionUser string	Username of the user deleting the document.

Responses

XwsResultCode	XwsResultInfo
0	Success
1202	Param Value Missing
1203	Param Value Invalid
20220	Document Not Found
403	Security Validation Failed / Security Config or Context Missing / Security Token Expired or Decryption Failed

Example Request

cURL

Python

Go

C#

PHP


curl -X GET "https://xdoc.example.com/XDocApi/?XM=Document.DocumentDelete&ProjectId=1000&DocumentId=2190819175244460059"

import requests
import xmltodict

def invokeServiceMethod(pServiceEndpoint, pXM, pXSC, pXST, pAdditionalParameters):
    apiServiceEndpoint = pServiceEndpoint
    parameters = {'xm': pXM,
                  'xsc': pXSC,
                  'xst': pXST}
    if pAdditionalParameters:
        parameters.update(pAdditionalParameters)

    response = requests.get(url=apiServiceEndpoint, params=parameters)

    return response


if __name__ == "__main__":
    serviceEndpoint = "https://xdoc.example.com/XDocApi/"
    methodSignature = "Document.DocumentDelete"
    securityContext = "SecurityContext"
    securityToken = "cF5NhapgJqCOvH2cSQrHmfkgfwYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnGndTudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyMNHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
    additionalParameters =  { 'ProjectId' : '1000', 'DocumentId' : '2190819175244460059' } 

    print("Now invoking Document.DocumentDelete")
    responseXML = invokeServiceMethod(serviceEndpoint,
                                      methodSignature,
                                      securityContext,
                                      securityToken,
                                      additionalParameters)

    # print invoke URL
    print(f'API Invoke URL:\n{responseXML.url}\n')

    # print response HTTP headers
    print(f'API Response HTTP Headers:\n{responseXML.headers}\n')

    # print XML response
    print(f'API Response XML Envelope:\n{responseXML.text}\n')

    # parse XML response
    xmlDict = xmltodict.parse(responseXML.text)
    resultCode = xmlDict['ServiceResponse']['@ResultCode']
    resultInfo = xmlDict['ServiceResponse']['@ResultInfo']

    # check XwsResultCode in XML payload
    if resultCode != "0":
        print(f'Call failed with result code {resultCode}. Additional info: {resultInfo}')
    else:
        print("Call was successful!")

package main
import (
   "encoding/xml"
   "fmt"
   "io/ioutil"
   "net/http"
   "net/url"
   "time"
)

var (
   serviceEndpoint string
   serviceMethod   string
   securityContext string
   securityToken   string
)

type XMLData struct {
   XMLName        xml.Name     `xml:"ServiceResponse"`
   ServiceName    string       `xml:"ServiceName,attr"`
   ResultInfo     string       `xml:"ResultInfo,attr"`
   ResultCode     string       `xml:"ResultCode,attr"`
   Success        string       `xml:"Success,attr"`
   ErrorCode      string       `xml:"ErrorCode,attr"`
   ErrorInfo      string       `xml:"ErrorInfo,attr"`
   RequestDate    string       `xml:"RequestDate,attr"`
   RequestID      string       `xml:"RequestId,attr"`
   RemoteClientIP string       `xml:"RemoteClientIp,attr"`
   APIStatusCode  string       `xml:"ApiStatusCode,attr"`
   ResponseTrace  string       `xml:"ResponseTrace"`
   ResponseData   ResponseData `xml: "ResponseData"`
}

type ResponseData struct {
   XMLName        xml.Name       `xml:"ResponseData"`
   AppVersionInfo AppVersionInfo `xml:"AppVersionInfo"`
}

type AppVersionInfo struct {
   XMLName      xml.Name `xml:"AppVersionInfo"`
   ProductID    string   `xml:"ProductId,attr"`
   UpdateDate   string   `xml:"UpdateDate,attr"`
   VersionBuild string   `xml:"VersionBuild,attr"`
}

func init() {
	serviceEndpoint = "https://xdoc.example.com/XDocApi/"
	securityContext = "SecurityContext"
	securityToken = "cF5NhapgJqCOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNpVLNxOwz+xpmJOAaEhCzyoMEDJVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzwcrhEEfvPd1WxEd67zbM3kV95UBaEe9zDx7aooRLeKcGCILz0qj2QYgzCCXjEvCS"
}

func InvokeServiceMethod(pXM string, pXSC string, pXST string, pAdditionalParameters map[string]string) (responseHeaders http.Header, responseXML []byte, requestURLStr string) {

   parameters := url.Values{}
   parameters.Add("xm", pXM)
   parameters.Add("xsc", pXSC)
   parameters.Add("xst", pXST)

   if pAdditionalParameters != nil {
      for key, value := range pAdditionalParameters {
         parameters.Add(key, value)
      }
   }

   // parse request url and add paramaters
   requestURL, err := url.ParseRequestURI(serviceEndpoint)
   check(err)
   requestURL.RawQuery = parameters.Encode()

   // create an HTTP client
   client := http.Client{Timeout: time.Second * 10}

   // make request
   requestURLStr = requestURL.String()
   response, err := client.Get(requestURLStr)
   check(err)

   // response headers
   responseHeaders = response.Header

   // read response body
   responseXML, readError := ioutil.ReadAll(response.Body)
   check(readError)
   defer response.Body.Close()

   return responseHeaders, responseXML, requestURLStr
}

func main() {

   // set service method
   serviceMethod = "Document.DocumentDelete"

   // add additional parameters
   additionalParameters := make(map[string]string)
   // add additional parameters
   additionalParameters := make(map[string]string)
   additionParameters["ProjectId"] = "1000"
   additionParameters["DocumentId"] = "2190819175244460059"

   // make request
   responseHeaders, responseXML, requestURLStr := InvokeServiceMethod(serviceMethod, securityContext, securityToken, additionalParameters)

   // print invoke URL
   fmt.Printf("\nAPI Invoke URL: %s\n\n", requestURLStr)

   // print response HTTP headers
   fmt.Println("API Response HTTP Headers:")
   for headerName, headerValue := range responseHeaders {
      fmt.Printf("%s:%s; ", headerName, headerValue[0])
   }

   // print response XML payload
   fmt.Println("\n\nAPI Response XML Envelope: ")
   fmt.Println(string(responseXML) + "\n")

   // unmarshal response XML
   responseXMLData := new(XMLData)
   err := xml.Unmarshal(responseXML, &responseXMLData)
   check(err)

   // check XwsResultCode in XML payload
   if responseXMLData.ResultCode != "0" {
      fmt.Printf("Call failed with result code %s. Additional info: %s", responseXMLData.ResultCode, responseXMLData.ResultInfo)
   } else {
      fmt.Print("Call was successful!")
   }
}

func check(err error) {
   if err != nil {
      panic(err)
   }
}

using System;
using System.Net;
using System.Text;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Cryptography;

/* XDOC API DEMO - Document.DocumentDelete */

namespace xdoc_api_demo
{
    class Program
    {
        // create HTTP client
        private static readonly HttpClient client = new HttpClient();

        // invoke API service method
        private static void InvokeServiceMethod(string pXM, string pXSC, string pXST, string pXUT, Dictionary<string, string> pAdditionalParams)
        {
            // set API service endpoint (input your XDOC server domain here)
            string serviceEndpoint = "http://xdoc.example.com/XDocApi/?";

            // add service method to invoke URL
            string requestURL = serviceEndpoint + "XM=" + pXM;

            // add security context to invoke URL
            requestURL += "&XSC=" + pXSC;

            // add security token to invoke URL (if provided)
            if (!string.IsNullOrEmpty(pXST))
            {
                requestURL += "&XST=" + pXST;
            }

            // add user token to invoke URL (if provided)
            // note: The XUT (user token) is constructed, encrypted, and encoded in a similar manner as the XST; for use with the UI launch service
            if (!string.IsNullOrEmpty(pXUT))
            {
                requestURL += "&XUT=" + pXUT;
            }

            // add in any addition parameters provided to the invoke URL
            if (pAdditionalParams != null)
            {
                foreach (KeyValuePair<string, string> param in pAdditionalParams)
                {
                    requestURL += "&" + param.Key + "=" + param.Value;
                }
            }

            // write final URL to console for debug
            Console.WriteLine($"Invoke URL: {requestURL}\n");

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestURL);
            request.Proxy = null;
            request.Method = "GET";
            request.ContentLength = 0;

            using (HttpWebResponse webResponse = (HttpWebResponse)request.GetResponse())
            {
                // Check the service response for success using the HTTP headers
                var xwsSuccess = (webResponse.Headers["XwsSuccess"] == "1");

                // print response to console
                var encoding = ASCIIEncoding.ASCII;
                using (var reader = new System.IO.StreamReader(webResponse.GetResponseStream(), encoding))
                {
                    string responseXML = reader.ReadToEnd();
                    Console.WriteLine(responseXML);
                }
            }
        }

        // utility method to perform token encryption
        private static string EncryptToken(byte[] pIV, byte[] pEncryptionKey, string pPlainTextToken)
        {
            // Using AES 256 bit encryption settings
            using (RijndaelManaged aesAlg = new RijndaelManaged())
            {
                aesAlg.KeySize = 256; // must match 'key size' in HTTP Server Service Settings UI
                aesAlg.BlockSize = 128; // AES encryption always has 128 bit block size
                aesAlg.Mode = CipherMode.CBC; // must match 'cipher mode' in HTTP Server Service Settings UI
                aesAlg.Key = pEncryptionKey;
                aesAlg.IV = pIV;
                aesAlg.Padding = PaddingMode.PKCS7; // must match 'padding mode' in HTTP Server Service Settings UI

                // create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            swEncrypt.Write(pPlainTextToken);
                        }
                        // return the encrypted byte array converted to a base 64 encoded string
                        return System.Convert.ToBase64String(msEncrypt.ToArray());
                    }
                }
            }
        }

        // utility to ensure correct length for IV and encryption key
        private static byte[] EnsureCorrectLength(string pInput, int pFinalBytesRequiredLength)
        {
            // working variables
            byte[] tempBytes;
            int tempBytesSize = 0;
            byte[] finalBytes;

            // key initialization
            string key = pInput + String.Empty;

            // check to truncate if too long
            if (key.Length > pFinalBytesRequiredLength)
            {
                key = key.Substring(0, pFinalBytesRequiredLength);
            }

            // convert to byte array
            finalBytes = new byte[pFinalBytesRequiredLength];
            tempBytes = Encoding.UTF8.GetBytes(key);
            tempBytesSize = tempBytes.Length;
            for (int i = 0; i < tempBytesSize; i++)
            {
                finalBytes[i] = tempBytes[i];
            }

            // pad with zeros if needed
            if (tempBytesSize < pFinalBytesRequiredLength)
            {
                for (int i = tempBytesSize; i < pFinalBytesRequiredLength; i++)
                {
                    finalBytes[i] = 0x00;
                }
            }
            return finalBytes;
        }

        static void Main(string[] args)
        {

            // define values to use in the security token; reflects the values set in the HTTP Server Service Settings UI
            string sContext = "SecurityContext"; // must match 'security context' value in UI settings
            string sAppID = "MyAppID"; // identier for app utilizing the API
            string sAppKey = "MyAppKey"; // must match 'security token app key' value in UI settings
            string sDTS = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ");
            string sClient = "127.0.0.1"; // set your IP address here
            string sEncryptionKey = "lPdSlEgTkdgsaKfgEksfGhlsHWmwGdjs"; // must match 'encryption key' value set in UI, length of 32 for 256 bit encryption or 16 for 128 bit
            string sIV = "dBKlFmSkGNmEUjvX"; // must match 'init vector' value set in UI, length of 16 to match 128 bit block size in AES

            // construct XML security token
            // notes: the security token may also be constructed using JSON or a form-url-encoded format
            string sToken = "<SecurityToken>";
            sToken += $"<Context>{sContext}</Context>";
            sToken += $"<AppId>{sAppID}</AppId>";
            sToken += $"<AppKey>{sAppKey}</AppKey>";
            sToken += $"<GenDT>{sDTS}</GenDT>";
            sToken += $"<Client>{sClient}</Client>";
            sToken += "</SecurityToken>";
            Console.WriteLine($"Security Token PlainText XML: {sToken}\n");

            // add null padding or trucate to ensure correct length
            byte[] IV = EnsureCorrectLength(sIV, 16);
            byte[] encryptionKey = EnsureCorrectLength(sEncryptionKey, 32);

            // Note: The IV and encryption key in this example are already the correct length
            // if the encryption key or IV value set in the HTTP Server Service settings UI is not the correct length, 
            // XDOC will automatically pad it to the right with null char values or trucate the input to achieve the correct length
            // EnsureCorrectLength demonstrates this behavior and can be used as a safeguard to ensure that the values inputted in the UI will match here.

            // encrypt security token and convert to a base64 encoded string
            string sTokenEncrypted = EncryptToken(IV, encryptionKey, sToken);
            Console.WriteLine($"Encrypted and Base 64 Encoded Security Token: {sTokenEncrypted}\n");

            // URL encode the token
            string sTokenEncoded = WebUtility.UrlEncode(sTokenEncrypted);
            Console.WriteLine($"URL Encoded: {sTokenEncoded}\n");

            // Prepare request parameter values
            string serviceMethod = "Document.DocumentDelete";

            var additionalParams = new Dictionary<string, string> {
               { "ProjectId", "1000" },
               { "DocumentId", "2190819175244460059" },
            };
            

            // make the service method call
            InvokeServiceMethod(pXM: serviceMethod, pXSC: sContext, pXST: sTokenEncoded, pXUT: null, pAdditionalParams: additionalParams);
            
        }
    }
}

<?PHP
   // set parameter values
   $securityContext = 'SecurityContext';
   $securityToken = 'cF5NhapgJqCdopOvH2cSQrFMJe3wYlw4WXUCLBU9SOtSSi+Y3DNKHkdxOwz+xpmJOAaEhCzyoMEgkdlVNcnWp8TudSUCD8NffbyNiF+U+xTV2ez2R7aDnoMmWyABHLRaVNgqzToMCEP4sTka/Hmr/1SHgg6sTEzis7bIGCXA0wnCPKYyo5QjpHt9jf+x2/Hvz4wxW0';
   $methodToInvoke = 'Document.DocumentDelete';
   $projectId = '1000';
   $documentId = '2190819175244460059';
   $parameters = array('xm' => $methodToInvoke, 'xsc' => $securityContext, 'xst' => $securityToken, 'ProjectId' => $projectId, 'DocumentId' => $documentId);

   // set request options
   $options = array(
         'http'=>array(
                       'header'=>"Content-type: application/x-www-form-urlencoded\r\n",
                       'method'  => 'GET',
                       'content' => http_build_query($parameters)
                      )
   );

   // make GET request
   $apiEndpoint = "https://xdoc.example.com/XDocApi/";
   $context = stream_context_create($options);
   $responseXML = file_get_contents($apiEndpoint, false, $context);

   // show XML response in browser
   echo(header('content-type: text/xml'));
   echo $responseXML;

   // parse XML data
   $xmlData = simplexml_load_string($responseXML);
?>

Example Response

XML Payload

HTTP Headers

<ServiceResponse ServiceName="Document" ServiceMethod="Document.DocumentDelete" RequestId="702A7112A5F34F4CB14446471DAAC691" RequestDate="2021-01-25T22:17:23Z" ResponseDate="2021-01-25T22:17:23Z" Success="1" Abort="0" HasWarning="0" ApiStatusCode="S" ApiLogRef="20210125-221723467-702A7112A5F34F4CB14446471DAAC691--Document-DocumentDelete" ReturnData="" ResultCode="0" ResultInfo="Success" ResultInfoEx="" ErrorCode="" ErrorCodeRef="" ErrorInfo="" ErrorInfoEx="" RemoteClientIp="10.10.10.10" RemoteClientIpSource="ClientAddr" ExternalKey="" ExternalInfo="">
    <ResponseData>
        <Document ProjectId="1000" DocumentId="2210125202145460394" WorkUserName="" />
        <ResultInfo DocumentFound="1" UpdateCount="1" ServiceName="XDocBaseApiServerSvc" ServiceMethod="DocumentDelete" ResultWasSet="1" ResultState="0" ApiDoObject="Axacore.XLibs.Core.XDataObject" />
    </ResponseData>
</ServiceResponse>

Name	Value
XwsServiceName	XDOC
XwsServiceMethod	Document.DocumentDelete
XwsRequestId	E3D9A1670A194B02A7AE0B6DC1993167
XwsRequestDate	2019-09-14T00:42:47Z
XwsResponseDate	2019-09-14T00:42:47Z
XwsSuccess	1
XwsAbort	0
XwsHasWarning	0
XwsErrorIsUnexpected	0
XwsApiStatusCode	S
XwsApiLogRef	20190914-004247196-E3D9A1670A194B02A7AE0B6DC1993167
XwsReturnData	Success
XwsResultCode	0
XwsResultInfo	Success
XwsErrorCode	0
XwsErrorInfo
XwsRemoteClientIp	10.10.10.10
XwsRemoteClientIpSource	ClientAddr