Adobe Sign Integration Guide¶

// Example profile configuration
def profileConfig = [
    client_id: "3AAABLblqZhA...",
    client_secret: "your-secret-key",
    auth_uri: "https://secure.eu1.adobesign.com/public/oauth/v2",
    token_uri: "https://api.eu1.adobesign.com/oauth/v2/token",
    refresh_uri: "https://api.eu1.adobesign.com/oauth/v2/refresh",
    redirect_uri: "https://your-domain:8443/otcs/cs",
    scope: "agreement_write+agreement_read+agreement_send",
    additional_props: "api_access_point@,web_access_point@",
    web_app_client_id: "UB7E5BXCXY"
]

def profileId = 'adobesign-profile'

try {
    // Validate profile and check for existing authentication
    adobesign.validateProfile(profileId)
    out << "Successfully authenticated with Adobe Sign profile: ${profileId}"

} catch(AuthenticationException e) {
    // Generate authorization URL and redirect user
    def redirectUrl = "${url}/runcs/${self.ID}"
    def authURL = adobesign.getAuthorizationUrl(profileId, redirectUrl)

    log.info("Redirecting to Adobe Sign authorization: ${authURL}")
    redirect authURL
}

def agreementRequest = adobesign.newAgreementRequestBuilder()
    .withName("Contract Agreement")
    .withMessage("Please review and sign this contract")
    .withElectronicSignature()
    .inProcess()
    .withExpirationTime(new Date() + 30) // 30 days from now
    .enableDocumentVisibility()
    .build()

def participantSet = adobesign.newParticipantSetInfoBuilder()
    .withRole("SIGNER")
    .withOrder(1)
    .addRecipient(users.current) // Current user
    .addRecipient([email: "user@example.com", name: "John Doe"])
    .build()

def fileInfo = adobesign.newFileInfoBuilder()
    .withTransientDocumentId("transient-doc-id")
    .withLabel("Contract Document")
    .build()

try {
    // 1. Retrieve document from Content Server
    def contract = docman.getDocument(1234567)

    // 2. Upload document to Adobe Sign
    def documentId = adobesign.uploadDocument(contract)

    // 3. Create participant set
    def participants = [
        adobesign.createSignerGroup([
            [email: "homer@example.com", name: "Homer J. Simpson"]
        ])
    ]

    // 4. Create and send agreement
    def agreementId = adobesign.createAndSendAgreement(
        [documentId],
        "Springfield Nuclear Power Plant - Employment Contract",
        participants,
        "Dear Homer, please sign the employment contract."
    )

    out << "Agreement created successfully with ID: ${agreementId}"

} catch (Exception e) {
    log.error("Error creating agreement: ${e.message}", e)
    out << "Error: ${e.message}"
}

try {
    // Upload multiple documents
    def documents = adobesign.uploadDocuments([
        docman.getDocument(1234567),
        docman.getDocument(1234568)
    ])

    // Create complex participant workflow
    def participants = [
        // First: Legal team approval
        adobesign.createParticipantSet([
            [email: "legal@company.com", name: "Legal Team"]
        ], 1, "APPROVER"),

        // Second: Department heads
        adobesign.createParticipantSet([
            [email: "hr@company.com", name: "HR Manager"],
            [email: "finance@company.com", name: "Finance Manager"]
        ], 2, "SIGNER"),

        // Third: Final approval
        adobesign.createParticipantSet([
            [email: "ceo@company.com", name: "CEO"]
        ], 3, "SIGNER")
    ]

    // Create agreement with custom configuration
    def agreementId = adobesign.createAndSendAgreement(
        documents,
        "Multi-Party Service Agreement",
        participants,
        "Please review and sign the attached service agreement. This document requires approval from legal, department heads, and final CEO approval."
    )

    out << "Complex agreement created: ${agreementId}"

} catch (Exception e) {
    log.error("Error creating complex agreement: ${e.message}", e)
}

try {
    def documents = adobesign.uploadDocuments([
        docman.getNode(2350027),
        docman.getNode(2349903)
    ])

    def agreementConfig = [
        participantSetsInfo: [
            [
                role: "SIGNER",
                memberInfos: [
                    [email: "homer@example.com", name: "Homer J. Simpson"],
                    [email: "marge@example.com", name: "Marge Simpson"]
                ],
                order: 1
            ]
        ],
        name: "Family Contract Agreement",
        signatureType: "ESIGN",
        fileInfos: documents.collect { [transientDocumentId: it] },
        state: "IN_PROCESS",
        message: "Family contract requiring both signatures",
        ccs: [
            [email: "lisa@example.com"],
            [email: "bart@example.com"]
        ],
        locale: 'en_US',
        expirationTime: new Date() + 14 // 14 days from now
    ]

    def agreementId = adobesign.sendAgreement(agreementConfig)
    out << "JSON-configured agreement created: ${agreementId}"

} catch (Exception e) {
    log.error("Error creating JSON agreement: ${e.message}", e)
}

