using pdfdocument c# : Add a link to a pdf file control application platform web page azure winforms web browser WATUsageGuide34-part877

.NET Programmer's Guide
339
Table 94. Execution control properties on Request
MaxExecutionTime
This property controls the maximum number of seconds the robot
can execute. When this time has elapsed the robot will be stopped by
RoboServer. The timer doesn't start until the robot begins to execute,
so if the robot is queued on RoboServer this is not taken into account.
StopOnConnectionLost
This property (true by default) controls if RoboServer will stop the
robot if it discovers that the connection to the client application has
been lost. You should have a very good reason for setting this value to
false - if your code is not written to handle this, your application will
not perform as expected.
StopRobotOnApiException
This property (true by default) instructs RoboServer to stop the robot
when the first API exception is raised. By default most steps in a
Robot will raise an API exception if the step fails to execute - this is
configured on the steps error handling tab.
When  set  to  false,  the robot  will  continue  to  execute  regardless
of  API  exceptions,  however  unless  your  application  is  using  a
IRobotResponseHandler for streaming the results, an exception
will still be thrown by Execute(), so be extremely careful when setting
this to false.
Username, Password
These properties are used to set the credentials. This is used when
RoboServer is configured to require authentication. When this option
is enabled, the client must provide credentials or RoboServer will
reject the request.
RobotLibrary
This property is used to assign a RobotLibrary to the request. A robot
library instructs RoboServer where to find the robot identified in the
request. Later examples will explore the various robot library types
and when/how to use them.
ExecutionId
Allows you to set the executionId for this request. If you don't provide
one, RoboServer will generate one automatically. The execution ID
is used for logging, and also needed if your client needs to be able
to stop the robot programmatically. The ID must be globally unique
(over time). If two robots use the same execution ID, the logs will be
inconsistent.
Setting this is useful if your robots are part of a larger workflow and
you already have a unique identifier in your client application, as this
allows you to easily join the robot logs with the rest of the system.
setProject(String)
This is used solely for logging purposes. The Management Console
uses this field to link log messaged to project, so the log views can
filter by project.
If your application is not using the RepositoryRobotLibrary
you should probably set this value to inform the RoboServer logging
system which project (if any) this robot belongs to.
Robot Libraries
In Design Studio robots are grouped into projects. If you look in the file system you will see that these
projects are represented by a folder with the only constraint that it must contain a folder named Library,
see Libraries and Projects for details.
Add a link to a pdf file - 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
add email link to pdf; add hyperlink to pdf in preview
Add a link to a pdf file - 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
add url link to pdf; pdf hyperlink
.NET Programmer's Guide
340
When you build the execute request for RoboServer, you identify the robot by a robot URL, like this:
Request request = new Request("Library:/Input.robot");
Here, Library:/ is a symbolic reference to a robot library, in which the RoboServer should look for
the robot. The RobotLibrary is then specified on the builder like this:
request.SetRobotLibrary(new DefaultRobotLibrary());
There are three different robot library implementations, which one to select depends on you deployment
environment.
Table 95. Robot Libraries
Library Type
Description
DefaultRobotLibrary
This configures RoboServer to look for the robot in the current project
folder. This folder is defined in the Settings application.
If you have multiple RoboServers you will have to deploy your robots
on all RoboServers.
This robot library is not cached, so the robot is reloaded from disk
with every execution. This makes the library usable in a development
environment  where  robots  change  often,  but  not  suitable  for  a
production environment.
EmbeddedFileBasedRobotLibrary
This library is embedded in the execute request sent to RoboServer.
To create this library you must create a zip file containing the robots
and all its dependencies (types, snippets and resources). This can be
done the Tools->Create Robot Library File menu in Design Studio.
The library is sent with every request, which adds some overhead for
large libraries, but the libraries cached on RoboServer, which offers
best possible performance.
One strength is that robots and code can be deployed as a single unit,
which offers clean migration from QA environment to production
environment. However, if the robots change often you will have to
redeploy them often.
You can use the following code to configure the embedded robot
library for your request.
var request = new Request("Library:/Tutorials/NewsMagazine.robot");
var stream = new FileStream("c:\\embeddedLibrary.robotlib", FileMode.Open);
request.RobotLibrary = new EmbeddedFileBasedRobotLibrary(stream);
RepositoryRobotLibrary This is the most flexible RobotLibrary.
This library uses the Management Console's built-in repository as a
robot library. When you use this library, RoboServer will contact the
Management Console which will send a robot library containing the
robot and its dependencies.
Caching occurs on a per robot basis, inside both Management Console
and RoboServer. Inside Management Console, the generated library is
cached based on the robot and its dependencies. On RoboServer, the
C# PDF Library SDK to view, edit, convert, process PDF file for C#
and quick navigation link in PDF bookmark. C#.NET: Edit PDF Metadata. PDF SDK for .NET allows you to read, add, edit, update, and delete PDF file metadata, like
convert excel to pdf with hyperlinks; c# read pdf from url
VB.NET PDF Password Library: add, remove, edit PDF file password
This VB.NET example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = True ' Add password to PDF file.
pdf link to specific page; add a link to a pdf file
.NET Programmer's Guide
341
Library Type
Description
cache is based on a timeout, so it doesn't have to ask the Management
Console for each request. In addition, the library loading between
RoboServer  and  Management  Console  uses  HTTP  public/private
caching, to further reduce bandwidth.
If  NewsMagazine.robot  has  been  uploaded  to  the  Management
Console we could use  the repository robot library like this when
executing the robot:
var request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.RobotLibrary = new RepositoryRobotLibrary("http://localhost:50080",
"Default Project", 60000);
This  will  instruct  RoboServer  to  load  the  robot  from  a  local
Management Console and cache it for one minute before checking
with the Management Console to see if a new version of the robot (it's
type and snippets) has been changed.
In addition any resource loaded through the Library:/ protocol,
will  cause  RoboServer  request  the  resource  directly  from  the
Management Console.
Advanced
In this section we will look a little closer at some of the more advanced features on the API. These include
output streaming, logging and SSL configuration, as well as parallel execution.
Load Distribution
Table 96. Load balanced executor
RoboServer prod = new RoboServer("prod.kapow.local", 50000);
RoboServer prod2 = new RoboServer("prod2.kapow.local", 50000);
Cluster cluster = new Cluster("Prod", new RoboServer[]{ prod, prod2}, false);
Request.RegisterCluster(cluster);
Lets look a little closer at what happens inside the RequestExecutor. The executor is given an array
of RoboServers. As the executor is constructed it tries to connect to each RoboServer. Once it is connected
it sends a ping request to each RoboServer to discover how the server is configured.
Load is distributed to each online RoboServer in the cluster, based on the number of unused execution slots
on the RoboServer. The next request is always distributed to the RoboServer with the most available slots.
The number of available execution slots is obtained through the initial Ping response, and the executor
keeps track of each robot it starts, and when it completes. The number of execution slots on a RoboServer
is determined by the max concurrent robots on the Servers tab.
If a RoboServer goes offline it will not receive any robot execution requests before it has successfully
responded to the ping request.
Two client rule
You should only have one API client using a given cluster of RoboServer. If you have multiple .Net
applications running robots against the same RoboServers, this will result in reduced performance.
C# PDF Password Library: add, remove, edit PDF file password in C#
This example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = true; // Add password to PDF file.
adding hyperlinks to pdf files; add links to pdf in preview
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
Insert Image to PDF. Image: Remove Image from PDF Page. Copy, Paste, Cut Image in Page. Link: Edit URL. Images. Redact Pages. Annotation & Drawing. Add Sticky Note
pdf link to email; pdf email link
.NET Programmer's Guide
342
Executor Logger
When you execute a request, the execute method will throw an exception if a robot generates an error.
Other types of errors and warnings are reported through an executor logger, a class implementing the
IExecutorLogger interface. In the previous examples, we have not provided any execution logger
when executing robots, which means that the default implementation ExecutorLogger that will write
to system out will be used. Let's see how the ExecutorLogger will report if one of our RoboServers
goes offline.
The example configures a cluster with a RoboServer which is not online.
Table 97. ExecutorLogger offline server example
RoboServer rs = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("name", new RoboServer[]{rs}, false);
Request.RegisterCluster(cluster);
If you run this example if should print the following to the console:
Table 98. ExecutorLogger offline RoboServer console output
RoboServer[Host=localhost, Port=50000]' went offline.
Com.KapowTech.RoboSuite.Api.Engine.UnableToConnectException:...........
Often you don't want to have your application writing directly to System.out, in that case you can
provide a different IExecutorLogger implementation, you can do so when registering the cluster,
like this
Table 99. Use DebugExecutorLogger
Request.RegisterCluster(cluster, new DebugExecutorLogger());
This  example  uses  the  DebugExecutorLogger()  which  will  also  print  to  System.out,  but
only if the API debugging is enabled. Alternative you can provide your own implementation of the
ExecutorLogger, to control how error messages should be handled.
Data Streaming
Sometimes you need to present the results from a robot execution in real-time, as the robot is executing.
In these cases you want the API to return the extracted values immediately instead of waiting for the robot
to finish its execution and access the RqlResult.
The API offers the possibility to receive a callback every time the API receives a value that was returned
by the Robot. This is done through the IRobotResponseHandler interface
Table 
100. 
Response 
streaming
usingAbstractFailFastRobotResponseHandler
using System;
C# PDF insert image Library: insert images into PDF in C#.net, ASP
using RasterEdge.Imaging.Basic; using RasterEdge.XDoc.PDF; Have a try with this sample C#.NET code to add an image to the first page of PDF file.
add a link to a pdf; add hyperlink pdf
VB.NET PDF insert image library: insert images into PDF in vb.net
using RasterEdge.XDoc.PDF; Have a try with this sample VB.NET code to add an image to the first page of PDF file. ' Open a document.
adding a link to a pdf; clickable links in pdf files
.NET Programmer's Guide
343
using Com.KapowTech.RoboSuite.Api;
using Com.KapowTech.RoboSuite.Api.Repository.Construct;
using Com.KapowTech.RoboSuite.Api.Construct;
using System.IO;
using Com.KapowTech.RoboSuite.Api.Engine.Hotstandby;
namespace Examples
{
public class DataStreaming {
public static void Main(String[] args)  {
var server = new RoboServer("localhost", 50000);
var cluster = new Cluster("MyCluster", new RoboServer[] { server }, false);
Request.RegisterCluster(cluster);
var request = new Request("Library:/Tutorials/NewsMagazine.robot");
IRobotResponseHandler handler = new SampleResponseHandler();
request.Execute("MyCluster", handler);
}
}
public class SampleResponseHandler : AbstractFailFastRobotResponseHandler
{
override public void HandleReturnedValue(RobotOutputObjectResponse response, IStoppable stoppable)
{
var title = response.OutputObject["title"];
var preview = response.OutputObject["preview"];
Console.WriteLine(title + ", " + preview);
}
}
}
The  above  example  uses  the  second  execute  method  of  the  Request,  which  expects
 RobotResponseHandler  in  addition  to  the  name  of  the  cluster  to  execute  the
