using pdfdocument c# : Add url to pdf software application project winforms html windows UWP WATUsageGuide32-part875

Java Programmer's Guide
319
_errors.add(response);
}
public List<RobotErrorResponse> getErrors() {
return _errors;
}
public List<RobotOutputObjectResponse> getOutput() {
return _output;
}
}
}
The example above shows how to use a  RobotResponseHandler that collects returned values
and errors. This type of handler is useful if the robot should continue to execute even when error
are encountered, this can be useful if the website is unstable and occasionally times out. Notice that
only robot errors (API exceptions) are collected by the handler, if the connection to RoboServer is
lost Request.execute() will still throw an RQLException (and the robot will be stopped by
RoboServer).
For more details check the RobotResponseHandler JavaDoc.
SSL
The API communicates with RoboServer through an RQLService. The RQLService is a RoboServer
component which listens for API requests on a specific network port. When you start a RoboServer you
specify if the RoboServer should use the encrypted SSL service, or the plain socket service, or both (using
two different ports). All RoboServers in a cluster must be running the same RQLService (although the
port may be different).
Assuming we have started a RoboServer with the SSL RQLService on port 50043, like this
RoboServer -service ssl:50043
we can use the following code
Table 66. SSL configuration
RoboServer server = new RoboServer("localhost", 50043);
boolean ssl = true;
Cluster cluster = new Cluster("MyCluster", new RoboServer[] {server}, ssl);
Request.registerCluster(cluster);
All we need to do is to create the cluster as an SSL cluster and specify the SSL port used by each
RoboServer. Now all communication between RoboServer and the API will be encrypted.
For this example to work you need commons-ssl-0.3.8.jar in you application classpath, you can
find it next to the API jar file inside your kapow installation.
In addition to data encryption, SSL offers the possibility to verify the identity the remote party. This type
of verification is very important on the Internet, as rouge websites could otherwise pretend to be someone
they are not. Most often your API client and RoboServers will be on the same local network, so you rarely
need to verify the identity of the other party, but the API supports this feature should it become necessary.
Add url to pdf - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
adding hyperlinks to pdf; pdf hyperlinks
Add url to pdf - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
pdf email link; convert excel to pdf with hyperlinks
Java Programmer's Guide
320
Because identity verification is almost never used we will not describe it in this guide. If you are interested,
you should look at the SSL examples that are included with the Java API.
Parallel execution
Both execute methods of the Request are blocking, which means that a thread is required for each robot
execution. The examples we have looked at until now have all executed the robot directly on the main
thread, which is typically not preferable as you can only execute a single robot at a time in a sequential
manner.
Let's  look  at  an example that  will  execute  two  tutorial  robots in parallel.  This  example  uses  the
java.util.concurrent library for multithreading.
Table 67. Multithreading Example
import com.kapowtech.robosuite.api.java.repository.construct.*;
import com.kapowtech.robosuite.api.java.rql.*;
import com.kapowtech.robosuite.api.java.rql.construct.*;
import com.kapowtech.robosuite.api.java.rql.engine.hotstandby.*;
import java.util.concurrent.*;
public class ParallelExecution {
public static void main(String[] args) throws Exception {
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[] {server}, false);
Request.registerCluster(cluster);
int numRobots = 4;
int numThreads = 2;
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(numThreads, numThreads, 10, TimeUnit.SECONDS, new LinkedBlockingQueue());
for (int i = 0; i < numRobots; i++) {
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.setRobotLibrary(new DefaultRobotLibrary());
threadPool.execute(new RobotRunnable(request));
}
threadPool.shutdown();
threadPool.awaitTermination(60, TimeUnit.SECONDS);
}
// -----------------------------------------------------------------
// Inner classes
// -----------------------------------------------------------------
static class RobotRunnable implements Runnable {
Request _request;
RobotRunnable(Request request) {
_request = request;
}
C#: How to Open a File from a URL (HTTP, FTP) in HTML5 Viewer
License and Price. File Formats. PDF. Word. Excel. PowerPoint. Tiff. DNN (Dotnetnuke). Quick to Start. Add a Viewer Control on Open a File from a URL (HTTP, FTP).
add hyperlink pdf; clickable links in pdf files
C#: How to Add HTML5 Document Viewer Control to Your Web Page
addTab(_tabRedact); //add Tab "Sample new UserCommand("pdf"); _userCmdDemoPdf.addCSS( new customStyle({ background: "url('RasterEdge_Resource_Files/images
clickable pdf links; adding hyperlinks to a pdf
Java Programmer's Guide
321
public void run() {
try {
RQLResult result = _request.execute("MyCluster");
System.out.println(result);
}
catch (RQLException e) {
e.printStackTrace();
}
}
}
}
The  above  example  creates  a  ThreadPoolExecutor  with  two  threads,  we  then  creates  four
RobotRunnables and execute them on the thread pool. Since the thread pool has two threads, two robots
will start to execute immediately, the remaining two will be parked in the LinkedBlockingQueue and
executed in order as the two first robot finish their execution and the thread pool threads become available.
Please note that the Request is mutable, to avoid raise conditions the Request is cloned inside the execute
method. Because Request is mutable you should never modify the same Request on separate threads.
Repository Integration
In the Management Console you also specify cluster of RoboServers, these are used to execute scheduled
robots, as well as robots executed as REST services. The API allowed you to use the RepositoryClient
to obtain cluster information from Management Console, check the RepositoryClient documentation for
details.
Table 68. Repository Integration
public class RepositoryIntegration {
public static void main(String[] args) throws Exception {
RepositoryClient client = RepositoryClientFactory.createRepositoryClient("http://localhost:50080", null, null);
Request.registerCluster(client, "Cluster 1");
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.setRobotLibrary(new DefaultRobotLibrary());
RQLResult result = request.execute("MyCluster");
System.out.println(result);
}
}
The  above  example  shows  how  to  create  a  RepositoryClient  [api/com/kapowtech/
robosuite/api/java/repository/engine/RepositoryClient.html] which connects
to  a  Management  Console  deployed  on  localhost.  For  this  example  to  work,
you  must  have  commons-logging-1.1.1.jar,commons-codec-1.4.jar,commons-
httpclient-4.1.jar included in your classpath.
Authentication is not enabled so null is passed as both username and password. When we register the
RepositoryClient we specify the name of a cluster which exists on the Management Console, this
C# PDF Library SDK to view, edit, convert, process PDF file for C#
editing PDF document hyperlink (url) and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update
add hyperlink to pdf; add links to pdf in acrobat
C# Image: How to Download Image from URL in C# Project with .NET
Add this imaging library to your C#.NET project jpeg / jpg, or bmp image from a URL to your provide powerful & profession imaging controls, PDF document, tiff
active links in pdf; check links in pdf
Java Programmer's Guide
322
will then query the Management Console to get a list of RoboServers configured for this cluster, and check
every 2 minutes to see if the cluster configuration has been updated on the Management Console.
This integration allows you to create a cluster on Management Console that you can change dynamically
using the Management Console user interface. When you use a Management Console cluster with the API
usage should be exclusive, and you should not use it for scheduling robot, as this would break the two
client rule.
Under the hood
The section will explain what is going on under the hood when you register a cluster and execute a
Requests.
When you register a Cluster with the Request, a RequestExecutor is created behind the scene.
This RequestExecutor is stored in a Map using the cluster name as key. When a request is executed
the provided cluster name is used to find the associated RequestExecutor and execute the request.
Let's look at a short example
Table 69. Normal execution
public static void main(String[] args) throws InterruptedException, RQLException {
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[]{ server}, false);
Request.registerCluster(cluster);
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.setRobotLibrary(new DefaultRobotLibrary());
RQLResult result = request.execute("MyCluster");
System.out.println(result);
}
Now let's write the same example by using the hidden RequestExecutor directly
Table 70. under the hood execution
public static void main(String[] args) throws InterruptedException, RQLException {
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[]{ server}, false);
RequestExecutor executor = new RequestExecutor(cluster);
Request request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.setRobotLibrary(new DefaultRobotLibrary());
RQLResult result = executor.execute(request);
System.out.println(result);
}
The reason the RequestExecutor  [api/com/kapowtech/robosuite/api/java/rql/
engine/hotstandby/RequestExecutor.html]  is  hidden  by  default,  is  so  you  don't
have  to  keep  track  of  it.  You  may  only  create  one  RequestExecutor  per  cluster,  so
C# PDF insert image Library: insert images into PDF in C#.net, ASP
C#.NET PDF SDK - Add Image to PDF Page in C#.NET. How to Insert & Add Image, Picture or Logo on PDF Page Using C#.NET. Add Image to PDF Page Using C#.NET.
add hyperlink in pdf; adding links to pdf in preview
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Insert Image to PDF. Image: Remove Image from PDF Page. Cut Image in Page. Link: Edit URL. Bookmark: Edit Images. Redact Pages. Annotation & Drawing. Add Sticky Note
convert doc to pdf with hyperlinks; add links to pdf file
Java Programmer's Guide
323
if  you  use  it  directly  you  need  to  store  a  reference  to  it  throughout  your  application.
Using    Request.registerCluster(cluster)  means  that  you  can  blissfully  ignore  the
RequestExecutor and lifecycle rules.
The RequestExecutor contains the necessary state and logic which provides the load balancing and
failover features. Using the RequestExecutor directly also offers a few extra features, which we will
look at.
RequestExecutor Features
When the RequestExecutor is not connected to a repository, you can dynamically add remove
RoboServers, by calling addRoboServer(..) and removeRoboServer(..). These methods
modifies the distribution list used inside the RequestExecutor.
RequestExecutor.getTotalAvailableSlots() returns the number of unused execution slots
across all RoboServers in the internal distribution list.
By using these methods you can dynamically add RoboServers to your RequestExecutor once the
number of available execution slots becomes low.
When  you  create  the  RequestExecutor  you  may  optionally  provide  an
RQLEngineFactory 
[api/com/kapowtech/robosuite/api/java/rql/engine/
hotstandby/RQLEngineFactory.html]. The RQLEngineFactory allows you to customize
which  RQLProtocol 
[api/com/kapowtech/robosuite/api/java/rql/engine/
remote/RQLProtocol.html] is used when connecting to a RoboServer. This is only needed under
very rare circumstances, for instance if you want use a client certificate to increase security, check API
Client Certificates for details.
Web applications
The  RequestExecutor  [api/com/kapowtech/robosuite/api/java/rql/engine/
hotstandby/RequestExecutor.html] contains a number of internal threads used for sending
and receiving requests to RoboServers, as well as pinging each known RoboServer at regular intervals.
These threads are all marked as daemon, which means that they don't prevent the JVM from stopping
when the main thread exists, check  Thread JavaDoc [http://docs.oracle.com/javase/1.4.2/docs/api/java/
lang/Thread.html] for details on daemon threads.
If you use the RequestExecutor inside a web application, the JVM has a longer lifespan than your web
application, and you can deploy and un-deploy your web application while the web container is running.
This means that a web application is responsible for stopping any threads that it has created, if it does
not a memory leak will be created when you un-deploy the web application. The memory leak occurs
because any objects referenced by running threads can't be garbage collected until the threads stop, so if
these threads are not stopped when the application is un-deployed, they will never be garbage collected.
If  you  use  the  RequestExecutor  inside  a  web  application your code  is  responsible
for  shutting  down  these  internal  threads,  this  is  done  by  calling  Request.shutdown()
[api/com/kapowtech/robosuite/api/java/rql/Request.html#shutdown()]  or
RequestExecutor.shutdown()  [api/com/kapowtech/robosuite/api/java/rql/
engine/hotstandby/RequestExecutor.html#shutdown()]  if  your  code  created  the
RequestExecutor explicitly.
This example show you how to use a ServletContextListener to shutdown the API correctly when
a web application is un-deployed. You must define the context listener in your applications web.xml.
Table 71. proper shutdown in web application
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
to PDF. Image: Remove Image from PDF Page. Image Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Redact Pages. Annotation & Drawing. Add Sticky Note
add url to pdf; add page number to pdf hyperlink
VB.NET Image: VB Code to Download and Save Image from Web URL
Apart from image downloading from web URL, RasterEdge .NET Imaging SDK still dedicated to provide powerful & profession imaging controls, PDF document, image
add links in pdf; adding a link to a pdf in preview
Java Programmer's Guide
324
import com.kapowtech.robosuite.api.java.repository.construct.*;
import com.kapowtech.robosuite.api.java.rql.*;
import com.kapowtech.robosuite.api.java.rql.construct.*;
import javax.servlet.*;
public class APIShutdownListener implements ServletContextListener {
public void contextInitialized(ServletContextEvent servletContextEvent) {
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[]{ server}, false);
try {
Request.registerCluster(cluster);
}
catch (ClusterAlreadyDefinedException e) {
throw new RuntimeException(e);
}
}
public void contextDestroyed(ServletContextEvent servletContextEvent) {
Request.shutdown();
}
}
contextDestroyed is called  when  the web container  un-deploys the application.  Here we  call
Request.shutdown() to ensure that all internal threads in the hidden RequestExecutor are
stopped correctly.
Since  contextInitialized  can't  throw  any  unchecked  exceptions  we  have  to  wrap  the
ClusterAlreadyDefinedException in a RunTimeException. Developers may be tempted to
ignore the ClusterAlreadyDefinedException at this location, because they claim that it can't be
thrown, as our application has not defined any other clusters. However due to the class loader hierarchy
in java web containers it is actually possible to get this exception if the application is deployed twice. It
will however only occur if the API jar file was loaded by a common class loader and not by the individual
application's class loader.
API Debugging
Although this is rarely needed, the API can provide additional information for debugging purposes. To
enable API debugging you need to configure the system property DEBUG_ON. The value of this property
must be a package/class name the API.
For instance, if you are interested in the data transmissions between the API and RoboServer, you could ask
for debugging information for package com.kapowtech.robosuite.api.java.rql.io. While
you are developing you can do this by directly setting the system property in code, like this:
Table 72. Enabling Debug
System.setProperty("DEBUG_ON", "com.kapowtech.robosuite.api.java.rql.io");
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[]{ server}, false);
Request.registerCluster(cluster);
Java Programmer's Guide
325
If you are debugging an application in production, you would define the system property via the command
line, like this
Table 73. Enabling Debug
java -DDEBUG_ON=com.kapowtech.robosuite.api.java.rql.io Tutorial1
If you are interested in debug from multiple packages, you separate the package names by , (comma).
Instead of a package name, you can provide the argument ALL, to have debug from all packages printed.
Repository API
The Repository API allows you to query the Management Console's Repository, to get a list of projects,
robots and the input required to call a robot. It also allows you to programmatically deploy robots, types
and resource files.
Dependencies
To use the Repository API you need the following libraries, all libraries can be found in the API/
robosuite-java-api/lib folder inside you Kapow Katalyst installation folder
• commons-logging-1.1.1.jar, or newer
• commons-codec-1.4.jar, or newer
• commons-httpclient-4.1.jar, or newer
• commons-ssl-0.3.8.jar, or newer - if your Management Console must be accessed through
HTTPs
You also need to use Java 1.5 or newer.
Repository Client
Communication  with  the  repository  is  achieved  through  the  RepositoryClient  found  in  the
com.kapowtech.robosuite.api.java.repository.engine
Table 74. Create RepositoryClient
public static void main(String[] args) {
String username = "admin";
String password = "admin";
try {
RepositoryClient client = RepositoryClientFactory.createRepositoryClient("http://localhost:50080/", username, password);
Project[] projects = client.getProjects();
for (Project project : projects) {
System.out.println(project.getName());
}
}
catch (RepositoryClientException e) {
e.printStackTrace();
Java Programmer's Guide
326
}
}
Here we see a RepositoryClient configured to connect to Management Console's repository on
http://localhost:50080/ , with a username and password.
Once the RepositoryClient is created, we use the getProjects() method to query the repository
for  a  list  of  projects.  Notice  that  when  calling  any  of  the  RepositoryClient  methods,  a
RepositoryClientException will be thrown if an error occurs.
The RepositoryClient has the following eleven methods
Table 75. Methods of the RepositoryClient
Method signature
description
void 
deleteResource(String
projectName,  String  resourceName,
boolean silent)
Deletes a resource from a project. If silent is true no
error is generated if the resource doesn't exist
void 
deleteRobot(String
projectName, 
String 
robotName,
boolean silent)
Deletes a robot from a project
void 
deleteSnippet(String
projectName,  String  snippetName,
boolean silent)
Deletes a snippet from a project
void 
deleteType(String
projectName, 
String 
modelName,
boolean silent)
Deletes a type from a project
void 
deployLibrary(String
projectName,
EmbeddedFileBasedRobotLibrary
library, boolean failIfExists)
Deploys  a  library  to  the  server.  Robots,
types  and  resources  will  be  overridden  unless
failIfExists is true.
void 
deployResource(String
projectName,  String  resourceName,
byte[] 
resourceBytes, 
boolean
failIfExists)
Deploys a resource to a project. If a resource with
the given name already exist it can be overridden by
setting failIfExists to false.
void 
deployRobot(String
projectName, 
String 
robotName,
byte[] 
robotBytes, 
boolean
failIfExists)
Deploys a robot to a project.If a robot with the given
name already exist it can be overridden by setting
failIfExists to false.
void 
deploySnippet(String
projectName,  String  snippetName,
byte[] 
snippetBytes, 
boolean
failIfExists)
Deploys a robot to a project. If a snippet with the
given name already exist it can be overridden by
setting failIfExists to false.
void 
deployType(String
projectName, 
String 
typeName,
byte[] 
typeBytes, 
boolean
failIfExists)
Deploys a type to a project. If a type with the given
name already exist it can be overridden by setting
failIfExists to false.
Project[] getProjects()
Returns the projects that exist in this repository
Cluster[] getRoboServerClusters()
Return the cluster configuration on the Management
Console
Java Programmer's Guide
327
Method signature
description
Robot[]  getRobotsInProject(String
projectName)
Returns the robots available in the project with the
given name.
RobotSignature
getRobotSignature(String
projectName, String robotName)
Returns the robot signature, e.i. the input variables
required to execute this robot and a list of the types
it may return or store
Proxy servers must be specified explicitly when creating the RepositoryClient. Standard http proxy servers
without authentication are supported. NTLM proxy servers with authentication is also supported.
Check 
the 
RepositoryClient 
[api/com/kapowtech/robosuite/api/java/repository/engine/
RepositoryClient.html] JavaDoc for additional details
Deployment via Repository Client
The following example shows how to deploy a robot and a type from the local file system using the
RepositoryClient
Table 76. Deployment using RepositoryClient
String user = "test";
String password = "test1234";
RepositoryClient client = new RepositoryClient("http://localhost:50080", user, password);
try {
FileInputStream robotStream = new FileInputStream("c:\\MyRobots\\Library\\Test.robot");
FileInputStream typeStream = new FileInputStream("c:\\MyRobots\\Library\\Test.type");
// Use the Kapow Java APIs StreamUtil to convert InputStream to byte[].
// For production we recommend IOUtils.toByteArray(InputStream i) in the commons-io library from apache.
byte[] robotBytes = StreamUtil.readStream(robotStream).toByteArray();
byte[] typeBytes = StreamUtil.readStream(typeStream).toByteArray();
// we assume that no one has deleted the Default project
client.deployRobot("Default project", "Test.robot", robotBytes, true);
client.deployType("Default project", "Test.type", typeBytes, true);
}
catch (RepositoryClientException e) {
// an error connecting to the repository
e.printStackTrace();
}
catch (FileNotFoundException e) {
System.out.println("Could not load file from disk " + e.getMessage());
}
catch (IOException e) {
System.out.println("Could not read bytes from stream " + e.getMessage());
}
catch (FileAlreadyExistsException e) {
// either the type or file already exist in the give project
System.out.println(e.getMessage());
}
Java Programmer's Guide
328
Repository REST API
The repository API is actually a group of restful services (and URLs where data can be posted).
All the Repository Client methods that retrieve information from the repository sends XML to the
Repository, and the Repository responds with XML. All deploy methods post bytes to the Repository
(information encoded in URL) and the Repository return XML to acknowledge. The format of the
XML  sent  and  received  is  governed  by  a  DTD  found  here [http://www.kapowtech.com/robosuite/
repository_1_3.dtd].
Here is an example of all the XML based requests, all messages must start with the following declaration
Table 77.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE repository-request PUBLIC "-//Kapow Technologies//DTD Repository 1.3//EN" "http://www.kapowtech.com/robosuite/repository_1_3.dtd">
If the Management Console is deployed at http://localhost:8080/ManagementConsole,
the  requests must  be posted  to  http://localhost:8080/ManagementConsole/secure/
RepositoryAPI?format=xml
Table 78. REST operations
Method
Example request
Example response
delete-
file
(robot)
<repository-request> <delete-
file 
file-type="robot"
silent="true"> 
<project-
name>Default 
project</
project-name> 
<file-
name>InputA.type</file-name>
</delete-file>  </repository-
request>
<repository-response><delete-
successful/></repository-
response>
delete-
file
(type)
<repository-request> <delete-
file 
file-type="type"
silent="false"> 
<project-
name>Default 
project</
project-name> 
<file-
name>InputA.type</file-name>
</delete-file>  </repository-
request>
<repository-response><error
type="file-not-found">Could
not 
find 
a 
Type 
named
InputA.type 
in 
project
'Default 
project'</error></
repository-response>
delete-
file
(snippet)
<repository-request> <delete-
file 
file-type="snippet"
silent="true"> 
<project-
name>Default 
project</
project-name> 
<file-
name>InputA.type</file-name>
</delete-file>  </repository-
request>
<repository-response><delete-
successful/></repository-
response>
delete-
file
(resource)
<repository-request> <delete-
file 
file-type="resource"
silent="true"> 
<project-
name>Default 
project</
<repository-response><delete-
successful/></repository-
response>
Documents you may be interested
Documents you may be interested