c# httpclient download pdf : Create bookmark pdf control Library system azure .net winforms console cpf4-part1354

MarkLogic Server
Understanding and Using Pipelines
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 41
6.4.4.2 On Success and On Failure
The on-success and on-failure part of the state transition is where you specify the state to which 
the document is set if the state transition returns successfully (on-success) or if it fails (on-failure). 
If you do not specify an on-success or on-failure state, the document remains in its current state 
after the state transition success or failure, thereby completing processing for that document.
6.4.4.3 Default Action
The default action references an XQuery module that is called if no other actions are activated. 
The state transition will execute the first of the following that occurs:
•  Any action whose condition in the state transition returns 
true
or is absent.
•  The default action for any transition for this state.
•  The success-action.
You can use the default action to move a document to the next state if the processing you want to 
perform is the default action. The following is a sample state-transition node that contains a 
default action:
<state-transition>
<annotation>
Default action example
</annotation>
<state>http://marklogic.com/states/initial</state>
<on-success>http://marklogic.com/states/collected</on-success>
<on-failure>http://marklogic.com/states/error</on-failure>
<priority>5000</priority>
<default-action>
<module>/pipeline/mypipes/default-action.xqy</module>
</default-action>
</state-transition>
If you want the move the state to one that is different from the state transition’s on-success state, 
you can use the 
$override-state
parameter to the 
cpf:success
function in your default action 
XQuery module. You should move the state to a different state from the document’s current state. 
An example of a module that does this is the 
/MarkLogic/cpf/actions/state-setting-action.xqy
under the 
Modules
directory.
6.4.4.4 Priority
The priority is used to determine which pipeline state should be executed first in the event that 
there are multiple pipelines states attached to a domain that act on the same state. State transitions 
with a higher priority number execute before ones with a lower number. In the event of a tie (that 
is, if two priorities are the same number), it is indeterminate which one will execute first. For the 
pipelines supplied with MarkLogic Server, the order is set such that conversion executes first, 
then entity enrichment, then modular documents (xinclude), then alerting, and finally schema 
validation.
Create bookmark pdf - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
bookmarks pdf; bookmark pdf reader
Create bookmark pdf - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
how to add bookmark in pdf; pdf bookmark editor
MarkLogic Server
Understanding and Using Pipelines
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 42
6.4.4.5 Execute
The execute part of the state transition runs the XQuery module or XSLT stylesheet referenced in 
the condition, and then runs the XQuery module or XSLT stylesheet referenced by the action if 
the condition returns 
true
or if there is no condition specified. If there are multiple execute 
elements in a single state transition, you should design them so that at most one execute element 
has a condition that returns 
true
. If multiple conditions return 
true
, then the first one to return 
true
has its action executed. The reason for this is that all of the XQuery modules or XSLT 
stylesheets execute in separate transactions, and it is non-deterministic which one will return first. 
Therefore, if you have multiple conditions that return 
true
, either the first one will come first (in 
the case of a single pipeline) or you cannot guarantee which one will come first and execute its 
action (in the case of multiple pipelines).
Note:  If a condition fails (for example, throws an exception), the condition is handled as 
if it returns 
false
.
You can also include an options node, which allows you to pass an external variable and/or an 
options node to code in the action XQuery moduleor XSLT stylesheet. The options node should 
have the namespace of the action module, or the namespace of the options node called in the 
XQuery function (
xdmp:tidy
, for example). The following is a sample options node within a 
condition:
<condition>
<module>/MarkLogic/cpf/actions/mimetype-condition.xqy</module>
<options xmlns="/MarkLogic/cpf/actions/mimetype-condition.xqy">
<mime-type>text/html</mime-type>
</options>
</condition>
The pipeline passes the options node as an external variable (
$cpf:options
) to the module that 
tests for the condition (
mimetypes-condition.xqy
, in this sample).
6.5
XQuery Functions to Manage Pipelines
The Admin Interface provides all of the functionality for loading pipelines. However, if you want 
to load and manage pipelines without using the Admin Interface, the 
pipelines.xqy
XQuery 
module contains functions to manage pipelines. This XQuery file is installed into the following 
location:
<install_dir>/Modules/MarkLogic/cpf/pipelines.xqy
For details on the functions in this module, see the MarkLogic XQuery and XSLT Function 
Reference
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
C#, C#.NET PDF Reading, C#.NET Annotate PDF in WPF, C#.NET PDF Create, C#.NET NET rotate PDF pages, C#.NET search text in PDF, C#.NET edit PDF bookmark, C#.NET
auto bookmark pdf; bookmarks pdf reader
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Easy to create searchable and scanned PDF files from Word. Ability to get word count of PDF pages. Change Word hyperlink to PDF hyperlink and bookmark.
bookmarks in pdf reader; how to bookmark a pdf page
MarkLogic Server
Developing Modules to Process Content
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 43
7.0   Developing Modules to Process Content
47
This chapter describes modules in the MarkLogic Server Content Processing Framework, and 
includes the following sections:
• 
Overview of Modules
• 
Loading Modules Into the Database
• 
External Variables Available to Modules
• 
Design Patterns and Rules
7.1
Overview of Modules
While domains and pipelines provide a framework to build content processing applications, the 
actual work of transforming or enhancing content is done through XQuery modules. An XQuery 
module can do an arbitrary amount of work; it can be very simple, very complex, or somewhere in 
between. 
There are two types of XQuery modules used in content processing applications:
•  Condition modules
•  Action modules
Condition modules test for a condition and return a boolean value (
true
or 
false
). Action 
modules typically perform some processing on the document and then call 
cpf:success
or 
cpf:failure
to advance the state, according to the definitions in the current pipeline.
Action modules can call out to web services inside or outside of MarkLogic Server, they can 
perform transformations on the document within MarkLogic Server, or they can perform any 
work needed in the current phase of the pipeline.
Note:  Instead of using XQuery modules for conditions and actions, you can also use 
XSLT modules. If you have a path to an XSLT stylesheet in a pipeline, the action 
or condition is run with the specified XSLT code. For details about using XSLT 
stylesheets in CPF actions, see “Using XSLT Stylesheets Instead of Action 
Modules” on page 47.
7.2
Loading Modules Into the Database
XQuery modules used as action and condition modules should be stored in the database. Load the 
XQuery modules into the database and root specified in the evaluation context for the domain 
configuration. For details about where to load the XQuery modules, see “Domain Scope and Code 
Evaluation Context” on page 26.
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Easy to create searchable and scanned PDF files from Word. Able to get word count in PDF pages. Change Word hyperlink to PDF hyperlink and bookmark.
create bookmarks in pdf; bookmarks pdf documents
VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
Qualified Tiff files are exported with high resolution in VB.NET. Create multipage Tiff image files from PDF in VB.NET project. Support
excel print to pdf with bookmarks; bookmark pdf in preview
MarkLogic Server
Developing Modules to Process Content
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 44
7.3
External Variables Available to Modules
Each CPF action condition and action module has the following external variables available:
• 
$cpf:document-uri
: The URI of the document being processed. In Server-Side JavaScript, 
the name of this variable is 
uri
.
• 
$cpf:transition
: The name of the transition being executed. Every action should use this 
external variable so it can pass the value into 
cpf:success
and 
cpf:failure
to advance the 
state of the document. In Server-Side JavaScript, the name of this variable is 
transition
.
• 
$cpf:options
: The options XML node from the pipeline action. You can use this to pass in 
options that the module uses, so you can use the same module with different pipelines and 
get different behavior. In Server-Side JavaScript, the name of this variable is 
options
.
You use these external variables to get the URI of the document being processed, the name of the 
transition being executed, and any options that the pipeline passes through to the module. To use 
these external variables in your XQuery modules, import them as external variables to your 
modules, as in the following code snippet from an XQuery 
1.0-ml
prolog:
declare variable $cpf:document-uri as xs:string external;
declare variable $cpf:transition as element() external;
declare variable $cpf:options as element() external;
To use the external variables in your Server-Side JavaScript code, you need to require the 
cpf.xqy
module and declare the variables in your module, as in the following example:
declareUpdate();
var cpf = require("/MarkLogic/cpf/cpf.xqy");
var uri;
var transition;
if (cpf["check-transition"](uri,transition)) {
try {
xdmp.nodeInsertChild(cts.doc(uri).xpath("/book"),
xdmp.unquote('<copyright><year>2010</year><holder>The 
Publisher</holder></copyright>').next().value.root);
xdmp.log("add copyright ran OK");
cpf["success"](uri,transition,null);
} catch (e)
{
cpf["failure"](uri,transition,e,null);
}
} else {
C# Create PDF from Tiff Library to convert tif images to PDF in C#
Create PDF from Tiff. |. Home ›› XDoc.PDF ›› C# PDF: Create PDF from Tiff. Create PDF from Tiff in both .NET WinForms and ASP.NET application.
creating bookmarks in a pdf document; bookmark template pdf
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
C#.NET PDF SDK- Create PDF from Word in Visual C#. Online C#.NET Tutorial for Create PDF from Microsoft Office Excel Spreadsheet Using .NET XDoc.PDF Library.
export bookmarks from pdf to excel; split pdf by bookmark
MarkLogic Server
Developing Modules to Process Content
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 45
7.4
Design Patterns and Rules
The Content Processing Framework is designed with certain assumptions about what the modules 
called in a pipeline will do. This section describes these rules and provides XQuery design 
patterns to help you follow the rules in your XQuery code. It is important to follow these rules in 
your XQuery modules; not following these rules can lead to unexpected results. The following 
topics are included:
• 
Condition Modules Must Return a Boolean
• 
Condition Modules Should Not Update Documents
• 
Action Modules Use try/catch With cpf:success and cpf:failure
• 
Action Modules Operate On a Single Document
• 
Action Modules Must Be a Single Transaction
• 
Using XSLT Stylesheets Instead of Action Modules
7.4.1
Condition Modules Must Return a Boolean
Condition modules must return a boolean value (
true
or 
false
). 
In one common scenario, a condition module checks either the existence or the value of an 
element in the document or in its properties document. If it exists, then the module returns 
true
and the document needs processing for the current phase of the pipeline. Another scenario is that 
the condition performs some specialized logic based on some part of the document contents. The 
logic does not even need to pertain to the document, as long as the module returns 
true
or 
false
.
7.4.2
Condition Modules Should Not Update Documents
A condition module should only return a boolean value—it should not perform any other work. 
This is an assumption of the pipeline design. If you do perform updates in conditions, it will 
change the document from the state it was in when the event occurred (potentially causing an 
additional trigger to fire). Do not perform any document updates in a condition module; doing 
updates in conditions can cause non-deterministic behavior. 
7.4.3
Action Modules Use try/catch With cpf:success and cpf:failure
The mechanism for transitioning a document from one state to the next is carried out by two 
functions in the 
cpf.xqy
XQuery module: 
cpf:success
and 
cpf:failure
. These functions handle 
the logic to advance a document either to the on-success or to the on-failure state specified in the 
pipeline.
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
C#.NET PDF SDK- Create PDF from PowerPoint in C#. How to Use C#.NET PDF Control to Create PDF from Microsoft PowerPoint Presentation in .NET Project.
create bookmarks pdf files; adding bookmarks in pdf
VB.NET PDF - Create PDF Online with VB.NET HTML5 PDF Viewer
C#, C#.NET PDF Reading, C#.NET Annotate PDF in WPF, C#.NET PDF Create, C#.NET NET rotate PDF pages, C#.NET search text in PDF, C#.NET edit PDF bookmark, C#.NET
convert excel to pdf with bookmarks; add bookmarks to pdf
MarkLogic Server
Developing Modules to Process Content
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 46
Action modules must call either 
cpf:success
or 
cpf:failure
exactly once. By using these 
functions in a 
try
/
catch
expression in your XQuery code, it is easy to either advance the 
document to the success state when the code runs without exceptions, or to catch any exceptions 
in the XQuery code and then put the document in a failure state. This ensures that exactly one of 
these functions is called. In the XQuery code, you concatenate the 
cpf:success
call following 
your action code, and return 
cpf:failure
in the 
catch
clause (which is run only if the 
try
clause 
throws an exception).
The 
try
/
catch
expression ensures that the state is advanced in the same transaction that performs 
the document processing. This way, if processing is interrupted, the state of the document always 
matches the actual state of the content processing.
The following sample code (from the 
link-rename-action.xqy
module) shows how to use 
cpf:success
and 
cpf:failure
in a try/catch expression.
xquery version "1.0-ml";
import module namespace cpf = "http://marklogic.com/cpf"
at "/MarkLogic/cpf/cpf.xqy";
import module namespace lnk = "http://marklogic.com/cpf/links"
at "/MarkLogic/cpf/links.xqy";
declare variable $cpf:document-uri as xs:string external;
declare variable $cpf:transition as node() external;
try {
lnk:propagate-rename( $cpf:document-uri )
,
cpf:success( $cpf:document-uri, $cpf:transition, () )
}
catch ($e) {
cpf:failure( $cpf:document-uri, $cpf:transition, $e, () )
}
7.4.4
Action Modules Operate On a Single Document
Use care if your action modules modify multiple documents. As a general rule, action modules 
should only modify the document being processed; they should not modify any other documents 
without fully understanding the implications. Creating side effects by modifying other documents 
within a single transaction can cause triggers to fire on updates, which can (potentially) cause 
multiple updates to the same document to be queued in the task server. Therefore, you should only 
modify other documents if you fully understand the consequences (or if you are sure there are no 
triggers on the other updates).
If your action modules modify multiple documents, you must design your application to handle 
the side effects. Each time a document that is in the scope of a domain is updated, a trigger fires, 
which can initiate a new set of processing. If your application must do this, make sure you 
carefully think through the side effects that will occur.
MarkLogic Server
Developing Modules to Process Content
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 47
7.4.5
Action Modules Must Be a Single Transaction
An action module must execute as a single transaction; it should not update the document more 
than once. Avoid using 
xdmp:eval
or 
xdmp:invoke
to run other transactions from within an action 
module. The Content Processing Framework assumes that action modules will perform a single 
transaction.
If you do perform multiple update transactions in an action module, you should understand the 
implications. Transitions are initiated as transactions complete. Having multiple transactions 
complete in a single action module can lead to multiple transitions being initiated in parallel, 
leading to unpredictable results. While it is possible to do this, your application design must take 
this into account. For more details, see “Design Patterns For Content Applications” on page 50.
7.4.6
Using XSLT Stylesheets Instead of Action Modules
If you specify a path to an XSLT stylesheet instead of a path to an XQuery module in a pipeline, 
then the framework will invoke the stylesheet with the appropriate variables. For an action 
module, the stylesheet must return the new contents of the document. The framework takes care 
of invoking the stylesheet for you, and it takes care of the other mechanics (the 
try/catch
and 
calling 
cpf:success
or 
cpf:failure
); your stylesheet should not directly perform any updates, as 
the framework will take care of that for you. Note that this is different from XQuery actions, 
which actually perform the update. If your stylesheet produces multiple result documents in an 
action module, the first result document is the content that updates the document under CPF 
control. Any subsequent result documents in the stylesheet output are saved to the database at the 
URIs specified in the stylesheet.
MarkLogic Server
Using the Framework to Create Custom Applications
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 48
8.0   Using the Framework to Create Custom Applications
51
This chapter describes ways to use the MarkLogic Server Content Processing Framework to 
create custom applications that run your own modules. It includes the following sections:
• 
Install Content Processing Framework in Database
• 
Decide on the Stages and Logic for Your Processing
• 
Create and Load Your Pipelines
• 
Create and Load Your Modules
• 
Design Patterns For Content Applications
• 
Microsoft Office 2007 Documents
• 
Other CPF Applications Included With MarkLogic Server
8.1
Install Content Processing Framework in Database
You must install the Content Processing Framework in each database that contains documents you 
want to process. This section describes the procedure for installing the Status Change Handling 
Pipeline in a database, which enables you to create applications using the Content Processing 
Framework.
Note:  If you are using the Default Conversion Option, follow the installation steps in 
“The Default Conversion Option” on page 62 instead of the steps in this section. 
The installation process for the Default Conversion Option includes the 
installation of the Status Change Handling Pipeline, so the following procedure is 
not needed. 
Perform the following steps to install the Content Processing Framework in a database:
1.
If it is not already installed, install MarkLogic Server.
2.
Open the Admin Interface to the database page for the database in which you want to 
install the Content Processing Framework. 
3.
On the database configuration page, select a 
triggers database
to use with your database 
(for example, Triggers). You can use any database for the triggers database. It can be the 
same database as the one you are configuring (for example, you can set the Documents 
database as the triggers database for the Documents database) or it can be a different 
database (for example, the Triggers database created as part of the installation process).
4.
Click OK to apply the changes to the database configuration.
MarkLogic Server
Using the Framework to Create Custom Applications
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 49
5.
Click the Content Processing link under the database to which you want to install the 
Content Processing Framework. The Content Processing Summary page appears.
6.
On the Content Processing Summary page, click the Install tab. The Content Processing 
Installation page appears.
7.
On the Content Processing Installation page, select 
false
for the 
enable conversion
option and click Install. 
Note:  If you have purchased the Default Conversion Option and select 
true
for the 
enable conversion
option, the default conversion pipelines and domain will be 
installed (in addition to the Content Processing Framework). If you have not 
purchased the Default Conversion Option, the 
enable conversion
option will be 
greyed out.
8.
Click OK to confirm the installation of content processing in your database.
9.
When the installation is complete, the Content Processing Summary page appears. It 
should show content processing installed in your database. 
10.
On Content Processing Summary page, click the default domain for your database (for 
example, Default Documents if you chose the Documents database).
11.
On the Domain Configuration Page, modify any of the default values as needed to 
partition the data to which your processing will occur. The default values set the document 
scope to include any documents whose URI begins with a
/
and to use modules that are in 
the database defined as the modules database whose URI begins with a
/
. For details on 
setting the domain values, see “Creating and Modifying Domains” on page 29.
12.
Attach any relavant pipelines to the domain, as described in “Attaching and Detaching 
Pipelines to Domains” on page 30.
The Content Processing Framework is now installed for the database.
8.2
Decide on the Stages and Logic for Your Processing
The Content Processing Framework makes it easy to set up content processing applications that 
have multiple processing stages. The number of stages you need depends on the processing you 
need to do. Also, the number of passes you need to make through a document might contribute to 
the number of stages needed in your application because each stage can only result in a single 
update transaction to the document (see “Action Modules Must Be a Single Transaction” on 
page 47).
Pipeline actions are typically called based on a condition, so you need to decide on the logic for 
your conditions as well as your actions.
MarkLogic Server
Using the Framework to Create Custom Applications
MarkLogic 8—February, 2015
Content Processing Framework Guide—Page 50
8.3
Create and Load Your Pipelines
You must create and load any pipelines to define your content processing. Pipelines are XML 
documents that describe the conditions, actions, and states for your content processing 
application. For details on how to create and load pipelines, see “Understanding and Using 
Pipelines” on page 31.
8.4
Create and Load Your Modules
You must develop XQuery modules for any conditions or actions referenced in your pipelines. 
The XQuery modules are where the work of your content processing occurs. For the rules about 
condition and action modules, see “Developing Modules to Process Content” on page 43.
You should store your modules in the modules database and document root configured in the 
evaluation context
for the domain to which the pipeline is attached.
8.5
Design Patterns For Content Applications
The Content Processing Framework uses post-commit triggers to move content processing from 
one stage to another. Consequently, applications with complex sets of pipelines process certain 
things asynchronously. When you are designing applications with the Content Processing 
Framework, it is important to think through the consequences of this. 
The following are example scenarios which can cause asynchronous processing to occur in 
applications:
•  Suppose you update documents B and C while you are processing document A. Because 
you cannot guarantee which update will finish first, and which trigger action will execute 
first, document B might end up being processed before document C, or it might end up 
being processed after document C. 
•  Suppose documents B and C are both processing, and each process ends up changing a 
property on document A to a different value. After both transactions complete, the value 
of the property on document A will depend on whether document B or document C 
committed its processing first. Also, each update to document A will trigger an update 
action on document A.
•  Suppose a delete of document A triggers an action to occur which cleans up links to 
document A. Before the action transaction occurs, however, suppose document A is 
created again, triggering a different action. In this case, it would be a good idea for the 
delete action to check and make sure the document still does not exist before cleaning up 
links. 
These scenarios are not necessarily bad, but they can cause unexpected behavior if you do not 
properly understand them at application design time. Your applications either need to avoid these 
types of scenarios or they need to be designed to handle them.
Documents you may be interested
Documents you may be interested