try {
    // Upload documents for template
    def uploadedDocs = adobesign.uploadDocuments([
        docman.getDocument(1234567),
        docman.getDocument(1234568)
    ])

    // Create library files
    def libraryFiles = uploadedDocs.collect { docId ->
        adobesign.newLibraryFileBuilder()
            .withTransientDocumentId(docId)
            .build()
    }

    // Create template
    def template = adobesign.newTemplateRequestBuilder()
        .withName("Standard Contract Template")
        .shareWithUser()
        .withTemplateTypeDocument()
        .withFileInfos(libraryFiles)
        .build()

    def templateId = adobesign.createLibraryTemplate(template)
    out << "Library template created: ${templateId}"

} catch (Exception e) {
    log.error("Error creating library template: ${e.message}", e)
}

try {
    def agreementId = "your-agreement-id"

    // Get basic status
    def status = adobesign.getAgreementStatus(agreementId)
    out << "<p>Agreement Status: ${status}</p>"

    // Get detailed status
    def fullStatus = adobesign.getFullAgreementStatus(agreementId)
    out << "<p>Detailed Status: ${fullStatus}</p>"

    // Check if signed

    if (status == "SIGNED") {
        // Download signed documents
        def responseBody = adobesign.downloadAgreement(agreementId)
        if (responseBody) {
            CSResource signedPdf = docman.getTempResource("signed-contract.pdf", ".pdf")
            signedPdf.content.withOutputStream { os ->
                os << responseBody.byteStream()
            }
        }
    }

} catch (Exception e) {
    log.error("Error monitoring agreement: ${e.message}", e)
}

try {
    def agreementId = "your-agreement-id"

    // Send immediate reminder to next signers
    def reminderId = adobesign.sendImmediateReminder(
        agreementId,
        "Please sign the contract as soon as possible."
    )

    out << "Reminder sent: ${reminderId}"

} catch (Exception e) {
    log.error("Error sending reminder: ${e.message}", e)
}

try {
    def agreementId = "your-agreement-id"
    //Retrieve the IDs of the next signers in the flow
    def participantIds = adobesign.getNextSignersIds(agreementId)

    // Create reminder with custom schedule
    def reminderId = adobesign.sendReminder(
        agreementId,
        participantIds,
        "Friendly reminder to complete your signature",
        24, // First reminder after 24 hours
        "AGREEMENT_AVAILABILITY", // Start counting from when agreement becomes available
        "DAILY_UNTIL_SIGNED" // Send daily until signed
    )

    out << "Scheduled reminder created: ${reminderId}"

} catch (Exception e) {
    log.error("Error creating scheduled reminder: ${e.message}", e)
}

try {
    def agreementId = "your-agreement-id"

    // Create participant access info
    def participantAccessInfos = [
        adobesign.newParticipantAccessInfoBuilder()
            .withParticipantId("participant-id")
            .withEmail("user@example.com")
            .build()
    ]

    // Generate access URLs
    def accessResponse = adobesign.createDeliverableAccessURL(
        agreementId,
        participantAccessInfos
    )

    out << "Access URLs generated: ${accessResponse}"

} catch (Exception e) {
    log.error("Error creating deliverable access: ${e.message}", e)
}

/*
 * Complete Business Workspace integration script
 * Handles agreement creation, status monitoring, and document synchronization
 */

def bwID = params.bwID