robot  on.  In  this  example  we  create  a  IRobotResponseHandler  by  extending
AbstractFailFastRobotResponseHandler, which provides default error handling, so we only
need to handle the values returned by the robot.
The handleReturnedValue method is called whenever the API receives a returned value from
RoboServer. The AbstractFailFastRobotResponseHandler used in this example, will throw
exceptions in the same way as the non-streaming execute method. This means that an exception will be
thrown in response to any API exceptions generated by the robot.
The IRobotResponseHandler has several methods which can be grouped into 3 categories.
Robot life cycle events
Methods which are called when the robot's execution state change
on RoboServer, such as when it starts and finishes its execution.
Robot data events
Methods which are called when the robot returns data or errors to
the API.
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# of PDF document, including editing PDF url links and quick navigation link in bookmark
adding links to pdf document; adding hyperlinks to pdf
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
Add necessary references: using RasterEdge.XDoc.PDF; Note: When you get the error "Could not load file or assembly 'RasterEdge.Imaging.Basic' or any other
pdf links; pdf link to attached file
.NET Programmer's Guide
344
Additional error handling
Methods which are called either due to an error inside RoboServer
or in the API.
Table 101. IRobotResponseHandler - robot life cycle events
Method name
Description
void
RequestSent(RoboServer
roboServer,
ExecuteRequest
request)
Called when the RequestExecutor has found the server which
will execute the request.
void
RequestAccepted(String
executionId)
Called when the found RoboServer has accepted the request, and put
it into it queue.
void
RobotStarted(IStoppable
stoppable)
Called when the RoboServer begins to execute the robot. This usually
occurs  immediately  after  the  robot  has  been  queued,  unless  the
RoboServer is under heavy load, or used by multiple API clients.
void
RobotDone(RobotDoneEvent
reason)
Called  when  the  robot  is  done  executing  on  RoboServer.  The
RobotDoneEvent is used to specify if the execution terminated
normally, due to an error, or if it was stopped.
Table 102. IRobotResponseHandler - robot data events
Method name
Description
void
HandleReturnedValue(RobotOutputObjectResponse
response, 
IStoppable
stoppable)
Called when the robot has executed a Return Value action, and the
value has been returned via the socket to the API.
void
HandleRobotError(RobotErrorResponse
response, 
IStoppable
stoppable)
Called  when  the  robot  raises  an  API  exception.  Under  normal
circumstances  the  robot  will  stop  executing  after  the  first
API  exception.  This  behavior  can  be  overridden  by  using
Request.StopRobotOnApiException = false, in which
case this method will be called multiple times. This is useful if you
want a data streaming robot to continue to execute regardless of any
generated errors.
void
HandleWriteLog(RobotMessageResponse
response, 
IStoppable
stoppable)
Called if the robot executes the Write Log action. This is useful if you
wish to provide additional logging info from within a robot.
Table 103. IRobotResponseHandler - additional error handling
Method name
Description
void
HandleServerError(ServerErrorResponse
response, 
IStoppable
stoppable)
Called if RoboServer generates an error, for instance if the server too
busy to process any requests, or if an error occurs inside RoboServer
which prevents it from starting the robot.
void
handleError(RQLException
Called if an error occurs inside the API. Most commonly if the client
looses the connection to RoboServer.
.NET Programmer's Guide
345
Method name
Description
e, 
IStoppable
stoppable)
Many of the methods will include a IStoppable object, this object can be used to stop for instance in
response to a specific error or value returned.
Some of these methods allow you to throw an RQLException, if you do this you should be aware of
the consequences. The thread that calls the handler is the thread that calls Request.Execute(), this
means that any exceptions thrown will bubble up the call stack and out the execute method. If you throw an
exception in response to handleReturnedValue, handleRobotError or handleWriteLog it
is your responsibility to invoke Stoppable.stop(), or the robot may continue to execute even though
the call to Request.Execute() has completed.
Data streaming is most often used in one of the following use cases.
• Ajax based web application, where results are presented to the user in real-time. If data was not streamed
results could not be shown until the robot was done running.
• Robots that return so much data that the client would not be able to hold it all in memory throughout
the robots execution.
• Processes that need to be optimized so the extracted values are processed in parallel with the robot
execution.
• Processes that store data in databases in a custom format.
• Robots that should ignore or require custom handling of API exceptions (see below).
Table 
104. 
Response 
and 
error 
collecting 
using
AbstractFailFastRobotResponseHandler
using System;
using System.Collections;
using System.Collections.Generic;
using Com.KapowTech.RoboSuite.Api;
using Com.KapowTech.RoboSuite.Api.Repository.Construct;
using Com.KapowTech.RoboSuite.Api.Construct;
using System.IO;
using Com.KapowTech.RoboSuite.Api.Engine.Hotstandby.Interfaces;
namespace Examples
{
public class DataStreaming
{
public static void Main(String[] args)
{
var server = new RoboServer("localhost", 50000);
var cluster = new Cluster("MyCluster", new RoboServer[] { server }, false);
Request.RegisterCluster(cluster);
var request = new Request("Library:/Tutorials/NewsMagazine.robot");
.NET Programmer's Guide
346
request.StopRobotOnApiException = false;  // IMPORTANT!!
ErrorCollectingRobotResponseHandler handler = new ErrorCollectingRobotResponseHandler();
request.Execute("MyCluster", handler); // blocks until robot is done, or handler throws an exception
Console.WriteLine("Extracted values:");
foreach (RobotOutputObjectResponse response in handler.GetOutput())
{
var title = response.OutputObject["title"];
var preview = response.OutputObject["preview"];
Console.WriteLine(title + ", " + preview);
}
Console.WriteLine("Errors:");
foreach (RobotErrorResponse error in handler.GetErrors())
{
Console.WriteLine(error.ErrorLocationCode + ", " + error.ErrorMessage);
}
}
}
public class ErrorCollectingRobotResponseHandler : AbstractFailFastRobotResponseHandler {
private IList<RobotErrorResponse> _errors = new List<RobotErrorResponse>();
private IList<RobotOutputObjectResponse> _output = new List<RobotOutputObjectResponse>();
override public void HandleReturnedValue(RobotOutputObjectResponse response, IStoppable stoppable)  {
_output.Add(response);
}
override public void HandleRobotError(RobotErrorResponse response, IStoppable stoppable) {
// do not call super as this will stop the robot
_errors.Add(response);
}
public IList<RobotErrorResponse> GetErrors() {
return _errors;
}
public IList<RobotOutputObjectResponse> GetOutput() {
return _output;
}
}
}
The example above shows how to use a IRobotResponseHandler that collects returned values
and errors. This type of handler is useful if the robot should continue to execute even when error are
encountered, which 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).
.NET Programmer's Guide
347
For more details check the IRobotResponseHandler chm documentation in the /docs folder .
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 105. 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.
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.
Check here to find out how to compile and run the included SSL example.
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 106. Repository Integration
using System;
using Com.KapowTech.RoboSuite.Api;
using Com.KapowTech.RoboSuite.Api.Construct;
using Com.KapowTech.RoboSuite.Api.Repository.Engine;
namespace Examples
{
public class RepositoryIntegration
{
public static void Main(String[] args)
.NET Programmer's Guide
348
{
string userName = "admin";
string password = "admin";
RepositoryClient client = new RepositoryClient("http://localhost:50080", userName, password);
Request.RegisterCluster(client, "Production");
var request = new Request("Library:/Tutorials/NewsMagazine.robot");
var result = request.Execute("Production");
Console.WriteLine(result.ToString());
}
}
}
The above example shows how to create a RepositoryClient which connects to a Management
Console deployed on localhost port 50080.
If the Management Console requires authentication you will need to pass a username and password,
otherwise you may pass null for both. When we register the RepositoryClient we specify the name
of a cluster which exists on the Management Console, this 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
Request.
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.
Lets look at a short example
Table 107. Normal execution
public static void Main(String[] args)
{
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[]{ server}, false);
Request.RegisterCluster(cluster);
var request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.RobotLibrary = new DefaultRobotLibrary();
var result = request.Execute("MyCluster");
Console.WriteLine(result);
}
Documents you may be interested
Documents you may be interested