Merge

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
using System.Threading; 
using System.Net; 
using System.Net.Http; 
using System.Net.Http.Headers; 
using Newtonsoft.Json.Linq; 
 
namespace Azure_Code_Snippets.DocumentationSnippets 
{ 
   class CloudServices_Merge_Demo 
   { 
      private enum FormatsEnum 
      { 
         Png = 1, 
         Jpeg = 2, 
         Tiff = 3, 
         Pdf = 4, 
         Pdfa = 5, 
         PdfImage = 6, 
         PdfImageOverText = 7, 
         PdfaImageOverText = 8, 
         Docx = 9, 
         DocxFramed = 10, 
         Rtf = 11, 
         RtfFramed = 12, 
         Txt = 13, 
         TxtFramed = 14, 
      } 
 
      private string hostedServicesUrl = "https://azure.leadtools.com/api/"; 
 
      public async Task<bool> Merge(string firstFileId, string secondFileId) 
      { 
         var mergeList = new List<MergeArgument>(); 
         mergeList.Add(new MergeFirstLast() 
         { 
            fileId = firstFileId, 
            firstPage = 1, 
            lastPage = -1 
         }); 
 
         mergeList.Add(new MergePageArray() 
         { 
            fileId = secondFileId, 
            pages = new int[]{ 5, 1, 2, 4, 2 } 
         }); 
 
         //Final output format for the merged file 
         var outputFormat = FormatsEnum.Pdf; 
         var mergeUrl = string.Format("Conversion/Merge?format={0}", outputFormat); 
         var response = await client.PostAsync(mergeUrl, new StringContent(JsonConvert.SerializeObject(mergeList), Encoding.UTF8, "application/json")); 
         return response.StatusCode == HttpStatusCode.OK; 
 
      } 
 
      private HttpClient InitClient() 
      { 
         string AppId = "Enter Application ID"; 
         string Password = "Enter Application Password"; 
 
         HttpClient client = new HttpClient(); 
         client.BaseAddress = new Uri(hostedServicesUrl); 
         client.DefaultRequestHeaders.Accept.Clear(); 
         client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); 
 
         string authData = string.Format("{0}:{1}", AppId, Password); 
         string authHeaderValue = Convert.ToBase64String(Encoding.UTF8.GetBytes(authData)); 
         client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authHeaderValue); 
 
         return client; 
      } 
 
      private class MergeArgument 
      { 
         public string fileId { get; set; } 
      } 
 
      private class MergeFirstLast: MergeArgument 
      { 
         public int firstPage { get; set; } 
         public int lastPage { get; set; } 
      } 
 
      private class MergePageArray : MergeArgument 
      { 
         public int[] pages { get; set; } 
      } 
   } 
} 

#Simple script to make a Merge request to the LEADTOOLS CloudServices and parse the resulting JSON. 
 
import requests, sys, time 
 
# Enums in python 
from enum import Enum 
 
class FormatsEnum(Enum): 
    Png = 1 
    Jpeg = 2 
    Tiff = 3 
    Pdf = 4 
    Pdfa = 5 
    PdfImage = 6 
    PdfImageOverText = 7 
    PdfaImageOverText = 8 
    Docx = 9 
    DocxFramed = 10 
    Rtf = 11 
    RtfFramed = 12 
    Txt = 13 
    TxtFramed = 14 
 
servicesUrl = 'https://azure.leadtools.com/api/' 
 
#The application ID. 
appId = "Enter Application ID"; 
 
#The application password. 
password = "Enter Application Password"; 
 
#These ID's will be acquired by calling the Upload API command with the forMerge flag set to true. 
firstFileId = "" 
secondFileId = "" 
 
data = [] 
 
firstFileData = {} 
# pass every page in the file 
firstFileData['firstPage'] = 1 
firstFileData['lastPage'] = -1 
firstFileData['fileId'] = firstFileId 
data.append(firstFileData) 
 
secondFileData = {} 
# Make sure this file's pages are merged in a specific order. 
secondFileData['pages'] = [5,1,2,4,3] 
secondFileData['fileId'] = secondFileId 
data.append(secondFileData) 
 
# The output format of the merged files 
mergeFormat = FormatsEnum.Pdf.value 
 
baseMergeUrl = '{}Conversion/Merge?format={}' 
formattedMergeUrl = baseMergeUrl.format(servicesUrl, mergeFormat) 
request = requests.post(formattedMergeUrl, auth=(appId, password), json=data) 
if request.status_code != 200: 
        print("Error sending merge request") 
        print(request.text) 
        sys.exit() 