try {
    if (!bwID) {
        throw new ExecutionFaultException("Business Workspace ID is required")
    }

    // Get Business Workspace
    CSNode bw = docman.getNode(bwID)
    if (!bw) {
        throw new ExecutionFaultException("Business Workspace not found: ${bwID}")
    }

    def bwNameId = "Business Workspace ${bw.name} (${bw.ID})"

    // Check if already processed
    def agreementCat = bw."Agreement".asType(Map)
    def agreementID = agreementCat["Signature State"]["Agreement ID"].flatten()[0]
    def agreementStatus = agreementCat["Signature State"]["Status"].flatten()[0]

    if (agreementID) {
        out << "${bwNameId} already sent for signature.<br>ID: <b>${agreementID}</b>, Status: <b>${agreementStatus}</b>"
        return
    }

    // Extract agreement details
    def agreementName = agreementCat["Agreement Name"][0] ?: bw.name
    def message = agreementCat["Message"][0] ?: "Please review and sign the attached documents"
    def participants = agreementCat["Participants"]

    if (!participants.size()) {
        throw new ExecutionFaultException("${bwNameId} has no participants configured")
    }

    // Get documents from Business Workspace
    def bwDocuments = bw.getChildrenFast()
    if (!bwDocuments) {
        throw new ExecutionFaultException("${bwNameId} has no documents to sign")
    }

    // Upload documents and create file info objects
    def documentsNodes = bwDocuments.collect { it.getOriginalNode() }
    def transientDocumentsIds = adobesign.uploadDocuments(documentsNodes)
    def transientDocuments = []

    transientDocumentsIds.eachWithIndex { docId, index ->
        def amUniqueId = UUID.randomUUID().toString()

        // Update document category
        bwDocuments[index]."Document"."Transient Document ID" = docId
        bwDocuments[index]."Document"."AM Unique ID" = amUniqueId
        bwDocuments[index].update()

        // Create file info for agreement
        transientDocuments.add(
            adobesign.newFileInfoBuilder()
                .withTransientDocumentId(docId)
                .withLabel(amUniqueId)
                .build()
        )
    }

    // Build participant sets from category data
    def participantSets = []
    def rolesKeys = participants*."Role".unique()

    rolesKeys.each { roleKey ->
        def orders = agreementCat["Participants"]
            .findAll { it."Role" == roleKey }
            .sort { it."Order" }
            *."Order".unique()

        orders.each { order ->
            def orderedParticipants = agreementCat["Participants"]
                .findAll { it."Role"[0] == roleKey[0] && it."Order"[0] == order[0] }

            def memberInfos = orderedParticipants.collect {
                if (it."User"[0]) {
                    users.getMemberById(it."User"[0])
                } else {
                    [name: it."Full Name"[0], email: it."Email"[0]]
                }
            }

            participantSets.add(
                adobesign.newParticipantSetInfoBuilder()
                    .withRole(roleKey[0].toUpperCase())
                    .withOrder(order[0] as Integer)
                    .withParticipantsFromList(memberInfos)
                    .build()
            )
        }
    }

    // Create and send agreement
    agreementID = adobesign.createAndSendAgreementWithTransientDocs(
        transientDocuments,
        agreementName,
        participantSets,
        message
    )

    if (agreementID) {
        // Update Business Workspace with agreement info
        bw."Agreement"."Signature State"."Agreement ID" = agreementID
        bw."Agreement"."Signature State"."Status" = "IN_PROCESS"
        bw.update()

        out << "Agreement created successfully for ${bwNameId}<br>Agreement ID: <b>${agreementID}</b>"
        log.info("Agreement created for Business Workspace ${bwNameId}: ${agreementID}")
    }

} catch (Exception e) {
    log.error("Error processing Business Workspace ${bwID}: ${e.message}", e)
    out << "Error: ${e.message}"
}

/*
 * Scheduled script for monitoring agreement status
 * Run this script periodically to check for status changes
 */

import org.apache.commons.io.FilenameUtils

// The path to the Adobe Sign Workspace, modify it to match your setup
def adobeSignWorkspacePath = "Workspaces:Adobe Sign Workspace"

// Retrieves the information about the category in order to be able to retrieve a specific document via the "AM Unique ID" category attribute
def adobeSignDocumentCategory                = docman.getCategory("Adobe Sign:Document")
def adobeSignDocumentCategoryDefinitionID    = adobeSignDocumentCategory.definitionID
def adobeSignAMUniqueIdAttributeID           = adobeSignDocumentCategory.getAttributeID('AM Unique ID')

// The method which peforms query to retrieve the specific document via the "AM Unique ID" category attribute that corresponds to the label of the transient document
def getDocumentByLabel = { amUniqueId ->
    try{
        // Define SQL code
        def sqlCode = """
SELECT 
        D.DataID "DATAID"
FROM    DTree D INNER JOIN LLAttrData LLA 
    ON D.DataID = LLA.ID AND D.VersionNum = LLA.VerNum
WHERE
    LLA.AttrID          = ${adobeSignAMUniqueIdAttributeID}
    AND LLA.DefID       = ${adobeSignDocumentCategoryDefinitionID} 
    AND LLA.ValStr      = '${amUniqueId}'
"""
        // Set cursor and transaction enabled flags
        Boolean cursorEnabled = true 
        Boolean transactionEnabled = true
        // Set record limit
        Integer recordLimit = 1

        // Run the SQL query
        def result = docman.runSQL(sqlCode,  cursorEnabled,  transactionEnabled,  recordLimit).rows

        return result[0].DATAID
    } catch(e) {
        log.error("Unable to retrieve the Document with the AM Unique ID  ${amUniqueId}", e)
    }
}

