def get_view(envelope_id, envelope_args, student, session, authentication_method='None'):
"""Get the recipient view
Parameters:
envelope_id (str): envelope ID
envelope_args (dict): parameters of the document
student (dict): student information
authentication_method (str): authentication method
Returns:
URL to the recipient view UI
"""
access_token = session.get('access_token')
account_id = session.get('account_id')
# Create the RecipientViewRequest object
recipient_view_request = RecipientViewRequest(
authentication_method=authentication_method,
client_user_id=envelope_args['signer_client_id'],
recipient_id='1',
return_url=envelope_args['ds_return_url'],
user_name=f"{student['first_name']} {student['last_name']}",
email=student['email']
)
# Obtain the recipient view URL for the signing ceremony
# Exceptions will be caught by the calling function
ds_client = DsClient.get_configured_instance(access_token)
envelope_api = EnvelopesApi(ds_client)
results = envelope_api.create_recipient_view(
account_id,
envelope_id,
recipient_view_request=recipient_view_request
)
return results
def saveDoc(envelopeId, orderNumber):
try:
# api_client object created when checkToken() function was called in aws_worker
api_client.set_default_header("Authorization", "Bearer " + api_client.token)
accountID = get_account_id()
envelope_api = EnvelopesApi(api_client)
results_file = envelope_api.get_document(accountID , "combined" , envelopeId)
# Create the output directory if needed
output_directory = os.path.join(current_directory, r'output')
if not os.path.exists(output_directory):
os.makedirs(output_directory)
if(not os.path.exists(output_directory)):
print(date() + "Failed to create directory")
filePath = os.path.join(current_directory, "output", ds_config("OUTPUT_FILE_PREFIX") + orderNumber + ".pdf")
# Cannot create a file when file with the same name already exists
if(os.path.exists(filePath)):
# Remove the existing file
os.remove(filePath)
# Save the results file in the output directory and change the name of the file
os.rename(results_file,filePath)
# Create a file
except ApiException as e:
print(date() + "API exception: {}. saveDoc error".format(e))
# Catch exception while fetching and saving docs for envelope
except Exception as e:
print(date() + "Error while fetching and saving docs for envelope {}, order {}".format(envelopeId, orderNumber))
print(date() + "saveDoc error {}".format(e))
def worker(args):
"""
This function does the work of creating the envelope in
draft mode and returning a URL for the sender"s view
"""
# Step 1. Create the envelope with "created" (draft) status
args["envelope_args"]["status"] = "created"
# Using worker from example 002
results = Eg002Controller.worker(args)
envelope_id = results["envelope_id"]
# Step 2. Create the sender view
view_request = ReturnUrlRequest(return_url=args["ds_return_url"])
# Exceptions will be caught by the calling function
api_client = create_api_client(base_path=args["base_path"], access_token=args["access_token"])
envelope_api = EnvelopesApi(api_client)
results = envelope_api.create_sender_view(
account_id=args["account_id"],
envelope_id=envelope_id,
return_url_request=view_request
)
# Switch to Recipient and Documents view if requested by the user
url = results.url
if args["starting_view"] == "recipient":
url = url.replace("send=1", "send=0")
return {"envelope_id": envelope_id, "redirect_url": url}
def get(self, request, envelope_id):
envelopes_api = EnvelopesApi(get_api_client())
context = {
'envelope_recipients': envelopes_api.list_recipients(ACCOUNT_ID, envelope_id),
'envelope': envelopes_api.get_envelope(ACCOUNT_ID, envelope_id)
}
return render(request, 'envelopes/envelope_detail.html', context=context)
def send_envelope(self):
self.check_token()
envelope = self.create_envelope()
envelope_api = EnvelopesApi(SendEnvelope.api_client)
results = envelope_api.create_envelope(SendEnvelope.accountID,
envelope_definition=envelope)
return results
def make_envelope(file, sender, signer_name, signer_email, token):
file.seek(0)
content_bytes = file.read()
base64_file_content = base64.b64encode(content_bytes).decode('ascii')
document = Document(document_base64=base64_file_content,
name='DocuScan Terms',
file_extension='html',
document_id=1)
signer = Signer(email=signer_email,
name=signer_name,
recipient_id='1',
routing_order='1')
envelope_definition = EnvelopeDefinition(
email_subject='Please sign these terms',
documents=[document],
recipients=Recipients(signers=[signer]),
status='sent')
api_client = ApiClient()
api_client.host = 'https://demo.docusign.net/restapi'
api_client.set_default_header('Authorization', 'Bearer ' + token)
envelope_api = EnvelopesApi(api_client)
results = envelope_api.create_envelope(
sender['accounts'][0]['account_id'],
envelope_definition=envelope_definition)
return results
def testListDocuments(self):
auth_api = AuthenticationApi()
envelopes_api = EnvelopesApi()
try:
login_info = auth_api.login()
assert login_info is not None
assert len(login_info.login_accounts) > 0
login_accounts = login_info.login_accounts
assert login_accounts[0].account_id is not None
base_url, _ = login_accounts[0].base_url.split('/v2')
self.api_client.host = base_url
docusign.configuration.api_client = self.api_client
docs_list = envelopes_api.list_documents(
login_accounts[0].account_id, self.envelope_id)
assert docs_list is not None
assert (docs_list.envelope_id == self.envelope_id)
print("EnvelopeDocumentsResult: ", end="")
pprint(docs_list)
except ApiException as e:
print("\nException when calling DocuSign API: %s" % e)
assert e is None # make the test case fail in case of an API exception
def get_view(cls, envelope_id, envelope_args, user, authentication_method='None'):
"""Get the recipient view
Parameters:
envelope_id (str): Envelope ID
envelope_args (dict): Parameters of the document
user (dict): User information
authentication_method (str): Authentication method
Returns:
URL to the recipient view UI
"""
# Create the recipient view request object
recipient_view_request = RecipientViewRequest(
authentication_method=authentication_method,
client_user_id=envelope_args['signer_client_id'],
recipient_id='1',
return_url=envelope_args['ds_return_url'],
user_name=f"{user['first_name']} {user['last_name']}",
email=user['email']
)
# Obtain the recipient view URL for the signing ceremony
# Exceptions will be caught by the calling function
ds_client = DsClient.get_instance()
envelope_api = EnvelopesApi(ds_client.api_client)
results = envelope_api.create_recipient_view(
ds_client.account_id,
envelope_id,
recipient_view_request=recipient_view_request
)
return results
def determine_is_signed(self, envelope_id):
"""
Queries docusign for a particular envelope to see if the user signed it or not
:param envelope_id: (String) -> The envelope_id of the document that is being checked
:return: (boolean) -> True: The document is signed
False: The document is not signed or error
"""
# Initialize the envelope api
envelopes_api = EnvelopesApi()
try:
# Queries docusign for the envelope and checks the status of the document
# if it is completed, then it is signed, otherwise it still hasn't been signed
if envelopes_api.list_recipients(
self.account_id,
envelope_id).signers[0].status == 'completed':
return True
else:
return False
except ApiException as e:
logger.error(
"\nException in {0} when calling DocuSign API: {1}".format(
DocusignWrapper.determine_is_signed.__name__, e))
return False
def list(self):
self.check_token()
envelope_api = EnvelopesApi(ListEnvelopes.api_client)
from_date = (datetime.now() + timedelta(days=-30)).strftime("%Y/%m/%d")
return envelope_api.list_status_changes(ListEnvelopes.accountID,
from_date=from_date)
def get_document(self, document_id, envelope_id):
self.check_token()
envelope_api = EnvelopesApi(Envelope.api_client)
document = envelope_api.get_document(Envelope.accountID, document_id, envelope_id, certificate=False)
os.rename(document, '/home/phamvantoanb/Workspaces/sun/python/nicigas/' + Envelope.accountID + "-" + envelope_id
+ "-" + document_id + '.pdf')
def send_document_for_signing(loan_id, signer_name, signer_email):
APP_PATH = os.path.dirname(os.path.abspath(__file__))
access_token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImtpZCI6IjY4MTg1ZmYxLTRlNTEtNGNlOS1hZjFjLTY4OTgxMjIwMzMxNyJ9.eyJUb2tlblR5cGUiOjUsIklzc3VlSW5zdGFudCI6MTU3NTY5MDA3NywiZXhwIjoxNTc1NzE4ODc3LCJVc2VySWQiOiI5YmM2MWNiZC1lMjA2LTQ4ZmYtOGE2OC1mZGM0ZGNlMWRhOWUiLCJzaXRlaWQiOjEsInNjcCI6WyJzaWduYXR1cmUiLCJjbGljay5tYW5hZ2UiLCJvcmdhbml6YXRpb25fcmVhZCIsImdyb3VwX3JlYWQiLCJwZXJtaXNzaW9uX3JlYWQiLCJ1c2VyX3JlYWQiLCJ1c2VyX3dyaXRlIiwiYWNjb3VudF9yZWFkIiwiZG9tYWluX3JlYWQiLCJpZGVudGl0eV9wcm92aWRlcl9yZWFkIiwiZHRyLnJvb21zLnJlYWQiLCJkdHIucm9vbXMud3JpdGUiLCJkdHIuZG9jdW1lbnRzLnJlYWQiLCJkdHIuZG9jdW1lbnRzLndyaXRlIiwiZHRyLnByb2ZpbGUucmVhZCIsImR0ci5wcm9maWxlLndyaXRlIiwiZHRyLmNvbXBhbnkucmVhZCIsImR0ci5jb21wYW55LndyaXRlIl0sImF1ZCI6ImYwZjI3ZjBlLTg1N2QtNGE3MS1hNGRhLTMyY2VjYWUzYTk3OCIsImF6cCI6ImYwZjI3ZjBlLTg1N2QtNGE3MS1hNGRhLTMyY2VjYWUzYTk3OCIsImlzcyI6Imh0dHBzOi8vYWNjb3VudC1kLmRvY3VzaWduLmNvbS8iLCJzdWIiOiI5YmM2MWNiZC1lMjA2LTQ4ZmYtOGE2OC1mZGM0ZGNlMWRhOWUiLCJhdXRoX3RpbWUiOjE1NzU2OTAwMDYsInB3aWQiOiIyZjA5MDc4Yy0yMzdiLTQ1ODMtYWI0MS1jOGM4NTg2MDllZmYifQ.wrcjGaFQTDAZ2NpYcT4i40hboJyc4s1NGNodhN0VEEWh-XuM5cmHJJQECEueGf3UA9taUjupFbI86JxMkpx9GqebBBNCT6UyHBq0GPbhy85nR2ktgYi6ZbcBJvxiLdWwd3IkrC0a-4GVAgqdp1pXVe79f4nPMmRzCvKMIsdlUUVcQCacPU7hgHNuZhwwPikQKO1WDEBCD8epv4qbil4_Er73It3-DNMNYa4yqaaQ64rb_xTOAwYZ4Ua3w6gW2Vot6zBIt-Gm1Go8GgDrzrAxES5W0e6DtQMUq48q9Kiba5YhdnZSXLC1yJIb2ma_p0j1NYW-Pu0WMjjK8Y_-4B6RpQ'
account_id = '5959504'
file_name_path = 'documents/approval_letter.pdf'
base_path = 'https://demo.docusign.net/restapi'
# Create the component objects for the envelope definition...
with open(os.path.join(APP_PATH, file_name_path), "rb") as file:
content_bytes = file.read()
base64_file_content = base64.b64encode(content_bytes).decode('ascii')
document = Document( # create the DocuSign document object
document_base64=base64_file_content,
name='Approval Letter', # can be different from actual file name
file_extension='pdf', # many different document types are accepted
document_id=1 # a label used to reference the doc
)
# Create the signer recipient model
signer = Signer( # The signer
email=signer_email,
name=signer_name,
recipient_id="1",
routing_order="1")
# Create a sign_here tab (field on the document)
sign_here = SignHere( # DocuSign SignHere field/tab
document_id='1',
page_number='1',
recipient_id='1',
tab_label='SignHereTab',
x_position='195',
y_position='147')
# Add the tabs model (including the sign_here tab) to the signer
signer.tabs = Tabs(sign_here_tabs=[
sign_here
]) # The Tabs object wants arrays of the different field/tab types
# Next, create the top level envelope definition and populate it.
envelope_definition = EnvelopeDefinition(
email_subject="Please sign this Approval Letter for your loan.",
documents=[
document
], # The order in the docs array determines the order in the envelope
recipients=Recipients(
signers=[signer]
), # The Recipients object wants arrays for each recipient type
status="sent" # requests that the envelope be created and sent.
)
# send envelope request
api_client = ApiClient()
api_client.host = base_path
api_client.set_default_header("Authorization", "Bearer " + access_token)
envelope_api = EnvelopesApi(api_client)
results = envelope_api.create_envelope(
account_id, envelope_definition=envelope_definition)
return results
def embedded_signing_ceremony(signer_email, signer_name, signer_id, signer_file_path, signer_file_name, form_filled_type):
with open(os.path.join(APP_PATH, signer_file_path), "rb") as file:
content_bytes = file.read()
base64_file_content = base64.b64encode(content_bytes).decode('ascii')
document = Document(document_base64 = base64_file_content, name = signer_file_name, file_extension = 'pdf', document_id = 1)
signer = Signer(email = signer_email, name = signer_name, recipient_id = "1", routing_order = "1", client_user_id = signer_id)
sign_here = SignHere(document_id = '1', page_number = '1', recipient_id = '1', tab_label = 'SignHereTab', x_position = '300', y_position = '650')
signer.tabs = Tabs(sign_here_tabs = [sign_here])
envelope_definition = EnvelopeDefinition(
email_subject = "Please sign this document sent from the Python SDK",
documents = [document],
recipients = Recipients(signers = [signer]),
status = "sent"
)
api_client = ApiClient()
api_client.host = base_path
api_client.set_default_header("Authorization", "Bearer " + access_token)
envelope_api = EnvelopesApi(api_client)
results = envelope_api.create_envelope(account_id, envelope_definition=envelope_definition)
envelope_id = results.envelope_id
recipient_view_request = RecipientViewRequest(authentication_method = "email", client_user_id = signer_id, recipient_id = '1', return_url = base_url + form_filled_type, user_name = signer_name, email = signer_email)
results = envelope_api.create_recipient_view(account_id, envelope_id, recipient_view_request = recipient_view_request)
return results.url
def send_document_for_signing():
"""
Sends the document <file_name> to be signed by <signer_name> via <signer_email>
"""
# Create the component objects for the envelope definition...
with open(os.path.join(APP_PATH, file_name_path), "rb") as file:
content_bytes = file.read()
base64_file_content = base64.b64encode(content_bytes).decode('ascii')
document = Document( # create the DocuSign document object
document_base64=base64_file_content,
name='Example document', # can be different from actual file name
file_extension='pdf', # many different document types are accepted
document_id=1 # a label used to reference the doc
)
# Create the signer recipient model
signer = Signer( # The signer
email=signer_email,
name=signer_name,
recipient_id="1",
routing_order="1")
# Create a sign_here tab (field on the document)
sign_here = SignHere( # DocuSign SignHere field/tab
document_id='1',
page_number='1',
recipient_id='1',
tab_label='SignHereTab',
x_position='195',
y_position='147')
# Add the tabs model (including the sign_here tab) to the signer
signer.tabs = Tabs(sign_here_tabs=[
sign_here
]) # The Tabs object wants arrays of the different field/tab types
# Next, create the top level envelope definition and populate it.
envelope_definition = EnvelopeDefinition(
email_subject="Please sign this document sent from the Python SDK",
documents=[
document
], # The order in the docs array determines the order in the envelope
recipients=Recipients(
signers=[signer]
), # The Recipients object wants arrays for each recipient type
status="sent" # requests that the envelope be created and sent.
)
# Ready to go: send the envelope request
api_client = ApiClient()
api_client.host = base_path
api_client.set_default_header("Authorization", "Bearer " + access_token)
envelope_api = EnvelopesApi(api_client)
results = envelope_api.create_envelope(
account_id, envelope_definition=envelope_definition)
return results
def get(self, request, *args, **kwargs):
envelopes_api = EnvelopesApi(get_api_client())
context = {}
from_date = (datetime.utcnow() - timedelta(days=60)).isoformat()
# retrieve all envelopes of last 2 months
context['envelope_list'] = envelopes_api.list_status_changes(ACCOUNT_ID, status='sent, delivered',
from_date=from_date).envelopes
return render(request, 'envelopes/envelope_list.html', context=context)
def testRequestASignature(self):
with open(SignTest1File, 'rb') as sign_file:
file_contents = sign_file.read()
# create an envelope to be signed
envelope_definition = docusign.EnvelopeDefinition()
envelope_definition.email_subject = 'Please Sign my Python SDK Envelope'
envelope_definition.email_blurb = 'Hello, Please sign my Python SDK Envelope.'
# add a document to the envelope
doc = docusign.Document()
base64_doc = base64.b64encode(file_contents).decode("utf-8")
doc.document_base64 = base64_doc
doc.name = 'TestFile.pdf'
doc.document_id = '1'
envelope_definition.documents = [doc]
# Add a recipient to sign the document
signer = docusign.Signer()
signer.email = Username
signer.name = 'Pat Developer'
signer.recipient_id = '1'
# Create a SignHere tab somewhere on the document for the signer to sign
sign_here = docusign.SignHere()
sign_here.document_id = '1'
sign_here.page_number = '1'
sign_here.recipient_id = '1'
sign_here.x_position = '100'
sign_here.y_position = '100'
sign_here.scale_value = '0.5'
tabs = docusign.Tabs()
tabs.sign_here_tabs = [sign_here]
signer.tabs = tabs
recipients = docusign.Recipients()
recipients.signers = [signer]
envelope_definition.recipients = recipients
envelope_definition.status = 'sent'
envelopes_api = EnvelopesApi()
try:
envelope_summary = envelopes_api.create_envelope(
self.user_info.accounts[0].account_id,
envelope_definition=envelope_definition)
assert envelope_summary is not None
assert envelope_summary.envelope_id is not None
assert envelope_summary.status == 'sent'
print("EnvelopeSummary: ", end="")
pprint(envelope_summary)
except ApiException as e:
print("\nException when calling DocuSign API: %s" % e)
assert e is None # make the test case fail in case of an API exception
def send_template(self, name, email):
webbrowser.open_new_tab(self._oauth_login_url)
print(self._oauth_login_url)
self._api_client.configure_jwt_authorization_flow(
self._private_key_filename, self._oauth_base_url, self._integrator_key, self._user_id, 3600)
docusign.configuration.api_client = self._api_client
template_role_name = 'Needs to sign'
# create an envelope to be signed
envelope_definition = docusign.EnvelopeDefinition()
envelope_definition.email_subject = 'Please Sign my Python SDK Envelope'
envelope_definition.email_blurb = 'Hello, Please sign my Python SDK Envelope.'
# assign template information including ID and role(s)
envelope_definition.template_id = self._template_id
# create a template role with a valid template_id and role_name and assign signer info
t_role = docusign.TemplateRole()
t_role.role_name = template_role_name
t_role.name = name
t_role.email = email
# create a list of template roles and add our newly created role
# assign template role(s) to the envelope
envelope_definition.template_roles = [t_role]
# send the envelope by setting |status| to "sent". To save as a draft set to "created"
envelope_definition.status = 'sent'
auth_api = AuthenticationApi()
envelopes_api = EnvelopesApi()
try:
login_info = auth_api.login(api_password='******', include_account_id_guid='true')
assert login_info is not None
assert len(login_info.login_accounts) > 0
login_accounts = login_info.login_accounts
assert login_accounts[0].account_id is not None
self._base_url, _ = login_accounts[0].base_url.split('/v2')
self._api_client.host = self._base_url
docusign.configuration.api_client = api_client
envelope_summary = envelopes_api.create_envelope(login_accounts[0].account_id, envelope_definition=envelope_definition)
assert envelope_summary is not None
assert envelope_summary.envelope_id is not None
assert envelope_summary.status == 'sent'
print("EnvelopeSummary: ", end="")
pprint(envelope_summary)
except ApiException as e:
print("\nException when calling DocuSign API: %s" % e)
assert e is None # make the test case fail in case of an API exception
def get(self, request, *args, **kwargs):
envelope_definition = make_envelope()
envelopes_api = EnvelopesApi(get_api_client())
results = envelopes_api.create_envelope(ACCOUNT_ID, envelope_definition=envelope_definition)
sign_envelope = SigEnvelope.objects.create(envelope_id=results.envelope_id)
sign_request = SignRequest.objects.create(envelope=sign_envelope, error_details=results.error_details,
status_date_time=results.status_date_time)
Recipient.objects.create(recipient_id='1', sign_request=sign_request, email='*****@*****.**')
return JsonResponse({'envelope_id': results.envelope_id})
def get(self, request, envelope_id):
envelopes_api = EnvelopesApi(get_api_client())
envelope = envelopes_api.get_envelope(ACCOUNT_ID, envelope_id)
envelope.status = 'voided'
envelope.voided_reason = 'changed my mind'
envelope.purge_state = None
envelopes_api.update(ACCOUNT_ID, envelope_id, envelope=envelope)
SigEnvelope.objects.get(envelope_id=envelope_id).delete()
return redirect('esign:envelope_list')
def download(cls, args):
"""Download the specified document from the envelope"""
ds_client = DsClient.get_instance()
envelope_api = EnvelopesApi(ds_client.api_client)
file_path = envelope_api.get_document(ds_client.account_id,
args['document_id'],
args['envelope_id'])
(dirname, filename) = os.path.split(file_path)
return send_from_directory(directory=dirname,
filename=filename,
as_attachment=True)
def post(self, request, envelope_id):
signer = Signer(email=request.POST['email'], name='Aaqib 2', recipient_id='2', routing_order='1')
sign_here = SignHere(anchor_string='**Employee Signature**', anchor_units='pixels',
anchor_y_offset='10', anchor_x_offset='100')
signer.tabs = Tabs(sign_here_tabs=[sign_here])
recipients = Recipients(signers=[signer])
envelopes_api = EnvelopesApi(get_api_client())
envelope = envelopes_api.create_recipient(ACCOUNT_ID, envelope_id, recipients=recipients,
resend_envelope='true')
sign_request = SignRequest.objects.get(envelope=SigEnvelope.objects.get(envelope_id=envelope_id))
Recipient.objects.create(email=request.POST['email'], recipient_id='2', sign_request=sign_request)
return redirect(reverse('esign:envelope_detail', kwargs={'envelope_id': envelope_id}))
def testRequestSignatureFromTemplate(self):
template_role_name = 'Needs to sign'
# create an envelope to be signed
envelope_definition = docusign.EnvelopeDefinition()
envelope_definition.email_subject = 'Please Sign my Python SDK Envelope'
envelope_definition.email_blurb = 'Hello, Please sign my Python SDK Envelope.'
# assign template information including ID and role(s)
envelope_definition.template_id = template_id
# create a template role with a valid templateId and roleName and assign signer info
t_role = docusign.TemplateRole()
t_role.role_name = template_role_name
t_role.name = 'Pat Developer'
t_role.email = username
# create a list of template roles and add our newly created role
# assign template role(s) to the envelope
envelope_definition.template_roles = [t_role]
# send the envelope by setting |status| to "sent". To save as a draft set to "created"
envelope_definition.status = 'sent'
auth_api = AuthenticationApi()
envelopes_api = EnvelopesApi()
try:
login_info = auth_api.login(api_password='******',
include_account_id_guid='true')
assert login_info is not None
assert len(login_info.login_accounts) > 0
login_accounts = login_info.login_accounts
assert login_accounts[0].account_id is not None
base_url, _ = login_accounts[0].base_url.split('/v2')
self.api_client.host = base_url
docusign.configuration.api_client = self.api_client
envelope_summary = envelopes_api.create_envelope(
login_accounts[0].account_id,
envelope_definition=envelope_definition)
assert envelope_summary is not None
assert envelope_summary.envelope_id is not None
assert envelope_summary.status == 'sent'
print("EnvelopeSummary: ", end="")
pprint(envelope_summary)
except ApiException as e:
print("\nException when calling DocuSign API: %s" % e)
assert e is None # make the test case fail in case of an API exception
def worker(args):
"""
1. Call the envelope get method
"""
# Exceptions will be caught by the calling function
api_client = create_api_client(base_path=args["base_path"],
access_token=args["access_token"])
envelopes_api = EnvelopesApi(api_client)
results = envelopes_api.get_form_data(account_id=args["account_id"],
envelope_id=args["envelope_id"])
return results
def ds_return():
#
# Step 5. Get the envelop id from the request.
#
print(request.args)
envelope_id = request.args.get('envelope_id')
#
# Step 6. Create and define the API Client.
#
api_client = get_api_client_by_jwt_authorization_flow()
#
# Step 7. The envelope definition is created and ready to access list documents
#
envelope_api = EnvelopesApi(api_client)
docs_list = envelope_api.list_documents(DS_CONFIG['account_id'],
envelope_id)
print("EnvelopeDocumentsResult:\n{0}", docs_list)
#
# Step 8. Retrieve the document based on list documents and the envelope id
#
document_id = docs_list.envelope_documents[0].document_id
data = envelope_api.get_document(DS_CONFIG['account_id'], document_id,
envelope_id)
print(data)
#
# Step 9. Process the document in order to gat a base64 string to be showed into the html iframe
#
with open(os.path.join(data), "rb") as document:
content_bytes = document.read()
base64_file_content = base64.b64encode(content_bytes).decode('ascii')
print(base64_file_content)
return '''
<html lang="en">
<body>
<iframe name="LendingFront" src="data:application/pdf;base64, {file}" height="700" width="700"></iframe>
</body>
</html>
'''.format(event=request.args.get('event'), file=base64_file_content)
def setUp(self):
self.api_client = docusign.ApiClient(base_path=BaseUrl,
oauth_host_name=OauthHostName)
self.api_client.rest_client.pool_manager.clear()
docusign.configuration.api_client = self.api_client
try:
email_subject = 'Please Sign my Python SDK Envelope'
email_blurb = 'Hello, Please sign my Python SDK Envelope.'
template_id = TemplateId
role_name = 'Needs to sign'
name = 'Pat Developer'
email = Username
t_role = docusign.TemplateRole(role_name=role_name,
name=name,
email=email)
# send the envelope by setting |status| to "sent". To save as a draft set to "created"
status = 'sent'
# create an envelope definition
envelope_definition = docusign.EnvelopeDefinition(
email_subject=email_subject,
email_blurb=email_blurb,
template_id=template_id,
template_roles=[t_role],
status=status)
envelopes_api = EnvelopesApi()
self.api_client.host = BaseUrl
token = (self.api_client.request_jwt_user_token(
client_id=IntegratorKey,
user_id=UserId,
oauth_host_name=OauthHostName,
private_key_bytes=PrivateKeyBytes,
expires_in=3600))
self.user_info = self.api_client.get_user_info(token.access_token)
self.api_client.rest_client.pool_manager.clear()
docusign.configuration.api_client = self.api_client
envelope_summary = envelopes_api.create_envelope(
self.user_info.accounts[0].account_id,
envelope_definition=envelope_definition)
self.api_client.rest_client.pool_manager.clear()
self.envelope_id = envelope_summary.envelope_id
except ApiException as e:
print("\nException when calling DocuSign API: %s" % e)
except Exception as e:
print("\nException when calling DocuSign API: %s" % e)
self.api_client.rest_client.pool_manager.clear()
def send(cls, envelope):
"""Send an envelope
Parameters:
envelope (object): EnvelopeDefinition object
Returns:
envelope_id (str): envelope ID
"""
# Call Envelope API create method
# Exceptions will be caught by the calling function
ds_client = DsClient.get_instance()
envelope_api = EnvelopesApi(ds_client.api_client)
results = envelope_api.create_envelope(ds_client.account_id,
envelope_definition=envelope)
return results.envelope_id
def testRequestSignatureFromTemplate(self):
template_role_name = 'Needs to sign'
# Set properties and create an envelope later on
email_subject = 'Please Sign my Python SDK Envelope'
email_blurb = 'Hello, Please sign my Python SDK Envelope.'
# assign template information including ID and role(s)
template_id = TemplateId
# create a template role with a valid templateId and roleName and assign signer info
role_name = template_role_name
name = 'Pat Developer'
email = Username
t_role = docusign.TemplateRole(role_name=role_name,
name=name,
email=email)
# create a list of template roles and add our newly created role
# assign template role(s) to the envelope
template_roles = [t_role]
# send the envelope by setting |status| to "sent". To save as a draft set to "created"
status = 'sent'
# create the envelope definition with the properties set
envelope_definition = docusign.EnvelopeDefinition(
email_subject=email_subject,
email_blurb=email_blurb,
template_id=template_id,
template_roles=template_roles,
status=status)
envelopes_api = EnvelopesApi()
try:
envelope_summary = envelopes_api.create_envelope(
self.user_info.accounts[0].account_id,
envelope_definition=envelope_definition)
assert envelope_summary is not None
assert envelope_summary.envelope_id is not None
assert envelope_summary.status == 'sent'
print("EnvelopeSummary: ", end="")
pprint(envelope_summary)
except ApiException as e:
print("\nException when calling DocuSign API: %s" % e)
assert e is None # make the test case fail in case of an API exception
def worker(args):
"""
1. Call the EnvelopeDocuments::list method
"""
# Exceptions will be caught by the calling function
api_client = create_api_client(base_path=args["base_path"],
access_token=args["access_token"])
envelope_api = EnvelopesApi(api_client)
# 1. Call the EnvelopeDocuments::list method
results = envelope_api.list_documents(account_id=args["account_id"],
envelope_id=args["envelope_id"])
return results
def download(args, session):
"""Download the specified document from the envelope"""
access_token = session.get('access_token')
account_id = session.get('account_id')
ds_client = DsClient.get_configured_instance(access_token)
envelope_api = EnvelopesApi(ds_client)
file_path = envelope_api.get_document(
account_id, args['document_id'], args['envelope_id']
)
(dirname, filename) = os.path.split(file_path)
return send_from_directory(
directory=dirname,
filename=filename,
as_attachment=True
)
def worker(cls, args):
"""
1. Create the envelope request object
2. Send the envelope
"""
envelope_args = args["envelope_args"]
# 1. Create the envelope request object
envelope_definition = cls.make_envelope(envelope_args)
# 2. call Envelopes::create API method
# Exceptions will be caught by the calling function
api_client = create_api_client(base_path=args["base_path"], access_token=args["access_token"])
envelope_api = EnvelopesApi(api_client)
results = envelope_api.create_envelope(account_id=args["account_id"], envelope_definition=envelope_definition)
envelope_id = results.envelope_id
return {"envelope_id": envelope_id}
