Queue - NodeJS

//Simple script to showcasing how to queue up and run multiple requests using the LEADTOOLS CloudServices. 
 
const axios = require("axios"); 
 
//If uploading a file as multi-part content, we will need the file-system library installed. 
//const fs = require('fs'); 
 
const servicesUrl = "https://azure.leadtools.com/api/"; 
 
//The first page in the file to mark for processing 
const firstPage = 1; 
 
//Sending a value of -1 will indicate to the services that the rest of the pages in the file should be processed. 
const lastPage = -1; 
 
//Enum corresponding to the output format for the file. For the purposes of this script, we will be converting to tif. 
const fileFormat = 4; 
 
//We will be uploading the file via a URl.  Files can also be passed by adding a PostFile to the request.  Only 1 file will be accepted per request. 
//The services will use the following priority when determining what a request is trying to do GUID > URL > Request Body Content 
const fileURL = "http://demo.leadtools.com/images/cloud_samples/ocr1-4.tif"; 
 
let guid = ""; 
 
const uploadUrl = servicesUrl + "UploadFile?fileurl=" + fileURL; 

axios 
  .post(uploadUrl, {}, getRequestOptions(uploadUrl)) 
  .then((res) => { 
    uploadCallback(res.error, res, res.data); 
  }) 
  .catch((err) => { 
    console.error(err); 
  }); 
 
//If uploading a file as multi-part content: 
/*const uploadUrl = servicesUrl + "UploadFile"; 
const form = new FormData(); 
form.append("file", fs.createReadStream('path\to\inputFile')); 
axios.post(uploadUrl, form, getRequestOptions(uploadUrl)).then((res) => { 
    uploadCallback(res.error, res, res.data); 
}).catch ((err) => { 
    console.error(err); 
});*/ 
 
function uploadCallback(error, response, body) { 
  if (!error && response.status === 200) { 
    guid = body; 
    console.log("Unique ID returned by the Services: " + guid); 
 
    checkVerification(); 
  } 
} 

async function checkVerification() { 
  const queryUrl = servicesUrl + "Query?id=" + guid; 
  await axios 
    .post(queryUrl, {}, getRequestOptions(queryUrl)) 
    .then((res) => { 
      const results = res.data; 
      if (!res.error && results["FileStatus"] !== 123) { 
        console.log("Verification finished with return code: " + res.status); 
        if (results["FileStatus"] == 122) { 
          const recognitionUrl = 
            servicesUrl + 
            "Recognition/ExtractText?firstPage=" + 
            firstPage + 
            "&lastPage=" + 
            lastPage + 
            "&guid=" + 
            guid; 
          axios 
            .post(recognitionUrl, {}, getRequestOptions(recognitionUrl)) 
            .then((res) => { 
              recognitionCallback(res.error, res, res.data); 
            }) 
            .catch((err) => { 
              console.error(err); 
            }); 
        } else { 
          console.log( 
            "File failed verification with File Status: " + 
              results["FileStatus"] 
          ); 
        } 
      } else { 
        //The file has not yet finished processing. 
        return new Promise((resolve) => { 
          setTimeout(() => { 
            //Sleep for 5 seconds before trying again 
            resolve(checkVerification()); //Call the method again. 
          }, 5000); 
        }); 
      } 
    }) 
    .catch((err) => { 
      console.error(err); 
    }); 
} 

function recognitionCallback(error, response, body) { 
  if (!error && response.status === 200) { 
    console.log("ExtractText successfully queued"); 
 
    const conversionUrl = 
      servicesUrl + 
      "Conversion/Convert?firstPage=" + 
      firstPage + 
      "&lastPage=" + 
      lastPage + 
      "&guid=" + 
      guid + 
      "&format=" + 
      fileFormat; 
    axios 
      .post(conversionUrl, {}, getRequestOptions(conversionUrl)) 
      .then((res) => { 
        conversionCallback(res.error, res, res.data); 
      }) 
      .catch((err) => { 
        console.error(err); 
      }); 
  } else { 
    console.log( 
      "ExtractText failed to queue with HTTP code: " + response.status 
    ); 
    console.log(body); 
  } 
} 
 
function conversionCallback(error, response, body) { 
  if (!error && response.status === 200) { 
    console.log("Conversion successfully queued"); 
 
    const runUrl = servicesUrl + "Run?id=" + guid; 
    axios 
      .post(runUrl, {}, getRequestOptions(runUrl)) 
      .then((res) => { 
        runCallback(res.error, res, res.data); 
      }) 
      .catch((err) => { 
        console.error(err); 
      }); 
  } else { 
    console.log( 
      "Conversion failed to queue with HTTP code: " + response.status 
    ); 
    console.log(body); 
  } 
} 
 
function runCallback(error, response, body) { 
  if (!error && response.status === 200) { 
    console.log("File has been successfully marked to run"); 
    queryServices(); 
  } else { 
    console.log("Run failed with HTTP code: " + response.status); 
    console.log(body); 
  } 
} 

async function queryServices() { 
  //Function to query the status of a request.  If the request has not yet finished, this function will recursively call itself until the file has finished. 
  const queryUrl = servicesUrl + "Query?id=" + guid; 
  await axios 
    .post(queryUrl, {}, getRequestOptions(queryUrl)) 
    .then((res) => { 
      const results = res.data; 
      if (!res.error && results["FileStatus"] !== 100) { 
        console.log("File finished processing with return code: " + res.status); 
        if (results["FileStatus"] !== 200) { 
          return; 
        } 
        console.log("Results: \n"); 
        parseJson(results["RequestData"]); 
      } else { 
        //The file has not yet finished processing. 
        return new Promise((resolve) => { 
          setTimeout(() => { 
            //Sleep for 5 seconds before trying again 
            resolve(queryServices()); //Call the method again. 
          }, 5000); 
        }); 
      } 
    }) 
    .catch((err) => { 
      console.error(err); 
    }); 
} 

function parseJson(jsonObject) { 
  //Function to decode the JSON object that was returned by the LEADTOOLS CloudServices. 
  for (let i = 0; i < jsonObject.length; i++) { 
    let currentRequest = jsonObject[i]; 
    console.log("Service Type: " + currentRequest["ServiceType"]); 
    if ( 
      currentRequest["ServiceType"] === "Recognition" && 
      currentRequest["RecognitionType"] === "Text" 
    ) { 
      console.log("Recognition Method: " + currentRequest["RecognitionType"]); 
      console.log("Data:" + currentRequest["data"]); 
    } else if (currentRequest["ServiceType"] === "Conversion") { 
      console.log("Urls: "); 
      currentRequest["urls"].forEach((url) => { 
        console.log(url); 
      }); 
    } else { 
      console.log("Unanticipated service type"); 
    } 
  } 
} 

function getRequestOptions(url) { 
  const appId = "Replace with Application ID"; 
  const password = "Replace with Application Password"; 
 
  const token = Buffer.from(`${appId}:${password}`, "utf8").toString("base64"); 
  //Function to generate and return HTTP request  options. 
  const requestOptions = { 
    url: url, 
    data: {}, 
    //If uploading a file as multi-part content, remove the Content-Length header. 
    headers: { 
      "Content-Length": 0, 
      Authorization: `Basic ${token}`, 
    }, 
  }; 
  return requestOptions; 
}