Form Manager API

LiveCycle ES4 saw the (re)introduction of Form Manager. In simple terms Form Manager simplifies the process of managing forms. The official documentation for Form Manager can be found here
Once you have your required forms in Form Manager, you can start to build and manage Forms Portal. There are 2 ways to build forms portal.

  • Using Form Manager API
  • Using Forms Portal Components in CQ
  • FormPortalSample Portal

    In this post we will discuss the first option(using the Form manager api. In your web application you will need to make a ajax call as shown in the code snippet below.

    $(“#searchforms”).on(“click”,function()
    {
    var nameOfForm = “*”+$(“#formstosearch”).val();
    $.ajax({
    type:’POST’,
    url:”/lc/libs/formsmanager/manage.json?func=searchForms”,

    data:{
    appPath:””,
    cutPoints:”title|description|author|formUrl|pdfUrl”,
    relation:”NO_RELATION”,
    includeXdp:”false”,
    maxSize:0,
    offset:0,
    orderings:JSON.stringify([]),
    statements: JSON.stringify([{“name”:”title”,”value”:nameOfForm,”operator”:”CONTAINS”},{“name”:”status”,”value”:”true”,”operator”:”EQ”}])
    },
    success:function(data)
    {
    }

    Lets take a look at the code above
    #searchForms is the id of a button in the html page. When clicked the above code gets executed.nameOfForm is a variable which holds the value the user typed in the search box.
    Next is the ajax call which is being made to fetch the forms whose title starts with the value entered in the “#formsToSearch” field and forms whose status is “true”(meaning active)
    The ajax call has the following parameters
    appPath – This is application from which you want to search forms from. in our case we are searching for all forms in the repository
    cutPoints: These are the attributes of the form that are returned in the search results
    relation:Indicates what related objects to fetch. No_RELATION means no related objects to fetch
    statement: can have multiple statements. each statement will have name,value,operator. In our case the first statement is looking for forms whose title contains the value of the variable. The second statement is searching for forms whose status equals true(meaning active)

    Once the query is executed, the success handler function can access the results which are stored in the variable.
    You can then loop through the data elements and access title,description and other attributes using the data[i].title or data[i].description syntax

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 3.5/10 (6 votes cast)
    Posted in Adobe LiveCycle ES4 | Tagged , , | Comments Off

    Task Summary Page

    Workspace in LiveCycle ES4 now shows a new tab called the “Summary” tab. As the name indicates this tab can be used to summarize the current task details. By default the “Summary” tab does not have any content in it. The process developer can create the content of the “Summary” tab. In general it is used to show some extra information related to the current task- such as Task Summary or display the driving directions specific to the address mentioned in the task.
    The document listed hereTask Summary URL explains in detail the steps needed to display some task specific information in the summary tab. The pdf also has the necessary collateral to compete the short tutorial.
    you would need the following to successfully complete the steps mentioned in the document
    LiveCycle ES4 Server
    Livecyle ES4 Workbench
    and some experience with LiveCycle
    If you have any questions- Do not hesitate to ask

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 2.3/10 (3 votes cast)
    Posted in Adobe LiveCycle ES4 | Tagged , , | Comments Off

    Understanding reader extensions licensing

    We get many questions about reader extensions. That’s not surprising really because there are numerous ways to use reader extensions in an enterprise capacity as well as in a work group or consumer type of way. We also get many questions about the aspects of licensing reader extensions based on the fact that reader extended forms can be created from our Acrobat family of products as well as our LiveCycle family of products. The licensing programs for Acrobat and LiveCycle are designed to serve different uses and organizational needs. They scale from desktop use to enterprise levels

    Before we go too much further though, let me tell you what a reader extended document is.

    The reader extensions capability digitally signs a PDF form or document to enable certain features in the free Reader product on a per-file basis. These are features otherwise found in the full Acrobat product.  Extending features in a PDF document allows the content creator to offer more advanced capabilities to end users with free Reader without requiring them to purchase the full Acrobat product.  Examples of the features which are enabled by reader extensions include commenting, digital signatures, and saving forms and data offline.  We usually see customers take advantage of this technology to capture data in a form using reader extensions based on the ability for someone to fill out a form inside of the free Reader product, save it to their desktop, and then email it to the person needing this information.

    LiveCycle and Reader Extended Forms:

    Here’s an example of a reader extended form:  http://www.irs.gov/pub/irs-pdf/f1040.pdf.  This example was created using LiveCycle Enterprise Suite. LiveCycle is a server based product for automating form and document processing in enterprise organizations. The use of reader extensions in LiveCycle is targeted for large distribution use cases.  Other services available in LiveCycle can be used to generate PDF documents and forms and automate their processing in conjunction with other enterprise systems. LiveCycle’s reader extensions capabilities are licensed on a per-document (or form) or a per-recipient basis. Its usage can scale to extract information from an unlimited number of documents or an unlimited number of recipients.   A LiveCycle customer can purchase more document or recipient licenses as their business needs require.   For example, a state that wants to develop a single tax form to collect information from its 2 million citizens might purchase a per-document license for their form.  However, a government department of 6,000 planning to develop several human resources forms might be better served with per-recipient licenses.

    Acrobat and Reader Extended Forms:

    As I mentioned earlier, you can also create a reader extended form by using Acrobat.  Acrobat is a desktop product for producing and working with PDF documents on an individual basis.  The reader extension capabilities in Acrobat are intended for small scale distributions.    Acrobat provides capabilities to extract data into spreadsheets for further processing.

    The use of reader extension features in Acrobat is governed by the end user license agreement (EULA). Please see section 16.8.3 of the Acrobat  EULA  for the official description of  the proper use of Acrobat’s reader extension capabilities. Essentially it says, a licensee of Acrobat may either distribute a particular PDF form or document to an unlimited number of unique recipients provided they extract data from no more than 500 recipients OR extract data an unlimited number of times from no more than 500 recipients.  Let’s look at an example. A government department is creating a conference with a maximum capacity of 400 attendees. They develop a form for conference registration and publish it to their public website.  When the forms are received they extract the data from the first 400 forms they receive in order to fill up their conference seats. In this case, an Acrobat license is appropriate.

    In another example, a company of 350 employees creates a timesheet form that their employees complete each week.   The company can extract the data from this form an unlimited number of times.  In this case, an Acrobat license is appropriate.

    In our last example, a company posts a form to a public website hoping to gather data from as many respondents as possible, likely more than 500 respondents.  In this case, a LiveCycle license is appropriate as an Acrobat license cannot be used to gather data from more than 500 respondents.

    Licensing Examples

    Use Case

    Appropriate Software License

    Tax forms in a state with a population of 2 million LiveCycle Reader Extensions per-document
    Conference Registration for a conference of 400 participants Acrobat
    Timesheet form for a company of 350 Acrobat
    Several human resource forms for a government department of 6,000 LiveCycle Reader Extensions per-recipient

    Summary

    Adobe is committed to helping our customers understand our products and licensing strategy.  If you have questions about your use of Reader Extensions, please contact PublicSector@adobe.com for further assistance.

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 8.6/10 (21 votes cast)
    Posted in Adobe LiveCycle ES3 | 8 Comments

    LiveCycle Mobile Forms: bringing all the capabilities of XFA-based forms in HTML5

    Browser PDF viewers and LiveCycle forms

    Browsers like Google Chrome and Mozilla Firefox recently started to provide their own PDF viewers to display PDF documents. These native PDF viewers usually do not match the full capabilities provided by Adobe Reader. Specifically, they do not support XFA-based LiveCycle forms. As a result, end users are not able to fill and submit the form for further processing.

    Adobe issued an advisory to help users configure their browser settings to make Adobe Reader or Adobe Acrobat their default PDF viewer. See http://helpx.adobe.com/livecycle/kb/xfa-forms-firefox-chrome.html for configuring the PDF viewer for Mozilla Firefox and Google Chrome.

    Adobe appreciates that there are business scenarios where it’d be extremely difficult for LiveCycle customers to get their users to change the browser settings. For example, if a customer publishes LiveCycle forms on a public facing portal, it is going to be an impediment to the business if that portal asks its users to change their PDF viewer settings before opening the form. In many scenarios, the applicant may just take her business to some other competitor.

    If these scenarios resonate,  it’d be worthwhile to review the support for HTML5-based rendition of LiveCycle forms, introduced in LiveCycle ES4 release.

    Introducing Mobile Forms (powered by HTML5)

    LiveCycle ES4 provides support for rendering the LiveCycle forms into HTML5 such that the forms can be opened in browsers that provide HTML5 support, including those running on the mobile devices like iPad. The HTML5 rendition of the forms maintains the layout of the form and supports most form logic (such as JavaScript, form calc, and form validations) embedded in the XFA form template. This way, your technology investments in XFA forms are carried over easily to devices where running of the Adobe Reader plugin is not feasible.

    Here is a side-by-side comparison of LiveCycle ES4 rendition of a few LiveCycle sample forms in HTML5 and PDF — http://helpx.adobe.com/livecycle/help/experience-mobile-forms-capabilities.html.

    Upgrading to LiveCycle ES4

    LiveCycle ES4, with its support for HTML5 Forms, extends your business processes to your mobile workforce and clients, increasing productivity while providing access to any user equipped with a desktop, smartphone, or tablet.

    Interested in upgrading to LiveCycle ES4? See http://helpx.adobe.com/livecycle/help/mobile-forms/upgrade-livecycle-es4.html.

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 3.4/10 (7 votes cast)
    Posted in Adobe LiveCycle ES4, General Interest | Tagged , , , , , , | 2 Comments

    Managing LiveCycle Applications with ant

    Adobe LiveCycle ES4 introduces out of the box ant tasks which can help in managing LiveCycle Applications (like import, export, deploy etc).

    In past, Livecycle client SDK provided following public APIs for managing applications:

    public boolean deployApplication(String anApplicationName, 
        String anApplicationVersion) 
        throws ApplicationManagerClientException
    
    public boolean undeployApplication(String anApplicationName, 
        String anApplicationVersion) 
        throws ApplicationManagerClientException
    
    public String importApplication(Document aRequest) 
        throws DesigntimeServiceException
    
    public Document export(ArrayList exportReqs,
        String lcaDescription) 
        throws DesigntimeServiceException

    In addition to these APIs,  LiveCycle ES4 also provide convenient ant tasks which internally use these APIs.

    Declaring and using the ANT tasks

    To use the new ant tasks, following section needs to be added in the ant (i.e. build.xml) file:

    <!-- common section -->
    <property name="lc.sdk.home" 
        value="C:/Adobe/Adobe LiveCycle ES4/LiveCycle_ES_SDK" />
    <path id="application.client.classpath">
      <pathelement 
        location="${lc.sdk.home}/client-libs/thirdparty/axis.jar"/> 
      <pathelement 
        location="${lc.sdk.home}/client-libs/thirdparty/saaj.jar"/> 
      <pathelement 
        location="${lc.sdk.home}/client-libs/thirdparty/wsdl4j.jar"/> 
      <pathelement location=
        "${lc.sdk.home}/client-libs/thirdparty/commons-logging.jar"/>
      <pathelement 
        location="${lc.sdk.home}/client-libs/thirdparty/jaxrpc.jar"/> 
      <pathelement location=
        "${lc.sdk.home}/client-libs/thirdparty/commons-discovery.jar"/> 
      <pathelement location=
        "${lc.sdk.home}/client-libs/thirdparty/commons-collections-3.1.jar"/>
      <pathelement location=
        "${lc.sdk.home}/client-libs/thirdparty/activation.jar"/>
      <pathelement location=
        "${lc.sdk.home}/client-libs/thirdparty/mail.jar"/>
      <pathelement location=
        "${lc.sdk.home}/client-libs/common/adobe-livecycle-client.jar"/>
      <pathelement location=
        "${lc.sdk.home}/client-libs/common/adobe-usermanager-client.jar"/>
      <pathelement location=
        "${lc.sdk.home}/client-libs/common/adobe-repository-client.jar"/>
      <pathelement location=
        "${lc.sdk.home}/client-libs/common/adobe-application-remote-client.jar"/>
    </path>
    <taskdef name="deploy" classname=
      "com.adobe.livecycle.applicationmanager.ant.tasks.DeployApplicationTask">
      <classpath refid="application.client.classpath"/>
    </taskdef>
    <taskdef name="undeploy" classname=
      "com.adobe.livecycle.applicationmanager.ant.tasks.UndeployApplicationTask">
      <classpath refid="application.client.classpath"/>
    </taskdef>
    <taskdef name="deleteapp" classname=
    "com.adobe.livecycle.applicationmanager.ant.tasks.DeleteApplicationTask">
      <classpath refid="application.client.classpath"/>
    </taskdef>
    <taskdef name="exportlca" classname=
    "com.adobe.livecycle.applicationmanager.ant.tasks.ExportLCATask">
      <classpath refid="application.client.classpath"/>
    </taskdef>
    <taskdef name="importlca" classname=
    "com.adobe.livecycle.applicationmanager.ant.tasks.ImportLCATask">
      <classpath refid="application.client.classpath"/>
    </taskdef>

    After this section the defined tasks can be used as follows:

    <!-- This would import MyProcess on the server -->
    <importlca file="MyProcess.lca" 
      propertiesFile="lcserver.properties" />
    
    <!-- This would export application MyProcess from server 
    to file MyProcess.lca on the local machine -->
    <exportlca file="MyProcess.lca" appname="MyProcess" 
      appversion="1.0" propertiesFile="lcserver.properties" />
    
    <!-- This would deploy the imported application
    on the server -->
    <deploy appname="MyProcess" appversion="1.0" 
      propertiesFile="lcserver.properties" />
    
    <!-- This would undeploy the deployed application 
    on the server -->
    <undeploy appname="MyProcess" appversion="1.0" 
      propertiesFile="lcserver.properties" />
    
    <!-- This would delete the application on the server -->
    <delete appname="MyProcess" appversion="1.0" 
      propertiesFile="lcserver.properties" />

    The lcserver.properties file used in the example is of following form:

    serverUrl=http://<lc-server-ip>:<lc-server-port>
    username=administrator
    password=password
    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 6.0/10 (5 votes cast)
    Posted in Adobe LiveCycle ES4 | Comments Off

    Built-in profiler in LiveCycle ES4 for performance analysis

    New LiveCycle ES4 features like Forms Manager, HTML Workspace etc. require CQ repository as part of the installation. This embedded Adobe CQ, comes with a built in threads profiler. More information about this can be found at this CQ article. This profiler, being part of same container in which LiveCycle is running, collects thread data for LiveCycle classes and services as well.

    For Adobe LiveCycle ES4, built in profiler can be found at

    http://<server>:<port>/lc/system/console/profiler

    To use profiler, just reach above mentioned screen and click on “Start Collecting” button. This will start the profiler. To stop profiler, just click on “stop” button. Collected data will be shown on screen.

    Data will be shown in two parts

    1. Packages: Which code is executing
    2. Top 20 stack trace(s): Stack traces with highest count

    Before running the profiler, one can change few configurations to weed out unwanted threads and packages.Following screenshot shows self explaining configurations you can modify before starting profiler

    profiler

    This is available on Correspondence Management Publish instance as well.

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 7.2/10 (5 votes cast)
    Posted in Adobe LiveCycle ES4 | Comments Off

    XFA-based PDF forms on Firefox 19

    With the release of Firefox 19, Mozilla introduced a built-in PDF viewer. However, the XFA-based PDF forms do not open in the PDF viewer, by default. To open these forms using Firefox 19, you’d need to configure Firefox to open PDFs in Adobe Reader or Adobe Acrobat.

    For more details on how to accomplish this, see the knowledge base article at http://helpx.adobe.com/livecycle/kb/xfa-forms-mozilla-firefox-19.html.

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 7.2/10 (6 votes cast)
    Posted in General Interest | Tagged , , , | Comments Off

    Mobile Workspace offline internals

    With LiveCycle ES4, Mobile Workspace has enabled working without network connection. Offline support has mainly been achieved by caching and storing the data locally on the device. From the offset, the application assumes to be in offline mode. This has following major advantages:

    1. Any action performed by the user is stored offline ensuring that the user gets best experience.

    2. Make sure that the user action/data is not lost due to intermediate network disconnection.

    The offline app is constantly made to sync to the server by a background thread which has a timer setting that can be controlled by the user. The application also provides an on demand sync to the server using the refresh button at the top right of the main screen. It is possible to configuring the background sync thread frequency from the settings screen. Here we can see that the user is trying to change the sync frequency from 4 hours to 15 minutes.

    settings_screen

    The possible sync frequencies are 15 minutes, 1 hours, 4 hours, once per day or Manual. These can be selected from the drop down in the ‘General’ tab of the settings screen.

    sync_time_setting

    Once the user settings are saved, the background sync thread is updated as per the new settings.

    sync_settings_complete

    Data storage and caching

    Going into the internals of the data being stored on the device, application users disk storage, browser cache backed up by disk and the database in the form of webSql to store the complete data of the application. The main data associated with a task is

    a. Task metadata in the form of JSON associated with task object. This also includes the attachments metadata.

    b. Attachment files associated with the task.

    c. Form corresponding to the task and the form data, if any stored on the server.

    The application caches all this data efficiently onto the device so that the complete functionality can be replicated when there is no network connection. The task metadata and the other data in the form of task JSON is stored in the database in proper tables per user per server for efficient update and retrieval. Now comes the question of the attachment files  associated with the task. These files are downloaded and stored on the disk within the task specific directory. Lastly the form and the data associated with the form are cached with the help of browser cache. Browser cache of UIWebView uses NSURLCache concept to backup the shared cache of the application by disk. The browser cache is set to 40 MB which is sufficient to store the resources and the XDP of the forms associated with the task.

    Caching configuration

    By default the form and the attachments associated with the task are not cached onto the device. This comes with a background that the application should not blindly cache everything and it should be configurable for the user to decide what all data needs to be offlined. the default value of ‘Fetch forms’ and ‘fetch attachments’ is OFF in the ‘General tab of the settings screen.

    fetch_attachments fetch_formsOnce the user enables the caching or either forms or attachments then any subsequent refresh will cache the forms or attachments for the new tasks being synced form the server.

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 7.0/10 (3 votes cast)
    Posted in Adobe LiveCycle ES4 | Tagged , , , , , , , , | Comments Off

    Tags in Forms Manager

    One of the features provided by Forms Manager is a support to add CQ tags to Forms as a meta data. This blog post showcases how we can add CQ tags to the Form and use them to search Forms.

     CQ Tags

    Tags are a quick and easy method of classifying content (forms in case of Forms Manager). In technical terms, a tag is a piece of metadata assigned to a content node within CQ. You can also think of them as keywords or labels that you attach to a node (form in case of Forms Manager) to help you find it again.

    Some of the advantages of using CQ Tags with Forms Manager include

    • Tagging provides an easy straightforward way to organize forms without too much thought.
    • You can never have too many tags. Though if you have a lot, you can create namespaces to sort and organize your tags. With namespaces you can create categories of tags to make sure that tags that belong together are grouped together.
    • Tags are powerful organizers. With the ability to create tags and sub-tags it becomes possible to organize the forms in a logical structure.
    • Tags improve the form search experience. You can search for forms based on the tags added to them. Support for hierarchical tagging helps provide more appropriate search results.
    • Organization of forms on the existing portal through search API which supports tags.

    Scenario

    Assume you want to show a list of forms on your Portal, but in case you have a large number of forms you would want to bifurcate them based on categories and sub-categories. For example in case of a Taxation Department of a State some categories may be:

    • Income Tax Forms
      • Individual Tax Forms
      • Business / Enterprise Tax Forms
      • Non-Profit Organization Tax Forms
    • Sales Tax Forms
      • Sales Tax Registration Forms
      • Sales Tax Exemption Forms
      • Sales Tax Refund Forms
      • Annual Filer Forms
      • Quarterly Filer Forms

    Each category may then have multiple sub-categories and forms. In such a scenario you might like to maintain all the forms in a common repository where they can refer to common form fragments, but require an ability to identify a smaller set of forms that are relevant to the task at hand.

     Steps to use Tags with Forms Manager

    1. Create the tags in the CQ repository:
      1. Access the URL: http://<server>:<port>/lc and login with CQ admin credentials (admin/admin).
      2. Click on the ‘Tagging’ icon to create/update the tags.Screen Shot 2013-03-24 at 2.55.27 PM
      3. Create a new namespace or use an existing namespace. For creating a new namespace click on the New button highlighted below. Screen Shot 2013-03-24 at 2.56.54 PM
      4. Provide the required details in the dialog for the new namespace.Screen Shot 2013-03-24 at 2.58.01 PM
      5. Access the new namespace by selecting it from the tree structure on the left.
      6. For creating a tag click on the New button and provide the required information.
      7. For creating a sub-category select a tag from the tree structure on the left and add a new tag.
      8. Create all the tags in the required structure following the above steps.Screen Shot 2013-03-24 at 3.15.24 PM
    2. Add the tags to the forms in CQ repository:
      1. Access Forms Manager UI (url: http://<server>/<port>/lc/fm) and login with the credentials of a LiveCycle user with Forms Manager Administrator role (e.g. Super Administrator: administrator/password).
      2. Access the Form you want to add the tag information to.
      3. In the tags section – click the ‘+’ button to open the Tags widget, and access the tab for required namespace.
      4. Browse and select the required Tag to be added to the form.Screen Shot 2013-03-24 at 3.25.07 PM
      5. Click the ‘+’ button to close the Tags widget.Screen Shot 2013-03-24 at 3.25.43 PM
    3. Search for forms with Tags: CQ Tags support hierarchal structure, i.e. if you have added a tag A/B/C and search for a tag A/B (it parent), the child will also be listed. In the above example if a user has added a tag ‘Individual Tax Forms’ to a form, it will be listed when searching for forms with tag ‘Income Tax Forms’.
      1. Open the advanced search by clicking the Advanced search pod in Forms Tab.
      2. Click the ‘+’ button to open the Tags widget, and access the tab for required namespace.
      3. Browse and select the required Tag to be searched for.Screen Shot 2013-03-24 at 3.27.35 PM
      4. Click the ‘+’ button to close the Tags widget.
      5. Select the check-box before the tag to include the tag in the search condition.
      6. Click ‘Search’ button to perform the search.Screen Shot 2013-04-02 at 10.56.14 PM

    For more information on the exciting new features introduced in Adobe LiveCycle ES4  refer to the LiveCycle ES4 documentation link: What’s new in Adobe LiveCycle ES4 . For more information on Forms Manager Introduction to Forms Manager

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 9.5/10 (2 votes cast)
    Posted in Adobe LiveCycle ES4 | Tagged , , , | Comments Off

    Page 0 support for protected documents in LiveCycle Rights Management ES4

    Adobe LiveCycle Rights Management ES4 introduces Page 0 (Wrapper Document) support for Policy protected documents in Adobe LiveCycle ES4 release. In case of most of the non-Adobe PDF viewers, on opening LCRM protected documents a blank screen appears or the application aborts. With Page 0 support, for RM Policy protected PDFs, Cover Page or Page0 is displayed instead of the previewer displaying a blank screen or being completely aborted when viewed in non-Adobe PDF viewers.

    When viewing such documents (containing a Page 0) in Adobe Reader/Acrobat or Mobile Reader, the protected Document is opened by default.

    Implementation

    Processes can be created in Adobe LiveCycle Workbench to implement this functionality using the following Operations:

    1. Protect Document With Cover Page : This operation allows you to secure a given PDF document with the specified policy, and also adds a cover page to the document.
    2. Extract Protected Document : This operation allows you to extract the policy-protected PDF document from the PDF document with cover page

    Also, two new APIs have been added in LiveCycle Rights Management ES4 to implement this functionality:

    1. protectDocumentWithCoverPage : This API secures a given PDF with the specified policy, and returns a document with a cover page and the protected document as an attachment.
    2. extractProtectedDocument : This API extracts the protected document which is an attachment in the document with cover page. The document with cover page can be created using protectDocumentWithCoverPage method.

    Here is a sample code snippet for protecting a document with a CoverPage using protectDocumentWithCoverPage API:

    //Create a ServiceClientFactory instance
    ServiceClientFactory factory = ServiceClientFactory.createInstance(connectionProps);

    //Create a RightsManagementClient object
    RightsManagementClient rightsClient = new RightsManagementClient(factory);

    //Reference a PDF document to which a policy is applied
    FileInputStream fileInputStream = new FileInputStream("C:\\testFile.pdf");
    Document inPDF = new Document(fileInputStream);

    //Reference a Cover Page document
    FileInputStream coverPageInputStream = new FileInputStream("C:\\CoverPage.pdf");
    Document inCoverDoc = new Document(coverPageInputStream);

    //Create a Document Manager object
    DocumentManager documentManager = rightsClient.getDocumentManager();

    //Apply a policy to the PDF document
    RMSecureDocumentResult rmSecureDocument = documentManager.protectDocumentWithCoverPage(
    inPDF,
    "ProtectedPDF.pdf",
    "PolicySetName",
    "PolicyName",
    null,
    null,
    inCoverDoc,
    true);

    //Retrieve the policy-protected PDF document
    Document protectPDF = rmSecureDocument.getProtectedDoc();

    //Save the policy-protected PDF document
    File myFile = new File("C:\\PolicyProtectedDoc.pdf");
    protectPDF.copyToFile(myFile);

    Here is a sample code snippet for extracting the protected document from the document with CoverPage using extractProtectedDocument API:

    //Create a ServiceClientFactory instance
    ServiceClientFactory factory = ServiceClientFactory.createInstance(connectionProps);

    //Create a RightsManagementClient object
    RightsManagementClient rightsClient = new RightsManagementClient(factory);

    //Reference a protected PDF document with a Cover Page
    FileInputStream fileInputStream = new FileInputStream("C:\\policyProtectedDocWithCoverPage.pdf");
    Document inPDF = new Document(fileInputStream);

    //Create a Document Manager object
    DocumentManager documentManager = rightsClient.getDocumentManager();

    //Apply a policy to the PDF document
    Document extractedDoc = documentManager.extractProtectedDocument(inPDF);

    //Save the policy-protected PDF document
    File myFile = new File("C:\\PolicyProtectedDoc.pdf");
    extractedDoc.copyToFile(myFile);

     

    VN:F [1.9.22_1171]
    Was this helpful? Please rate the content.
    Rating: 9.0/10 (2 votes cast)
    Posted in Adobe LiveCycle ES4 | Tagged , | Comments Off