Package com.veeva.vault.vapil.api.request

Class DocumentRequest

java.lang.Object
com.veeva.vault.vapil.api.request.VaultRequest<DocumentRequest>
com.veeva.vault.vapil.api.request.DocumentRequest
public class DocumentRequest extends VaultRequest<DocumentRequest>
Document Requests
  • CRUD operations (single and bulk)
  • Create from Template
  • Placeholders
  • Versions
  • Locks
  • Reclassify
  • Document Meta-Data
  • Document Types

Many documents requests, including single document requests, leverage the Document model for inbound/outbound API calls. This includes setters/getters for standard Vault fields and a setter/getter for custom fields. Example: 

 Document doc = new Document();

 doc.setName("VAPIL Single Document");
 doc.setLifecycle("General Lifecycle");
 doc.setType("General");
 doc.setTitle("Test Upload VAPIL");
 doc.setProperty("custom_field__c", "value");

 DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setInputPath(filePath)
                                        .createSingleDocument(doc);

Bulk endpoints should be used for multiple document transactions. Example with input CSV file: 

 DocumentBulkResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setInputPath(csvFilePath)
                                        .createMultipleDocuments();
Vault API Coverage:
https://developer.veevavault.com/api/25.1/#documents

The following endpoints are covered in other classes for ease of use

  • Field Details

    • HTTP_HEADER_VAULT_MIGRATION_MODE

      public static final String HTTP_HEADER_VAULT_MIGRATION_MODE
      X-VaultAPI-MigrationMode When set to true, Vault applies Document Migration Mode limitations only to documents created with the request.
      See Also:

    • ID_PARAM

      public static final String ID_PARAM
      If you’re identifying documents in your input by a unique field, add idParam={fieldname} to the request endpoint.
      See Also:

  • Method Details

    • retrieveAllDocumentFields

      public DocumentFieldResponse retrieveAllDocumentFields()
      Retrieve All Document Fields

      Retrieve all standard and custom document fields and field properties.

      Returns:
      DocumentFieldResponse
      Vault API Endpoint:
       GET /api/{version}/metadata/objects/documents/properties
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-all-document-fields
      Example Request:
       DocumentFieldResponse resp  = vaultClient.newRequest(DocumentRequest.class)
                .retrieveAllDocumentFields();
      Example Response:
       System.out.println(resp.getResponse());

    • retrieveCommonDocumentFields

      public DocumentFieldResponse retrieveCommonDocumentFields(Set<Integer> docIds)
      Retrieve Common Document Fields

      Retrieve all document fields and field properties which are common to (shared by) a specified set of documents. This allows you to determine which document fields are eligible for bulk update.

      Parameters:
      docIds - List of Document Ids
      Returns:
      DocumentFieldResponse
      Vault API Endpoint:
       POST /api/{version}/metadata/objects/documents/properties/find_common
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-common-document-fields
      Example Request:
       DocumentFieldResponse resp  = vaultClient.newRequest(DocumentRequest.class)
                .retrieveCommonDocumentFields();
      Example Response:
       System.out.println(resp.getResponse());

    • retrieveAllDocumentTypes

      public DocumentTypesResponse retrieveAllDocumentTypes()
      Retrieve All Document Types

      Retrieve all document types. These are the top-level of the document type/subtype/classification hierarchy.

      Returns:
      DocumentTypesResponse
      Vault API Endpoint:
       GET /api/{version}/metadata/objects/documents/types
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-all-document-types
      Example Request:
       DocumentTypesResponse allTypesResponse = vaultClient.newRequest(DocumentRequest.class)
                                .retrieveAllDocumentTypes();
      Example Response:
      System.out.println(allTypesResponse.getResponse());

 for (DocumentTypesResponse.DocumentType documentType : allTypesResponse.getTypes()) {
   DocumentTypeResponse typeResponse = vaultClient.newRequest(DocumentRequest.class).retrieveDocumentType(documentType.getName());
   System.out.println(typeResponse.getResponse());

   if (typeResponse.getSubtypes() != null) {
     for (DocumentTypeResponse.DocumentSubtype documentSubtype : typeResponse.getSubtypes()) {
       DocumentSubtypeResponse subtypeResponse = vaultClient.newRequest(DocumentRequest.class)
                                        .retrieveDocumentSubtype(documentType.getName(), documentSubtype.getName());
       System.out.println(subtypeResponse.getResponse());

       if (subtypeResponse.getClassifications() != null) {
         for (DocumentSubtypeResponse.DocumentClassification documentClassification : subtypeResponse.getClassifications()) {
           DocumentClassificationResponse classificationResponse = vaultClient.newRequest(DocumentRequest.class)
                                        .retrieveDocumentClassification(
           documentType.getName(),
           documentSubtype.getName(),
           documentClassification.getName());
           System.out.println(classificationResponse.getResponse());
           }
         }
       }
     }
   }
 }

    • retrieveDocumentType

      public DocumentTypeResponse retrieveDocumentType(String type)
      Retrieve Document Type

      Retrieve all metadata from a document type, including all of its subtypes (when available).

      Parameters:
      type - document type (api name)
      Returns:
      DocumentTypeResponse
      Vault API Endpoint:
       GET /api/{version}/metadata/objects/documents/types/{type}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-type
      Example Request:
       DocumentTypeResponse typeResponse = vaultClient.newRequest(DocumentRequest.class)
                .retrieveDocumentType(documentType.getName());
      Example Response:
       System.out.println("Response: " + typeResponse.getResponse());

    • retrieveDocumentSubtype

      public DocumentSubtypeResponse retrieveDocumentSubtype(String type, String subType)
      Retrieve Document Subtype

      Retrieve all metadata from a document subtype, including all of its classifications (when available).

      Parameters:
      type - document type (api name)
      subType - document subType (api name)
      Returns:
      DocumentSubtypeResponse
      Vault API Endpoint:
       GET /api/{version}/metadata/objects/documents/types/{type}/subtypes/{subtype}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-subtype
      Example Request:
       DocumentSubtypeResponse subtypeResponse = vaultClient.newRequest(DocumentRequest.class)
                .retrieveDocumentSubtype(documentType.getName(), documentSubtype.getName());
      Example Response:
       System.out.println("Response: " + subtypeResponse.getResponse());

    • retrieveDocumentClassification

      public DocumentClassificationResponse retrieveDocumentClassification(String type, String subType, String classification)
      Retrieve Document Classification
      Parameters:
      type - document type (api name)
      subType - document subType (api name)
      classification - document classification (api name)
      Returns:
      DocumentClassificationResponse
      Vault API Endpoint:
       GET /api/{version}/metadata/objects/documents/types/{type}/subtypes/{subtype}/classifications/{classification}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-classification
      Example Request:
       DocumentClassificationResponse classificationResponse = vaultClient.newRequest(DocumentRequest.class)
                .retrieveDocumentClassification(
                        documentType.getName(),
                        documentSubtype.getName(),
                        documentClassification.getName());
      Example Response:
       System.out.println("Response: " + classificationResponse.getResponse());

    • retrieveAllDocuments

      public DocumentsResponse retrieveAllDocuments()
      Retrieve All Documents

      Retrieve the latest version of all documents and binders

      Various properties can filter the list of returned documents

      • namedFilter=My Documents Retrieves only documents which you have created.
      • namedFilter=Favorites Retrieves only documents which you have marked as favorites in the library.
      • namedFilter=Recent Documents Retrieves only documents which you have recently accessed.
      • namedFilter=Cart Retrieves only documents in your cart.
      • versionsScope=contents Searches only within the document content.
      • versionsScope=all Searches both within the document content and searchable document fields.
      • versionsScope=all Retrieves all document versions, rather than only the latest version.
      • searchKeyword={keyword} Search for documents based on a {keyword} in searchable document fields.
      • limit
      • sort
      • start
      Returns:
      DocumentsResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-all-documents
      Example Request:
       DocumentsResponse response = vaultClient.newRequest(DocumentRequest.class)
                .retrieveAllDocuments();
      Example Response:
       System.out.println("Number of Documents: " + response.getSize());
 List<DocumentsResponse.DocumentNode> documents = response.getDocuments();
 for (DocumentsResponse.DocumentNode documentNode : documents) {
                Document document = documentNode.getDocument();
                System.out.println("Document Name: " + document.getName());
                System.out.println("Document ID: " + document.getId());
                System.out.println(("Major Version: " + document.getMajorVersionNumber()));
                System.out.println("Minor Version: " + document.getMinorVersionNumber());
 }

    • retrieveDocument

      public DocumentResponse retrieveDocument(int docId)
      Retrieve Document

      Retrieve all metadata from a single document

      Parameters:
      docId - The Document Id
      Returns:
      DocumentResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/{doc_id}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document
      Example Request:
       DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                .retrieveDocument(docId);
      Example Response:
       System.out.println(response.getResponse());
 Document responseDoc = response.getDocument();
 System.out.println("Name = " + responseDoc.getName());
 System.out.println("Title = " + responseDoc.getTitle());

 // Get a custom property
 System.out.println("Custom property custom__c = " + responseDoc.get("custom__c"));

 System.out.println("Renditions " + response.getRenditions().getViewableRendition());

 for (DocumentResponse.Version v : response.getVersions())
 System.out.println("Version = " + v.getNumber() + " " + v.getValue());

    • retrieveDocumentVersions

      public DocumentVersionResponse retrieveDocumentVersions(int docId)
      Retrieve Document Versions

      Retrieve all versions of a document.

      Parameters:
      docId - The Document Id
      Returns:
      DocumentVersionResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/{doc_id}/versions
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-versions
      Example Request:
       DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                .retrieveDocumentVersion(docId, 0, 1);
      Example Response:
       See retrieveDocument(int) for example responses

    • retrieveDocumentVersion

      public DocumentResponse retrieveDocumentVersion(int docId, int majorVersion, int minorVersion)
      Retrieve Document Version

      Retrieve all fields and values configured on a document version.

      Parameters:
      docId - The Document Id
      majorVersion - document major version number
      minorVersion - document minor version number
      Returns:
      DocumentResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/{doc_id}/versions/{major_version}/{minor_version}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-version
      Example Request:
       DocumentResponse response  = vaultClient.newRequest(DocumentRequest.class)
                .retrieveDocumentVersion(docId, 0, 1);
      Example Response:
       See retrieveDocument(int) for example responses

    • downloadDocumentFile

      public VaultResponse downloadDocumentFile(int docId)
      Download Document File
      Parameters:
      docId - The Document Id
      Returns:
      VaultResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/{doc_id}/file
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#download-document-file
      Example Request:
       VaultResponse response = vaultClient.newRequest(DocumentRequest.class).downloadDocumentFile(docId);
      Example Response:
      if (response != null && response.isSuccessful()) {
   System.out.println("Doc content length: " + response.getBinaryContent().length);
      }

    • downloadDocumentVersionFile

      public VaultResponse downloadDocumentVersionFile(int docId, int majorVersion, int minorVersion)
      Download Document Version File
      Parameters:
      docId - The Document Id
      majorVersion - document major version number
      minorVersion - document minor version number
      Returns:
      VaultResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/{doc_id}/versions/{major_version}/{minor_version}/file
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#download-document-version-file
      Example Request:
       VaultResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .downloadDocumentVersionFile(docId, majorVersion, minorVersion);
      Example Response:
       if (response != null && response.isSuccessful()) {
   System.out.println("Created doc content length: " + response.getBinaryContent().length);
 }

    • downloadDocumentVersionThumbnailFile

      public VaultResponse downloadDocumentVersionThumbnailFile(int docId, int majorVersion, int minorVersion)
      Download Document Version Thumbnail File
      Parameters:
      docId - The Document Id
      majorVersion - document major version number
      minorVersion - document minor version number
      Returns:
      VaultResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/{doc_id}/versions/{major_version}/{minor_version}/thumbnail
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#download-document-version-thumbnail-file
      Example Request:
       VaultResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .downloadDocumentVersionThumbnailFile(docId, majorVersion, minorVersion);
      Example Response:
       if (response != null && response.isSuccessful()) {
   System.out.println("Created doc content length: " + response.getBinaryContent().length);
 }

    • createSingleDocument

      public DocumentResponse createSingleDocument(Document doc)
      Create Single Document

      Create a single document by uploading the specified file.

      Use either the local path or binaryfile setters.

      Use bulk for multiple documents! See createMultipleDocuments().

      Parameters:
      doc - Document metadata to create
      Returns:
      DocumentResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-single-document
      Example Request:
       Document doc = new Document();

 doc.setName("VAPIL Single Document");
 doc.setLifecycle("General Lifecycle");
 doc.setType("General");
 doc.setTitle("Test Upload VAPIL");

 DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setInputPath(filePath)
                                        .createSingleDocument(doc);
      Example Response:
       System.out.println("Created doc id: " + response.getDocument().getId());

    • createDocumentFromTemplate

      public DocumentResponse createDocumentFromTemplate(Document doc, String fromTemplate)
      Create Documents from Templates
      Parameters:
      doc - Document to create
      fromTemplate - The Template to create from
      Returns:
      DocumentResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-single-document
      Example Request:
       DocumentResponse response = vaultClient.newRequest(DocumentRequest.class).createDocumentFromTemplate(doc, "template_name__c");
      Example Response:
      System.out.println("Created doc id: " + response);

    • createContentPlaceholderDocument

      public DocumentResponse createContentPlaceholderDocument(Document doc)
      Create Content Placeholder Documents
      Parameters:
      doc - Document to create
      Returns:
      DocumentCreateResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-single-document
      Example Request:
       DocumentResponse response = vaultClient.newRequest(DocumentRequest.class).createContentPlaceholderDocument(doc);
      Example Response:
      System.out.println("Created doc id: " + response.getDocument().getId());

    • createUnclassifiedDocument

      public DocumentResponse createUnclassifiedDocument()
      Create Unclassified Documents
      Returns:
      DocumentResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-single-document
      Example Request:
       DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setInputPath(filePath)
                                        .createUnclassifiedDocument();
      Example Response:
       System.out.println("Created doc id: " + response.getDocument().getId());

    • createCrossLinkDocument

      public DocumentResponse createCrossLinkDocument(Document doc, int source_vault_id__v, int source_document_id__v)
      Create Crosslink Document

      When creating a CrossLink document, you must include all document fields that are required for the specified document type/subtype/classification and no file is uploaded. You must also specify the vault ID and document ID for the source document which will be bound to the new CrossLink document.

      Source binding rules define which version of the source document will be bound to the CrossLink document. If not specified, this defaults to the Latest Steady State version.

      Parameters:
      doc - Document to create
      source_vault_id__v - The source Vault Id
      source_document_id__v - The source document id
      Returns:
      DocumentResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-single-document
      Example Request:
       Document doc = new Document();
 doc.setName("VAPIL CrossLink");
 doc.setLifecycle("General Lifecycle");
 doc.setType("General");
 doc.setTitle("VAPIL CrossLink - latest version");

 Example 1 - Create Crosslink
 response = vaultClient.newRequest(DocumentRequest.class)
                                .setSourceBindingRule(DocumentRequest.CrosslinkBinding.LATEST)
                                .createCrossLinkDocument(doc, vaultId, crosslinkDocId);

 Example 2 - Create Crosslink Bound to Latest Version
 DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .createCrossLinkDocument(doc, vaultId, crosslinkDocId);

 Example 3 - Create Crosslink Bound to Specific Document Version
 DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .setSourceBindingRule(DocumentRequest.CrosslinkBinding.SPECIFIC)
                                .setBoundSourceMajorVersion(1)
                                .setBoundSourceMinorVersion(0)
                                .createCrossLinkDocument(doc, vaultId, crosslinkDocId);
      Example Response:
       System.out.println("Created doc id: " + response.getDocument().getId());

    • createMultipleDocuments

      public DocumentBulkResponse createMultipleDocuments()
      Create Multiple Documents

      This endpoint allows you to create multiple documents at once with a CSV input file.

      The maximum CSV input file size is 1GB. The values in the input must be UTF-8 encoded. CSVs must follow the standard format. The maximum batch size is 500.

      Returns:
      DocumentBulkResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents/batch
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-multiple-documents
      Example Request:
       Example 1 - CSV input
 DocumentBulkResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setInputPath(csvFilePath)
                                        .createMultipleDocuments();
      , 
       Example 2 - Binary input
 DocumentBulkResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .setBinaryFile(csv.getName(), Files.readAllBytes(csv.toPath()))
                                .createMultipleDocuments();
      Example Response:
       System.out.println(response.getResponse());

    • updateSingleDocument

      public DocumentResponse updateSingleDocument(Document doc)
      Update Single Document

      Update editable field values on the latest version of a single document. To update past document versions, see Update Document Version. Note that this endpoint does not allow you to update the archive__v field.

      Use bulk for multiple documents! See updateMultipleDocuments().

      Parameters:
      doc - Document metadata to update
      Returns:
      DocumentResponse
      Vault API Endpoint:
       PUT /api/{version}/objects/documents/{doc_id}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#update-single-document

    • updateMultipleDocuments

      public DocumentBulkResponse updateMultipleDocuments()
      Update Multiple Documents

      Bulk update editable field values on multiple documents. You can only update the latest version of each document.

      Returns:
      DocumentBulkResponse
      Vault API Endpoint:
       PUT /api/{version}/objects/documents/batch
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#update-multiple-documents
      Example Request:
       Example 1 - CSV input
 DocumentBulkResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setInputPath(csvFilePath)
                                        .updateMultipleDocuments();
      , 
       Example 2 - Binary input
 DocumentBulkResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .setBinaryFile(csv.getName(), Files.readAllBytes(csv.toPath()))
                                .updateMultipleDocuments();
      Example Response:
       System.out.println(response.getResponse());

    • reclassifySingleDocument

      public DocumentResponse reclassifySingleDocument(Document doc)
      Reclassify Document

      Reclassify allows you to change the document type of an existing document or assign a document type to an unclassified document. A document is the combination of the type__v, subtype__v, and classification__v fields on a document. When you reclassify, Vault may add or remove certain fields on the document. You can only reclassify the latest version of a document and only one document at a time. The API does not currently support bulk reclassify.

      Parameters:
      doc - Document metadata to reclassify
      Returns:
      DocumentResponse
      Vault API Endpoint:
       PUT /api/{version}/objects/documents/{doc_id}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#reclassify-document

    • reclassifyMultipleDocuments

      public DocumentBulkResponse reclassifyMultipleDocuments()
      Reclassify Multiple Documents

      Reclassify documents in bulk. Reclassify allows you to change the document type of existing documents or assign document types to unclassified documents. A document is the combination of the type__v, subtype__v, and classification__v fields on a document. When you reclassify, Vault may add or remove certain fields on the document. You can only reclassify the latest version of a document you cannot reclassify a checked out document.

      Returns:
      DocumentBulkResponse
      Vault API Endpoint:
       PUT /api/{version}/objects/documents/batch/actions/reclassify
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#reclassify-multiple-documents

    • updateDocumentVersion

      public DocumentResponse updateDocumentVersion(Document doc, int majorVersion, int minorVersion)
      Update Document Version

      Update editable field values on a specific version of a document.

      Parameters:
      doc - Document metadata to update
      majorVersion - document major version number
      minorVersion - document minor version number
      Returns:
      DocumentResponse
      Vault API Endpoint:
       PUT /api/{version}/objects/documents/{doc_id}/versions/{major_version}/{minor_version}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#update-document-version

    • createMultipleDocumentVersions

      public DocumentBulkResponse createMultipleDocumentVersions()
      Create Multiple Document Versions

      Your vault must be in Migration Mode. The maximum CSV input file size is 1GB. The values in the input must be UTF-8 encoded. CSVs must follow the standard format. The maximum batch size is 500.

      Returns:
      DocumentBulkResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents/versions/batch
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-multiple-documents

    • createSingleDocumentVersion

      public DocumentResponse createSingleDocumentVersion(int docId)
      Create Single Document Version

      Add a new draft version of an existing document. You can choose to either use the existing source file, or a new source file. These actions will increase the document’s minor version number. This is analogous to using the Create Draft action in the UI. Use bulk for multiple documents!

      Parameters:
      docId - Document id
      Returns:
      DocumentCreateResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents/{doc_id}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-single-document-version
      Example Request:
       Example 1 - Create Single Document Version From Uploaded Content
 DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                .setBinaryFile(testFile.getAbsolutePath(), Files.readAllBytes(testFile.toPath()))
                .setCreateDraft(CreateDraftType.UPLOADEDCONTENT)
                .createSingleDocumentVersion(docId);

 Example 1 - Create Single Document Version From Latest Content
 DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                .setCreateDraft(CreateDraftType.LATESTCONTENT)
                .createSingleDocumentVersion(docId);

 Example 1 - Create Single Document Version From Placeholder
 DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                .setBinaryFile(testFile.getAbsolutePath(), Files.readAllBytes(testFile.toPath()))
                .createSingleDocumentVersion(docId);
      Example Response:
       System.out.println("Response Status: " + response.getResponseStatus());
 System.out.println("Major Version: " + response.getDocument().getMajorVersionNumber());
 System.out.println("Minor Version: " + response.getDocument().getMinorVersionNumber());

    • deleteSingleDocument

      public DocumentResponse deleteSingleDocument(int docid)
      Delete Single Document

      Delete all versions of a document, including all source files and viewable renditions.

      Parameters:
      docid - The Document Id
      Returns:
      DocumentResponse
      Vault API Endpoint:
       DELETE /api/{version}/objects/documents/{document_id}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#delete-single-document

    • deleteMultipleDocuments

      public DocumentBulkResponse deleteMultipleDocuments()
      Delete Multiple Documents

      Delete all versions of multiple documents, including all source files and viewable renditions.

      The maximum input file size is 1GB. The values in the input must be UTF-8 encoded. CSVs must follow the standard format. The maximum batch size is 500.

      Returns:
      DocumentBulkResponse
      Vault API Endpoint:
       DELETE /api/{version}/objects/documents/batch
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#delete-multiple-documents
      Example Request:
       Example 1 - CSV input
 DocumentBulkResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setInputPath(csvFilePath)
                                        .deleteMultipleDocuments();
      , 
       Example 2 - Binary input
 DocumentBulkResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .setBinaryFile(csv.getName(), Files.readAllBytes(csv.toPath()))
                                .deleteMultipleDocuments();
      Example Response:
       System.out.println(response.getResponse());

    • deleteSingleDocumentVersion

      public DocumentResponse deleteSingleDocumentVersion(int docId, int majorVersion, int minorVersion)
      Delete Single Document Version

      Delete a specific version of a document, including the version’s source file and viewable rendition. Other versions of the document remain unchanged.

      Parameters:
      docId - Document metadata to update
      majorVersion - document major version number
      minorVersion - document minor version number
      Returns:
      DocumentResponse
      Vault API Endpoint:
       DELETE /api/{version}/objects/documents/{doc_id}/versions/{major_version}/{minor_version}
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#delete-single-document-version
      Example Request:
       DocumentResponse response = vaultClient.newRequest(DocumentRequest.class)
                .deleteSingleDocumentVersion(docId, 0, 1);
      Example Response:
       System.out.println("Response Status: " + response.getResponseStatus());
 System.out.println("ID: " + response.getDocument().getId());

    • deleteMultipleDocumentVersions

      public DocumentBulkResponse deleteMultipleDocumentVersions()
      Delete Multiple Document Versions

      Delete a specific version of multiple documents, including the version’s source file and viewable rendition.

      The maximum input file size is 1GB. The values in the input must be UTF-8 encoded. CSVs must follow the standard format. The maximum batch size is 500.

      Returns:
      DocumentBulkResponse
      Vault API Endpoint:
       DELETE /api/{version}/objects/documents/versions/batch
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#delete-multiple-documents

    • retrieveDeletedDocumentIds

      public DocumentDeletionResponse retrieveDeletedDocumentIds()
      Retrieve Deleted Document IDs

      Retrieve IDs of documents deleted within the past 30 days.

      After documents and document versions are deleted, their IDs remain available for retrieval for 30 days. After that, they cannot be retrieved. This request supports optional parameters to narrow the results to a specific date and time range within the past 30 days.

      To completely restore a document deleted within the last 30 days, contact Veeva support.

      Returns:
      DocumentDeletionResponse
      Vault API Endpoint:
       GET /api/{version}/objects/deletions/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-deleted-document-ids
      Example Request:
       DocumentDeletionResponse response = vaultClient.newRequest(DocumentRequest.class).retrieveDeletedDocumentIds();
      Example Response:
      if (response != null && response.isSuccessful()) {
   System.out.println("# deleted docs: " + response.getResponseDetails().getTotal());
 }

    • retrieveDeletedDocumentIdsByPage

      public DocumentDeletionResponse retrieveDeletedDocumentIdsByPage(String pageUrl)
      Retrieve Deleted Document IDs (By Page)

      Retrieve IDs of documents deleted using the previous_page or next_page parameter of a previous request

      Parameters:
      pageUrl - The URL from the previous_page or next_page parameter
      Returns:
      DocumentDeletionResponse
      Vault API Endpoint:
       GET /api/{version}/objects/deletions/documents
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-deleted-document-ids
      Example Request:
       DocumentDeletionResponse paginatedResponse = paginatedResponse = vaultClient.newRequest(JobRequest.class)
                .retrieveDeletedDocumentIdsByPage(response.getResponseDetails().getNextPage());
      Example Response:
      System.out.println(paginatedResponse.getResponseStatus())
      ;

    • retrieveDocumentLockMetadata

      public MetaDataDocumentLockResponse retrieveDocumentLockMetadata()
      Retrieve Document Lock Metadata
      Returns:
      MetaDataDocumentLockResponse
      Vault API Endpoint:
       GET /api/{version}/metadata/objects/documents/lock
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-lock-metadata
      Example Request:
       MetaDataDocumentLockResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .retrieveDocumentLockMetadata();
      Example Response:
       if (response.isSuccessful()) {
   for (DocumentLock documentLock : response.getProperties()) {
     System.out.println("Document Lock Properties: " + documentLock.getName());
   }
 }

    • createDocumentLock

      public VaultResponse createDocumentLock(int docId)
      Create Document Lock

      A document lock is analogous to checking out a document but without the file attached in the response for download.

      Parameters:
      docId - document id
      Returns:
      VaultResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents/{doc_id}/lock
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#create-document-lock
      Example Request:
       VaultResponse lockCreateResponse = vaultClient.newRequest(DocumentRequest.class)
                                .createDocumentLock(docId);
      Example Response:
       System.out.println("Document Lock Created: " + lockCreateResponse.getResponseStatus());

    • retrieveDocumentLock

      public DocumentLockResponse retrieveDocumentLock(int docId)
      Retrieve Document Lock
      Parameters:
      docId - document id
      Returns:
      VaultResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/{doc_id}/lock
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-lock
      Example Request:
       DocumentLockResponse lockResponse = vaultClient.newRequest(DocumentRequest.class)
                                .retrieveDocumentLock(docId);
      Example Response:
       System.out.println("Document Lock By: " + lockResponse.getLock().getLockedBy());
 System.out.println("Document Lock Date: " + lockResponse.getLock().getLockedDate());

    • deleteDocumentLock

      public VaultResponse deleteDocumentLock(int docId)
      Deleting Document Lock

      Deleting a document lock is analogous to undoing check out of a document.

      Parameters:
      docId - document id
      Returns:
      VaultResponse
      Vault API Endpoint:
       DELETE /api/{version}/objects/documents/{doc_id}/lock
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#delete-document-lock
      Example Request:
       VaultResponse lockDeleteResponse = vaultClient.newRequest(DocumentRequest.class)
                                .deleteDocumentLock(docId);
      Example Response:
       System.out.println("Document Lock Deleted: " + lockDeleteResponse.getResponseStatus());

    • undoCollaborativeAuthoringCheckout

      public DocumentCollaborativeCheckoutResponse undoCollaborativeAuthoringCheckout()
      Undo Collaborative Authoring Checkout

      Undo Collaborative Authoring checkout on up to 500 documents at once.

      Returns:
      DocumentCollaborativeCheckoutResponse
      Vault API Endpoint:
       DELETE /api/{version}/objects/documents/batch/lock
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#undo-collaborative-authoring-checkout
      Example Request:
       DocumentCollaborativeCheckoutResponse response = vaultClient.newRequest(DocumentRequest.class)
                .setInputPath(csv_path)
                .undoCollaborativeAuthoringCheckout();
      Example Response:
       for (DocumentCollaborativeCheckoutResponse.UndoCheckoutResponse undoCheckoutResponse : response.getData()) {
                System.out.println("Document ID: " + undoCheckoutResponse.getId());
                System.out.println("Response Status: " + undoCheckoutResponse.getResponseStatus());
                System.out.println("Response Message: " + undoCheckoutResponse.getResponseMessage());
 }

    • exportDocuments

      public JobCreateResponse exportDocuments(boolean includeSource, boolean includeRenditions, boolean includeAllVersions)
      Export Documents

      Use this request to export a set of document to your vault’s FTP staging server.

      Parameters:
      includeSource - indicates to include source content files
      includeRenditions - indicates to include renditions
      includeAllVersions - indicates to include all versions
      Returns:
      JobCreateResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents/batch/actions/fileextract
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#export-documents-1
      Example Request:
       JobCreateResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .setInputPath(filePath)
                        .exportDocuments(true, true, true);
      Example Response:
       if (response != null && response.isSuccessful()) {
   System.out.println("Job Id: " + response.getJobId());
 }

    • exportDocumentVersions

      public JobCreateResponse exportDocumentVersions(boolean includeSource, boolean includeRenditions)
      Export Document Versions

      Export a specific set of document versions to your vault’s FTP staging server. The files you export go to the u{userID} folder, regardless of your security profile.

      Parameters:
      includeSource - indicates to include source content files
      includeRenditions - indicates to include renditions
      Returns:
      JobCreateResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents/versions/batch/actions/fileextract
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#export-document-versions
      Example Request:
       JobCreateResponse response = vaultClient.newRequest(DocumentRequest.class)
                                .setInputPath(filePath)
                                .exportDocumentVersions(true, true);
      Example Response:
       if (response != null && response.isSuccessful()) {
   System.out.println("Job Id: " + response.getJobId());
 }

    • retrieveDocumentExportResults

      public DocumentExportResponse retrieveDocumentExportResults(int jobId)
      Retrieve Document Export Results

      After submitting a request to export documents from your vault, you can query your vault to determine the results of the request.

      Before submitting this request:

      You must have previously requested a document export job (via the API) which is no longer active.
      You must have a valid job_id value (retrieved from the document export binder request above).
      You must be a Vault Owner, System Admin or the user who initiated the job.

      Parameters:
      jobId - job id
      Returns:
      DocumentExportResponse
      Vault API Endpoint:
       GET /api/{version}/objects/documents/batch/actions/fileextract/{jobid}/results
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#retrieve-document-export-results
      Example Request:
       DocumentExportResponse exportResponse = vaultClient.newRequest(DocumentRequest.class)
                                .retrieveDocumentExportResults(jobId);
      Example Response:
       if (exportResponse != null && exportResponse.isSuccessful()) {
   List<DocumentExportResponse.ExportedDocument> exportedDocumentList = exportResponse.getData();
   if (exportedDocumentList != null) {
     for (DocumentExportResponse.ExportedDocument exportedDocument : exportedDocumentList) {
       System.out.println("id: " + exportedDocument.getId());
       System.out.println("major version: " + exportedDocument.getMajorVersionNumber());
       System.out.println("minor version: " + exportedDocument.getMinorVersionNumber());
       System.out.println("File: " + exportedDocument.getFile());
     }
   }
 }

    • documentTokens

      public DocumentTokenResponse documentTokens(List<Integer> docIds)
      Document Tokens

      The Vault Document Tokens API allows you to generates document access tokens needed by the external viewer to view documents outside of Vault.

      Parameters:
      docIds - list of document ids
      Returns:
      DocumentTokenResponse
      Vault API Endpoint:
       POST /api/{version}/objects/documents/tokens
      Vault API Help Link:
      https://developer.veevavault.com/api/25.1/#document-tokens
      Example Request:
       DocumentTokenResponse response = vaultClient.newRequest(DocumentRequest.class)
                                        .setExpiryDateOffset(10)
                                        .setDownloadOption(DocumentRequest.DownloadOption.PDF)
                                        .setTokenGroup("example")
                                        .documentTokens(docIds);
      Example Response:
      System.out.println(response.getResponse());

    • setBinaryFile

      public DocumentRequest setBinaryFile(String filename, byte[] binaryContent)
      Specify source data in an input file
      Parameters:
      filename - file name (no path)
      binaryContent - byte array of the file content
      Returns:
      The Request

    • setBoundSourceMajorVersion

      public DocumentRequest setBoundSourceMajorVersion(Integer boundSourceMajorVersion)
      Specify the Cross-Link Bound Source Major Version
      Parameters:
      boundSourceMajorVersion - Required when the source_binding_rule__v is set to Specific Document version
      Returns:
      The Request

    • setBoundSourceMinorVersion

      public DocumentRequest setBoundSourceMinorVersion(Integer boundSourceMinorVersion)
      Specify the Cross-Link Bound Source Minor Version
      Parameters:
      boundSourceMinorVersion - Required when the source_binding_rule__v is set to Specific Document version
      Returns:
      The Request

    • setChannel

      public DocumentRequest setChannel(String channel)
      Include the channel request parameter set to the website object record id value that corresponds to the distribution channel where the document is being made available. If no website record is specified, Vault will assume the request is for Approved Email.
      Parameters:
      channel - channel
      Returns:
      The Request

    • setContentTypeCsv

      public DocumentRequest setContentTypeCsv()
      Set the Header Content Type to CSV
      Returns:
      The Request

    • setContentTypeJson

      public DocumentRequest setContentTypeJson()
      Set the Header Content Type to JSON
      Returns:
      The Request

    • setDescription

      public DocumentRequest setDescription(String description)
      Specify description
      Parameters:
      description - description__v
      Returns:
      The Request

    • setDownloadOption

      public DocumentRequest setDownloadOption(DocumentRequest.DownloadOption downloadOption)
      Include the downloadOption request parameter set to PDF, source, both, or none. These allow users viewing the document to be able to download a PDF version or source version (Word™, PowerPoint™, etc.) of the document. If not specified, the download options default to those set on each document.
      Parameters:
      downloadOption - downloadOption for document tokens
      Returns:
      The Request

    • setExpiryDateOffset

      public DocumentRequest setExpiryDateOffset(Integer expiryDateOffset)
      Specify number of days after which the tokens will expire and the documents will no longer be available in the viewer. If not specified, the tokens will expire after 10 years by default.
      Parameters:
      expiryDateOffset - description__v
      Returns:
      The Request

    • setIdParam

      public DocumentRequest setIdParam(String idParam)
      Specify an UPSERT operation via the idParam
      Parameters:
      idParam - External Id field API name for the UPSERT
      Returns:
      The Request

    • setLimit

      public DocumentRequest setLimit(Integer limit)
      Set the limit of documents returned by retrieve all documents
      Parameters:
      limit - max number of documents returned
      Returns:
      The Request

    • setInputPath

      public DocumentRequest setInputPath(String inputPath)
      Specify source data in an input file
      Parameters:
      inputPath - Absolute path to the file for the request
      Returns:
      The Request

    • setLockDocument

      public DocumentRequest setLockDocument(Boolean lockDocument)
      Specify to check out the document before retrieval
      Parameters:
      lockDocument - whether or not to lock the document
      Returns:
      The Request

    • setOutputPath

      public DocumentRequest setOutputPath(String outputPath)
      Specify source data in an output file
      Parameters:
      outputPath - Absolute path to the file for the response
      Returns:
      The Request

    • setScopeFilter

      public DocumentRequest setScopeFilter(DocumentRequest.NamedFilter namedFilter)
      Set named filter of documents returned by retrieve all documents
      Parameters:
      namedFilter - named filter for documents
      Returns:
      The Request

    • setRequestString

      public DocumentRequest setRequestString(String requestString)
      Specify source data in an input string, such as a JSON request
      Parameters:
      requestString - The source request as a string
      Returns:
      The Request

    • setScopeFilter

      public DocumentRequest setScopeFilter(DocumentRequest.Scope scope)
      Set scope of documents returned by retrieve all documents
      Parameters:
      scope - scope of documents
      Returns:
      The Request

    • setSearchKeyword

      public DocumentRequest setSearchKeyword(String keyword)
      Search keyword for documents returned by retrieve all documents
      Parameters:
      keyword - keyword to search for
      Returns:
      The Request

    • setSort

      public DocumentRequest setSort(String sort)
      Sort for documents returned by retrieve all documents
      Parameters:
      sort - order by value
      Returns:
      The Request

    • setSourceBindingRule

      public DocumentRequest setSourceBindingRule(DocumentRequest.CrosslinkBinding sourceBindingRule)
      Specify the Cross-Link Source Binding Rule
      Parameters:
      sourceBindingRule - Possible values are Latest version, Latest Steady State version, or Specific Document version
      Returns:
      The Request

    • setStart

      public DocumentRequest setStart(Integer start)
      Set the starting position of documents returned by retrieve all documents
      Parameters:
      start - starting position
      Returns:
      The Request

    • setSteadyState

      public DocumentRequest setSteadyState(Boolean steadyState)
      Document Tokens: If set to true, Vault generates a token for the latest steady state version of a document. If you do not have view permission, or if a steady-state version does not exist, Vault returns an INVALID_STATE error. If omitted, the default value is false, and Vault generates a token for the latest version, regardless of state.
      Parameters:
      steadyState - true/false
      Returns:
      DocumentRequest

    • setSuppressRendition

      public DocumentRequest setSuppressRendition(Boolean suppressRendition)
      Specify whether to suppress rendition
      Parameters:
      suppressRendition - Required when the source_binding_rule__v is set to Specific Document version
      Returns:
      DocumentRequest

    • setTokenGroup

      public DocumentRequest setTokenGroup(String tokenGroup)
      This only required if you want to group together generated tokens for multiple documents in order to display the documents being referenced in the same viewer. This value accepts strings of alphanumeric characters (a-z, A-Z, 0-9, and single consecutive underscores) up to 255 characters in length.
      Parameters:
      tokenGroup - name of group
      Returns:
      The Request

    • setVersionScope

      public DocumentRequest setVersionScope(DocumentRequest.VersionsScope versionsScope)
      Set all versions or latest version of documents returned by retrieve all documents
      Parameters:
      versionsScope - scope for versions
      Returns:
      The Request

    • setMigrationMode

      public DocumentRequest setMigrationMode(boolean migrationMode)
      Enable migration mode to create multiple document versions in bulk and perform manual assignment of documents numbers. If not specified, the create multiple document versions endpoint will fail. API user must have the Document Migration permission to use this header.
      Parameters:
      migrationMode - The source request as a string
      Returns:
      The Request

    • setOffset

      public DocumentRequest setOffset(Integer offset)
      Set the offset, used to paginate Retrieve Deleted Document IDs API
      Parameters:
      offset - The offset as an int
      Returns:
      The Request

    • setStartData

      public DocumentRequest setStartData(String startDate)
      Set the start date, used to set start date for Retrieve Deleted Document IDs API
      Parameters:
      startDate - The start date as a string in the YYYY-MM-DDTHH:MM:SSZ format
      Returns:
      The Request

    • setEndData

      public DocumentRequest setEndData(String endDate)
      Set the end date, used to set end date Retrieve Deleted Document IDs API
      Parameters:
      endDate - The end date as a string in the YYYY-MM-DDTHH:MM:SSZ format
      Returns:
      The Request

    • setCreateDraft

      public DocumentRequest setCreateDraft(DocumentRequest.CreateDraftType createDraft)
      Set the createDraft type. This parameter is only required to create a new draft version from an existing document or by uploading a source file. To create a new version for a placeholder document, you must omit this parameter.
      Parameters:
      createDraft - The createDraft type: latestContent or uploadedContent
      Returns:
      The Request