<?php 
    //Simple script to make a Conversion request to the LEADTOOLS CloudServices and parse the resulting JSON. 
 
    $servicesBaseUrl = "https://azure.leadtools.com/api/"; 
 
    abstract class FormatsEnum 
    { 
        const Png = 1; 
        const Jpeg = 2; 
        const Tiff = 3; 
        const Pdf = 4; 
        const Pdfa = 5; 
        const PdfImage = 6; 
        const PdfImageOverText = 7; 
        const PdfaImageOverText = 8; 
        const Docx = 9; 
        const DocxFramed = 10; 
        const Rtf = 11; 
        const RtfFramed = 12; 
        const Txt = 13; 
        const TxtFramed = 14; 
    } 
 
     //These ID's will be acquired by calling the Upload API command with the forMerge flag set to true. 
    $firstFileId = ""; 
    $secondFileId = ""; 
 
    $data = []; 
 
    $firstFileData = array( 
        "firstPage" => 1, 
        "lastPage" => -1, 
        "fileId" => $firstFileId 
    ); 
    $secondFileData = array( 
        "pages" => [5,1,2,3,4], 
        "fileId" => $secondFileId 
    ); 
    array_push($data, $firstFileData, $secondFileData); 
 
    $fileFormat = FormatsEnum::Pdf; 
    $mergeUrl = "%sConversion/Merge?format=%s"; 
    $mergeUrl = sprintf($mergeUrl, $servicesBaseUrl, $fileFormat); 
    $mergeOptions = GeneratePostOptionsMerge($mergeUrl, $data); 
 
    $r = curl_init(); 
    curl_setopt_array($r, $mergeOptions); //Set the request URL 
 
    if (!$id = curl_exec($r)) { 
        echo "There was an error sending the merge request \n\r"; 
        echo $id; 
        exit; 
    } 
    curl_close($r); //Close the request 
 
 
    function GeneratePostOptionsMerge($url, $jsonData) 
    { 
        $options = GeneratePostOptionsUpload($url); 
        //remove 0 content-length header 
        unset($options[CURLOPT_HTTPHEADER]); 
 
        $encodedData = json_encode($jsonData); 
        $options[CURLOPT_POSTFIELDS] = $encodedData; 
        $options[CURLOPT_HTTPHEADER] = array( 
            'Content-Type: application/json', 
            'Content-Length: ' . strlen($encodedData) 
        ); 
        return $options; 
    } 
 
    function GeneratePostOptions($url) 
    { 
        $appId = "Enter Application ID"; 
        $password = "Enter Application Password"; 
        $headers = array( 
            "Content-Length : 0" 
        ); 
        $postOptions = array( 
            CURLOPT_POST => 1, 
            CURLOPT_URL => $url, 
            CURLOPT_FRESH_CONNECT => 1, 
            CURLOPT_RETURNTRANSFER => 1, 
            CURLOPT_USERPWD => "$appId:$password", 
            CURLOPT_FORBID_REUSE => 1, 
            CURLOPT_HTTPHEADER => $headers 
        ); 
        return $postOptions; 
    } 
?> 

#Simple script to make and process the results of a merge request to the LEADTOOLS CloudServices. 
 
use base 'HTTP::Message'; 
use LWP::UserAgent (); 
 
require HTTP::Request; 
require HTTP::Headers; 
 
my $servicesUrl = "https://azure.leadtools.com/api/"; 
 
my $appId = 'Enter Application ID'; 
my $password = 'Enter Application Password'; 
my $headers = HTTP::Headers->new( 
    Content_Length => 0 
); 
$headers->authorization_basic($appId, $password); 
 
#These ID's will be acquired by calling the Upload API command with the forMerge flag set to true. 
my $firstFileId = ""; 
my $secondFileId = ""; 
 
#The User Agent to be used when making requests 
my $ua = LWP::UserAgent->new; 
 
my @data = (); 
push( @data, { 
        firstPage => 1, 
        lastPage => -1, 
        fileId => $firstFileId 
}); 
 
push( @data, { 
    'pages' => [5,1,2,4,3], 
    'fileId' => $secondFileId 
}); 
 
#Enum corresponding to the output format for the file. For the purposes of this script, we will be converting to PDF. 
my $outputFormat = 4; 
my $mergeUrl = $servicesUrl . 'Conversion/Merge?format=' . $outputFormat; 
my $encodedData = to_json \@data; 
 
my $headers =HTTP::Headers->new( 
    Content_Type => 'application/json' 
); 
$headers->authorization_basic($appId, $password); 
 
my $request = HTTP::Request->new(POST => $mergeUrl, $headers); 
$request->content($encodedData); 
my $response = $ua->request($request); 
if(!$response->is_success){ 
        print STDERR $response->status_line, "\n"; 
        exit; 
    } 
 
print("Merge request successful \n\r");