using pdfdocument c# : Add url link to pdf Library software component asp.net windows web page mvc WATUsageGuide35-part878

.NET Programmer's Guide
349
Now lets write the same example by using the hidden RequestExecutor directly
Table 108. under the hood execution
public static void Main(String[] args)
{
RoboServer server = new RoboServer("localhost", 50000);
Cluster cluster = new Cluster("MyCluster", new RoboServer[]{ server}, false);
RequestExecutor executor = new RequestExecutor(cluster);
var request = new Request("Library:/Tutorials/NewsMagazine.robot");
request.RobotLibrary = new DefaultRobotLibrary();
var result = executor.Execute(request);
Console.WriteLine(result);
}
The reason the RequestExecutor is hidden by default, is so you don't have to keep track of it. You may
only create one RequestExecutor per cluster, so 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.TotalAvailableSlots property contains 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 IRqlEngineFactory. The
IRqlEngineFactory allows you to customize which RQLProtocol 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.
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.
Repository Client
Communication  with  the  repository  is  achieved  through  the  RepositoryClient  found  in  the
namespace Com.KapowTech.RoboSuite.Api.Repository.Engine
Add url link 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 an email link to a pdf; change link in pdf file
Add url link 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
chrome pdf from link; add link to pdf file
.NET Programmer's Guide
350
Let's look at an example
Table 109. Get Projects from Repository
string UserName = "admin";
string Password = "admin1234";
RepositoryClient client = new RepositoryClient("http://localhost:50080/", UserName, Password);
Project[] projects = client.GetProjects();
foreach(Project p in projects) {
Console.WriteLine(p);
}
Here we see a RepositoryClient configured to connect to Management Console's repository on
http://localhost:50080/ with a username and password. If the Management Console is not
password protected, you must supply null for user name 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 110. Methods of the RepositoryClient
Method signature
description
void 
DeleteResource(string
projectName,  string  resourceName,
boolean silent)
Deletes a resource from a project.
void 
DeleteRobot(string
projectName, 
string 
robotName,
boolean silent)
Deletes a robot from a project
void 
DeleteType(string
projectName, 
string 
typeName,
boolean silent)
Deletes a type from a project
void 
DeleteSnippet(string
projectName,  string  SnippetName,
boolean silent)
Deletes a snippet 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 
DeployType(string
projectName, 
string 
typeName,
Deploys a type to a project. If a type with the given
name already exist it can be overridden by setting
failIfExists to false.
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 links to pdf acrobat; add page number to pdf hyperlink
C#: How to Add HTML5 Document Viewer Control to Your Web Page
type="text/css"/> <link rel="stylesheet _viewerTopToolbar.addTab(_tabRedact); //add Tab "Sample customStyle({ background: "url('RasterEdge_Resource_Files/images
convert doc to pdf with hyperlinks; add links to pdf document
.NET Programmer's Guide
351
Method signature
description
byte[] 
typeBytes, 
boolean
failIfExists)
void 
DeploySnippet(string
projectName,  string  snippetName,
byte[] 
snippetBytes, 
boolean
failIfExists)
Deploys a snippet to a project. If a snippet 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
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
Check the .Net documentation for details. The .Net documentation is located inside you Kapow Katalyst
installation at /API/robosuite-dotnet-api/docs/RoboSuite .NET API.chm.
If authentication is enabled on the repository, the request may be declined if the credentials given doesn't
have sufficient access.
The repository is accessed via http. When using the .Net version of the Repository API, any proxy servers
configured for Internet Explorer will be used by the Repository API.
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 111. Deploying to Repository
string user = "test";
string password = "test1234";
RepositoryClient client = new RepositoryClient("http://localhost:50080", user, password);
byte[] robotBytes = File.ReadAllBytes("c:\\MyRobots\\Library\\Test.robot");
byte[] typeBytes = File.ReadAllBytes("c:\\MyRobots\\Library\\Test.type");
// 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);
Repository API as REST
The repository can also be accessed via  restful services
Examples
The Kapow Katalyst installation contains six additional API code examples, these examples are found in
API\robosuite-dotnet-api\example
VB.NET Image: VB Code to Download and Save Image from Web URL
to download image from website link more easily from image downloading from web URL, RasterEdge .NET powerful & profession imaging controls, PDF document, image
clickable pdf links; adding hyperlinks to a pdf
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program of PDF document, including editing PDF url links and quick navigation link in bookmark
adding hyperlinks to pdf documents; active links in pdf
.NET Programmer's Guide
352
Compiling & Running the Examples
To compile the examples run the build.bat from a command prompt. This will cause six .exe files to be
produced, which can be run directly.
The .exe files are relying on the robosuite-dotnet-api.dll and the log4net.dll both of
which are located in the examples directory. Both files are identical copies of the ones located in the bin
folder and are copied in here to make it easier to run the examples.
Each example program will print a small usage text when run without any arguments.
C# Compiler Issues
The build.bat file assumes that the C# compiler is available in the path.
.NET Framework 4.0
The API and accompanying log4net is build targeting the .net framework 4.0 client profile. For details on
the .net framework 4.0 client profile see http://msdn.microsoft.com/en-us/library/cc656912.aspx
Ssl example
To run the ssl example RunSslRobot.exe the RoboServer has to be configured to use ssl and the certificate
has to be imported on the client machine. This guide will show you how to configure ssl using a self-signed
certificate on a windows PC running a local RoboServer.
Creating the self-signed certificate
The bat file MakeCertificates.bat included in the examples directory will create a self-signed
certificate for your .net API client. You can use MakeCertificates.bat as follows
1. Start a Visual Studio Command Prompt and go do the examples directory
2. Type MakeCertificates.bat
3. You will now be prompted to type the password for the certificate in this case we simply type "123"
4. You will now be prompted to type a hostname that the certificate. For a local RoboServer we type
"localhost" It is important that this is the same hostname that you use in your client code when creating
the protocol.
5. Now you will be prompted 3 times for the password again - type "123" in each dialog
Certificates can also be created with Keytool as described in API Client Certificates
Configure the RoboServer
1. On the RoboServer start the Settings application located in Start -> All Programs -> Kapow Katalyst
2. In the Settings application goto the certificates tab
3. Click change and select the file API\robosuite-dotnet-api\example\server.pfx
4. When prompted for a password type "123".
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET of PDF document, including editing PDF url links and quick navigation link in bookmark
add hyperlink in pdf; check links in pdf
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.
pdf link open in new window; add links to pdf in acrobat
.NET Programmer's Guide
353
5. the RoboServer is now fully configured and can be started using the switch -service ssl:50443
to use the ssl configuration on port 50443
Configure the API client
1. Run the command mmc.exe
2. On the Console menu, click Add/Remove Snap-in
3. Under Snap-in, double-click Certificates, and select to manage certificates for the Local computer
and click Finish
4. With the certificates snap-in loaded expand the node Certificates -> Trusted root Certification
Authorities and right click the Certificates node and click the menu item All tasks -> Import
5. This will start the Certificate Import Wizard. When prompted to pick the certificate file browse to
API\robosuite-dotnet-api\example\server.pub.cer and complete the import
After completing these steps, both the server and client are configured to use ssl and running the example
RunSslRobot.exe can be used to verify the configuration.
C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
Image: Copy, Paste, Cut Image in Page. Link: Edit URL. Bookmark: Edit Redact Text Content. Redact Images. Redact Pages. Annotation & Drawing. Add Sticky Note.
add hyperlinks pdf file; add hyperlinks to pdf online
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Redact Text Content. Redact Images. Redact Pages. Annotation & Drawing. Add Sticky Note
clickable links in pdf from word; add hyperlink to pdf online
354
Clipping Programmer's Guide
This guide describes the Kapow Clipping API. The API defines a number of extension points and allows
advanced users of the Kapow Clipping technology to configure and control the use and execution of
Clipping robots.
A Clipping robot is a special robot type that will be called from a web clip. Web clips will be deployed
to either a web server (servlet engine) or a portal application.
The Kapow Clipping API provides Java programmers with a means of modifying and extending the
standard functionality of clipping robots. The extension points allow you to:
• Provide, modify or filter input or output to your robot, e.g. by accessing data from an external source.
This includes modifying the robot's input and output values, adding properties, and filtering cookies
and header information.
• Provide user credentials, e.g. by retrieving them from an external credential vault.
• Program your own scheduling algorithm for balancing the load on multiple RoboServers.
• Controlling session restart.
The guide is intended for Servlet programmers integrating Kapow Clips into their portal or web application.
We assume that the programmer is familiar with the following:
• Java.
• Java Portlet standard (JSR-168).
While this guide covers many basic issues, it does not go into detail on subjects that are covered in other
Kapow Katalyst guides, such as the Design Studio and Java Programmer's Guides. The reader is advised
to consult these other guides as needed.
Organization
The Guide is divided into the following sections.
• An introduction, containing a discussion of required items, notational conventions, and references.
• A brief overview of how to use the API, describing the clipping architecture and how extension points
are called. Furthermore, this section gives an introduction to how the extension points are defined.
Different kinds of extension points are discussed in subsequent sections.
• A discussion of Providers, which make it possible to provide extra information to the clipping robot.
• A discussion of Handlers, which make it possible to modify the output from the clipping robot.
• A discussion of Filters, which can modify information transferred to and from the clipping robot.
• A discussion of Controllers, which are used to control the behavior of the RoboServer.
• Finally, some tips and tricks.
Clipping Programmer's Guide
355
The guide can be read in one stretch. However, it is not necessary to read through the entire guide to be
able to get started with the API. We recommend that you read the Introduction and Using the API sections
first. After that you should be able to jump to the section describing the extension point that you need
for your purpose.
Introduction
This section contains:
• A list of items you need in order to use the Kapow .NET API, and instructions on how to get them.
• An overview of the notation that is used in the description of the API.
• References.
Required Items
The API is written for Java 2 Standard Edition (J2SE) 1.3 through 6. Earlier versions of Java are not
supported. As the API is intended to be used within the context of a web container, the necessary Java 2
Enterprise Edition (J2EE) API’s (in particular the Servlet API) will automatically be available.
Another requirement is that you have a license that allows clipping.
Notation
The notation used in the guide will probably be familiar, if you have read any of the other guides. Here
is a listing of the important types of notation:
Code examples:
Being a programming guide, this document contains several small
code examples. We use mostly code fragments for brevity. This
means that the code fragments cannot simply be copy-pasted into a
Java source file and compiled. Furthermore, in the examples brevity
has been preferred to good coding style.
Inline code:
Written in fixed-width font. Inline code is used to refer to Java
classes, keywords, or file names. For example, this is how we would
refer to the java.lang.String class.
New terms or important features:
Are emphasized so as to stand out.
References
The API uses an XML document for configuration, this document is called a clip descriptor, and has the
.clip file extension. The format of the clip descriptor is defined in the following DTD
Kapow Clipping Deployment
Descriptor DTD:
http://www.kapowtech.com/robosuite/rql/dtd/clip-deployment-
descriptor_1_3.dtd
Using the API
This section provides an overview of how the clipping API works and how to use it.
Clipping Programmer's Guide
356
The Clip Configuration File
A clip is deployed as a clip configuration file. This is an XML file with file extension .clip. The clip
configuration file contains all information needed to configure the clip.
The Clipping API consists of a number of interfaces that defines extension points to the clipping logic.
Developers may provide implementations of these interfaces and register them in the clip configuration file
by specifying the class name of the implementation. In some cases default implementations are provided,
and these can be chosen in the clip configuration file without specifying a class name.
Be aware that the order of the elements in the clip descriptor must follow the order defined in the DTD
mentioned in References. In the clip descriptor example listed in this guide, we have tried to add an element
before and/or after, to make it clear where the element fits in.
Note that deploying a robot from Design Studio will overwrite the clip configuration file, so in this
case modifications to the clip configuration file will have to be redone. To avoid doing this often, you
should choose to use a robot library at a URL. Furthermore, you could use a Property Provider to retrieve
configuration which might change often from another source than the clip configuration file.
The Clipping Logic
When a request is made for a clip e.g. in a portlet, the HTML of the clip will not be returned directly,
but instead a document with an IFRAME will be returned (see the figure below). This IFRAME will
make a new request targeting the clip configuration file; that is its source (src) URL is pointing at the
corresponding clip configuration file. The request for the clip configuration file is then handled by a servlet.
In other words all requests for clip configuration files are mapped to a servlet which means that there must
be a servlet mapping in the web application's web.xml file for this (this is automatically placed there
when you run a clipping wizard). The specific class name of the servlet may depend on where the clip
is deployed e.g. on a standard servlet engine, in a BEA WebLogic Portal, etc. The servlet contains code
(in the following called clipping logic) that will be deployed to a web server or portal and this code will
be responsible for contacting a RoboServer to run the clipping robot and for presenting the clip on the
web page. The clipping logic will send request to a RoboServer and will receive responses back from this.
Requests may take various forms, e.g. a request to restart a robot, a request telling the RoboServer that
the user has clicked on a link in the clip, etc. Request may also contain extra information to the robot e.g.
extra input object. The responses can also take many forms, e.g. content to present in the clip, an error
message, etc.
The figure below illustrates how this is done if the clip is deployed to a portal application, but clips deployed
to a web server will work in the same way.
Clipping Programmer's Guide
357
The Clipping Logic
Calling RoboServer
The servlet sends a set of RQLObjects to a RoboServer, like when a robot is normally run from the API.
The values of these RQLObjects are mapped into the corresponding input variables that must be defined
in the robot in the Variables View in Design Studio. One variable — the ClipRequest — is predefined. You
can define and declare additional input variables by defining types in Design Studio and adding variables
in the Robot Editor’s Variables View.
The ClipRequest consists of a command specification and some data. The command typically reflects an
action performed by the user, e.g. clicking on a link, changing focus, retrieving an attachment or navigating
in the history. In addition, a command might contain instructions to the RoboServer, e.g. to start and stop
the session.
The data sent as part of the ClipRequest includes
SessionId:
An identifier uniquely identifying the current session.
Cookies:
An abstract representation of the cookies in the servlet request.
Header:
An abstract representation of the HTTP header sent in the servlet
request.
User credentials:
User name and password used in the robot to login to the site being
clipped
Clipping Programmer's Guide
358
RoboServer credentials:
If authentication is enabled on RoboServer, this is the credentials
used to authenticate the portal against the RoboServer
Properties:
Input values, which can be retrieved within the robot using the Get
Properties converter.
Response from RoboServer
When RoboServer finishes processing the clipping robot, it will send back a response to the Servlet.
Like in the call to the RoboServer, this response consists of a number of RQLObjects representing
outputted variable values, where one variable — ClipResponse — is predefined. You can define and
declare additional variables.
A ClipResponse contains
Changes:
A specification of the changes to the servlet resulting from executing the robot.
SessionId:
An identifier uniquely identifying the current session.
Cookies:
An abstract representation of the cookies set by the clipped site.
Header:
An abstract representation of the HTTP header returned from the clipped site.
Alert message:
If the clipping robot execution resulted in a JavaScript alert box being shown, the
message of this alert will be present in this attribute.
Extension Points
We are now able to describe the extension points in more detail. If you want to insert code at an extension
point, you must provide a Java class implementing the Java interface for the extension point. This class
must be specified in the clip configuration file.
All providers, handlers and controller have access to the servlet request (HttpServletRequest) and
response (HttpServletResponse) and can therefore access various resources, e.g. portlet preferences
to get access to data from which to create the values it provides.
Providers
A provider is an extension point, which is called before the servlet calls the RoboServer. The provider
will then provide, modify or add information that will determine how the RoboServer is called. You can
implement the following providers:
RoboServer credentials provider:
If authentication is enabled on RoboServer, this provider controls
what username and password is used when executing the clipping
robot
Additional Input Objects provider:
Adds additional input to the call to RoboServer.
User Credentials provider:
Modify  username  and  password  in  the  ClipRequest  sent  to
RoboServer.
Properties provider:
Modify or add properties in the ClipRequest sent to RoboServer.
User Message Localization
provider:
Provide localization of Kapow messages presented by the servlet.
Documents you may be interested
Documents you may be interested