try {
    def workspacesNode = docman.getNodeByPath(adobeSignWorkspacePath)
    def businessWorkspaces = docman.getChildrenFast(workspacesNode).findAll { it.subtype == 848 }

    businessWorkspaces.each { bw ->
        def agreementID = bw."Agreement"."Signature State"."Agreement ID"[0]

        if (agreementID) {
            try {
                def agreementStatus = adobesign.getAgreementStatus(agreementID)
                def currentStatus = bw."Agreement"."Signature State"."Status"[0]

                if (agreementStatus.status != currentStatus) {
                    // Status changed - update local system
                    bw."Agreement"."Signature State"."Status" = agreementStatus.status
                    bw.update()

                    log.info("Agreement ${agreementID} status updated: ${currentStatus} -> ${agreementStatus.status}")

                    // Handle completed agreements
                    if (agreementStatus.status == "SIGNED") {
                        processSignedAgreement(agreementID, bw)
                    }
                }

            } catch (Exception e) {
                log.error("Error checking status for agreement ${agreementID}: ${e.message}", e)
            }
        }
    }

} catch (Exception e) {
    log.error("Error in agreement monitoring: ${e.message}", e)
}

def processSignedAgreement(agreementID, businessWorkspace) {
    try {
        // Get agreement documents
        def documents = adobesign.getAgreementDocuments(agreementID)

        if (documents?.documents) {
            documents.documents.each { doc ->
                // Find corresponding Content Server document
                def bwDocument = getDocumentByLabel(doc.label)

                if (bwDocument) {
                    // Download signed document
                    def responseBody = adobesign.downloadDocument(agreementID, doc.id)

                    if (responseBody) {
                        // Save signed version
                        CSResource signedPdf = docman.getTempResource(
                            FilenameUtils.getBaseName(bwDocument.name), 
                            ".pdf"
                        )

                        signedPdf.content.withOutputStream { os ->
                            os << responseBody.byteStream()
                        }

                        // Add as new version
                        if (bwDocument.getOriginalNode()) {
                            bwDocument.getOriginalNode().addVersion(signedPdf.content)
                        } else {
                            bwDocument.addVersion(signedPdf.content)
                        }

                        log.info("Added signed version for document: ${bwDocument.name}")
                    }
                }
            }
        }

    } catch (Exception e) {
        log.error("Error processing signed agreement ${agreementID}: ${e.message}", e)
    }
}

try {
    def webhookId = adobesign.createAgreementWebhook(
        "WEBHOOK_FROM_SCRIPT", 
        "https://your_address:8443/csconsole/ext/adobesign/adobeSign.cs", 
        ["AGREEMENT_CREATED", "AGREEMENT_ACTION_COMPLETED", "AGREEMENT_WORKFLOW_COMPLETED"],
        true, // Include detailed info
        true, // Include participants info
        true, // Include documents info
        true  // Include signed documents
    )

    out << "Webhook created successfully: ${webhookId}"

} catch (Exception e) {
    log.error("Error while creating the webhook on Adobe Sign: ${e.message}", e)
}

try {
    adobesign.deleteWebhook(webhookId)
    out << "Webhook deleted successfully"

} catch (Exception e) {
    log.error("Error while deleting the webhook on Adobe Sign: ${e.message}", e)
}

import org.apache.commons.io.FilenameUtils;

// Child node create is triggered when you add to a container
// a node that was not already on Content Server 

log.debug( "Executing Adobe Sign synchronization callback. Adobe Sign data doc: '{}', parent folder: '{}', callbackID: '{}', eventSourceID: '{}'", newNodeID, nodeID, callbackID, eventSourceID)

def adobeSignAgreementCategory 
def adobeSignAgreementCategoryDefinitionID
def adobeSignAgreementIDAttributeID
def adobeSignDocumentCategory
def adobeSignDocumentCategoryDefinitionID
def adobeSignAMUniqueIdAttributeID

try {

    // Retrieves the information about the category in order to be able to retrieve a specific workspace via the "Agreement ID" category attribute
    adobeSignAgreementCategory                = docman.getCategory("Adobe Sign:Agreement")
    adobeSignAgreementCategoryDefinitionID    = adobeSignAgreementCategory.definitionID
    adobeSignAgreementIDAttributeID           = adobeSignAgreementCategory.getAttributeID('Agreement ID')

    // Retrieves the information about the category in order to be able to retrieve a specific document via the "AM Unique ID" category attribute
    adobeSignDocumentCategory                = docman.getCategory("Adobe Sign:Document")
    adobeSignDocumentCategoryDefinitionID    = adobeSignDocumentCategory.definitionID
    adobeSignAMUniqueIdAttributeID           = adobeSignDocumentCategory.getAttributeID('AM Unique ID')

} catch( Exception e ) {

    log.error("Error retrieving categories for Adobe Sign synchronization callback:" , e)

}

// The method which peforms query to retrieve the specific document via category attribute
def getNodeByCatAttrValue = { defID, attrID, valStr ->
    try{
        // Define SQL code
        def sqlCode = """
SELECT 
        D.DataID "DATAID"
FROM    DTree D INNER JOIN LLAttrData LLA 
    ON D.DataID = LLA.ID AND D.VersionNum = LLA.VerNum
WHERE
    LLA.DefID       = ${defID}
    AND LLA.AttrID  = ${attrID}
    AND LLA.ValStr  = '${valStr}'
"""
        // Set cursor and transaction enabled flags
        Boolean cursorEnabled = true 
        Boolean transactionEnabled = true
        // Set record limit
        Integer recordLimit = 1

        // Run the SQL query
        def result = docman.runSQL(sqlCode,  cursorEnabled,  transactionEnabled,  recordLimit).rows

        return result[0]?.DATAID
    } catch(e) {
        log.error("Unable to retrieve the Document with the AM Unique ID  ${valStr}", e)
    }
}

try{
    def newDocument = asCSNode(newNodeID)

    if( newDocument.mimeType == "application/json" ){

        def jsonSlurper = new JsonSlurper()
        def jsonResponse = jsonSlurper.parseText(newDocument.content.content.text)
        def agreement = jsonResponse.agreement

        if (agreement){

            def agreementID = agreement.id
            // Retrieves the Workspace linked to the agreement via the Agreement ID category attribute value and update its status
            def bwID = getNodeByCatAttrValue(adobeSignAgreementCategoryDefinitionID, adobeSignAgreementIDAttributeID, agreementID)
            if (bwID){
                def bWorkspace = docman.getNodeFast(bwID)

                if (bWorkspace){

                    bWorkspace."Agreement"."Status" = agreement.status
                    bWorkspace.update()

                    // If the workflow as been completed and the agreement is SIGNED, download and store the signed version of each document
                    if (agreement.status == "SIGNED"){
                        log.debug("#### Process Adobe Sign Webhook File - agreement signed: {}", agreementID)

                        agreement.documentsInfo.documents.each{

                            // Retrieves the Content Server document linked to the agreement document using the AM Unique ID attribute value
                            def bwDocumentID = getNodeByCatAttrValue(adobeSignDocumentCategoryDefinitionID, adobeSignAMUniqueIdAttributeID, it.label)

                            if (bwDocumentID) {
                                def bwDocument = docman.getNodeFast(bwDocumentID)

                                if (bwDocument){

                                    // Download the signed document
                                    def responseBody = adobesign.downloadDocument(agreementID, it.id)

                                    if (responseBody){

                                        CSResource pdfFile = docman.getTempResource(FilenameUtils.getBaseName(bwDocument.name), ".pdf")

                                        pdfFile.content.withOutputStream { os ->
                                            os << responseBody.byteStream()
                                        }

                                        // Add the signed version to the original node, if exists
                                        if (bwDocument instanceof CSGeneration) {

                                            bwDocument.getOriginalNode().addVersion(pdfFile.content)

                                        } else {

                                            bwDocument.addVersion(pdfFile.content)
                                        }

                                        log.error("Added signed version for the document ${bwDocument.name} for ${bWorkspace.name}")
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

    }

} catch( Exception e ) {

    log.error("Error synchronizing Adobe Sign data. Data file ID: {}", newNodeID, e)

}

try {
    adobesign.validateProfile("your-profile-id")
} catch (AuthenticationException e) {
    // Redirect to authorization
    def authURL = adobesign.getAuthorizationUrl("your-profile-id", redirectUrl)
    redirect authURL
}

try {
    def documentId = adobesign.uploadDocument(document)
} catch (CSAdobeSignDocumentUploadException e) {
    log.error("Document upload failed: ${e.message}")
    // Handle specific upload errors
}

try {
    def agreementId = adobesign.createAndSendAgreement(documents, name, participants, message)
} catch (ExecutionFaultException e) {
    log.error("Agreement creation failed: ${e.message}")
    // Check specific error details
}