Module: Echosign::Request

Defined in:
lib/echosign/request.rb,
lib/echosign/widget/request.rb,
lib/echosign/agreement/request.rb,
lib/echosign/mega_sign/request.rb,
lib/echosign/library_documents/request.rb

Defined Under Namespace

Classes: EndpointHash, Failure

Constant Summary collapse

BASE_URL = 
'https://api.echosign.com/'
BASE_PATH = 
'api/rest/v5'
ENDPOINT = 
EndpointHash.new({
  base_uri: '/base_uris',
  transientDocument: '/transientDocuments',
  agreement: '/agreements',
  reminder: '/reminders',
  user: '/users',
  libraryDocument: '/libraryDocuments',
  widget: '/widgets',
  view: '/views',
  search: '/search',
  workflow: '/workflows',
  group: '/groups',
  megaSign: '/megaSigns',
}).freeze

Class Method Summary collapse

Class Method Details

.agreement_combined_pdf(token, base_uri, agreement_id, versionId, participantEmail, attachSupportingDocuments, auditReport) ⇒ String

Gets a single combined PDF document for the documents associated with an agreement.

Parameters:

  • token (String) —

    Auth Token

  • agreement_id (String) —

    ID of agreement to retrieve info on.

Returns:

  • (String) —

    Raw bytes from document file



56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/echosign/agreement/request.rb', line 56

def self.agreement_combined_pdf(token, base_uri, agreement_id, versionId, participantEmail,
                                attachSupportingDocuments, auditReport)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}/combinedDocument"
  endpoint << add_query(endpoint, "versionId=#{versionId}") unless versionId.nil?
  endpoint << add_query(endpoint, "participantEmail=#{participantEmail}") unless participantEmail.nil?
  endpoint << add_query(endpoint, "attachSupportingDocuments=#{attachSupportingDocuments}")
  endpoint << add_query(endpoint, "auditReport=#{auditReport}")
  response = get(endpoint, headers)
  response.body
end

.agreement_document_file(token, base_uri, agreement_id, document_id) ⇒ String

Retrieve agreement document PDF

Parameters:

  • token (String) —

    Auth Token

  • agreement_id (String) —

    ID of agreement to retrieve info on.

Returns:

  • (String) —

    Raw bytes from document file



84
85
86
87
88
89
 
# File 'lib/echosign/agreement/request.rb', line 84

def self.agreement_document_file(token, base_uri, agreement_id, document_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}/documents/#{document_id}"
  response = get(endpoint, headers)
  response.body
end

.agreement_documents(token, base_uri, agreement_id, recipient_email = nil, format = nil, version_id = nil) ⇒ Hash

Performs REST GET /agreement/:id/documents

Parameters:

  • agreement_id (String) —

    (REQUIRED)

  • recipient_email (String) (defaults to: nil) —

    The email address of the participant to be used to retrieve documents. (REQUIRED)

  • format (String) (defaults to: nil) —

    Content format of the supported documents. It can have two possible values ORIGINAL or CONVERTED_PDF. (REQUIRED)

  • version_id (String) (defaults to: nil) —

    Version of the agreement as provided by agreement_info. If not provided, the latest version of the agreement is used.

Returns:

  • (Hash) —

    Agreement documents response body



112
113
114
115
116
117
118
119
120
 
# File 'lib/echosign/agreement/request.rb', line 112

def self.agreement_documents(token, base_uri, agreement_id, recipient_email = nil, format = nil, version_id = nil)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}/documents"
  endpoint << add_query(endpoint, "versionId=#{version_id}") unless version_id.nil?
  endpoint << add_query(endpoint, "participantEmail=#{recipient_email}") unless version_id.nil?
  endpoint << add_query(endpoint, "supportingDocumentContentFormat=#{format}") unless format.nil?
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.agreement_form_data(token, base_uri, agreement_id) ⇒ String

Retrieves data entered by the user into interactive form fields at the time they signed the agreement

Parameters:

  • token (String) —

    Auth Token

  • agreement_id (String) —

    (REQUIRED)

Returns:

  • (String) —

    Raw bytes representing CSV file



73
74
75
76
77
 
# File 'lib/echosign/agreement/request.rb', line 73

def self.agreement_form_data(token, base_uri, agreement_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}/formData"
  response = get(endpoint, headers)
end

.agreement_info(token, base_uri, agreement_id) ⇒ Hash

Performs REST GET /agreement/:id operation

Parameters:

  • token (String) —

    Auth Token

  • agreement_id (String) —

    ID of agreement to retrieve info on.

Returns:

  • (Hash) —

    Agreement info response body



32
33
34
35
36
37
 
# File 'lib/echosign/agreement/request.rb', line 32

def self.agreement_info(token, base_uri, agreement_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.agreement_signing_urls(token, base_uri, agreement_id) ⇒ Hash

Performs REST GET /agreement/:id/signingUrls operation

Parameters:

  • token (String) —

    Auth Token

  • agreement_id (String) —

    ID of agreement to retrieve info on.

Returns:

  • (Hash) —

    URL information for the eSign page of the agreement



44
45
46
47
48
49
 
# File 'lib/echosign/agreement/request.rb', line 44

def self.agreement_signing_urls(token, base_uri, agreement_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}/signingUrls"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.audit_trail_pdf(token, base_uri, mega_sign_id) ⇒ String

Performs REST GET /mega_sign/:id/auditTrail operation

Parameters:

  • token (String) —

    Auth Token

  • mega_sign_id (String) —

    ID of mega_sign to retrieve info on.

Returns:

  • (String) —

    Raw bytes from audit pdf file



96
97
98
99
100
101
 
# File 'lib/echosign/agreement/request.rb', line 96

def self.audit_trail_pdf(token, base_uri, agreement_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}/auditTrail"
  response = get(endpoint, headers)
  response.body
end

.create_agreement(token, base_uri, body, user_id = nil, user_email = nil) ⇒ Hash

Performs REST create_agreement operation

Parameters:

  • body (Hash) —

    Request body (REQUIRED)

  • token (String) —

    Auth token (REQUIRED)

  • user_id (String) (defaults to: nil) —

    Echosign user ID (REQUIRED)

  • user_email (String) (defaults to: nil) —

    Echosign user email

Returns:

  • (Hash) —

    Agreement response body



9
10
11
12
13
14
15
 
# File 'lib/echosign/agreement/request.rb', line 9

def self.create_agreement(token, base_uri, body, user_id = nil, user_email = nil)
  headers = { 'Access-Token' => token }
  headers['X-User-Id'] = user_id unless user_id.nil?
  headers['X-User-Email'] = user_email unless user_email.nil?
  response = post(ENDPOINT.fetch(:agreement, base_uri), body, headers, json: true)
  JSON.parse(response.body)
end

.create_mega_sign(token, base_uri, body, user_id = nil, user_email = nil) ⇒ Hash

Performs REST create_mega_sign operation

Parameters:

  • body (Hash) —

    Request body (REQUIRED)

  • token (String) —

    Auth token (REQUIRED)

  • user_id (String) (defaults to: nil) —

    Echosign user ID (REQUIRED)

  • user_email (String) (defaults to: nil) —

    Echosign user email

Returns:

  • (Hash) —

    MegaSign response body



9
10
11
12
13
14
15
16
17
 
# File 'lib/echosign/mega_sign/request.rb', line 9

def self.create_mega_sign(token, base_uri, body, user_id = nil, user_email = nil)
  headers = { 'Access-Token' => token }
  headers['X-User-Id'] = user_id unless user_id.nil?
  headers['X-User-Email'] = user_email unless user_email.nil?
  headers['Content-Type'] = "application/json"
  response = HTTParty.post(ENDPOINT.fetch(:megaSign, base_uri), body: body.to_json,
                                                                headers: headers)
  JSON.parse(response.body)
end

.create_reminder(token, base_uri, body) ⇒ Hash

Sends a reminder for an agreement.

Parameters:

  • body (Hash) —

    Valid request body

  • token (String) —

    Auth Token

Returns:

  • (Hash) —

    Response body



73
74
75
76
77
78
 
# File 'lib/echosign/request.rb', line 73

def self.create_reminder(token, base_uri, body)
  endpoint = ENDPOINT.fetch(:reminder, base_uri)
  headers = { 'Access-Token' => token }
  response = post(endpoint, body, headers)
  JSON.parse(response.body)
end

.create_transient_document(token, base_uri, file_name, file_handle, mime_type = nil) ⇒ Hash

Performs REST create_transient_document operation

Parameters:

  • token (String) —

    Auth token (REQUIRED)

  • file_name (String) —

    File name (REQUIRED)

  • file_handle (File) —

    File handle (REQUIRED)

  • mime_type (String) (defaults to: nil) —

    Mime type

Returns:

  • (Hash) —

    Transient Document Response Body



87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/echosign/request.rb', line 87

def self.create_transient_document(token, base_uri, file_name, file_handle, mime_type = nil)
  headers = { 'Access-Token' => token }
  if file_handle.is_a?(String)
    raise "Cannot find file: #{file_handle}" unless File.exist?(file_handle)

    file_handle = File.new(file_handle)
  end
  body = { 'File-Name' => file_name, 'Mime-Type' => mime_type, 'File' => file_handle }
  response = post(ENDPOINT.fetch(:transientDocument, base_uri), body, headers)

  JSON.parse(response.body)
end

.create_user(token, base_uri, body) ⇒ Hash

Performs REST create_user operation

Parameters:

  • body (Hash) —

    Valid request body

  • token (String) —

    Auth Token

Returns:

  • (Hash) —

    New user response body



61
62
63
64
65
66
 
# File 'lib/echosign/request.rb', line 61

def self.create_user(token, base_uri, body)
  endpoint = ENDPOINT.fetch(:user, base_uri)
  headers = { 'Access-Token' => token }
  response = post(endpoint, body, headers)
  JSON.parse(response.body)
end

.create_widget(token, base_uri, widget) ⇒ Hash

Creates a widget and returns the Javascript snippet and URL to access the widget and widgetID in response to

the client

Parameters:

Returns:

  • (Hash) 


8
9
10
11
12
13
14
15
 
# File 'lib/echosign/widget/request.rb', line 8

def self.create_widget(token, base_uri, widget)
  endpoint = ENDPOINT.fetch(:widget, base_uri)
  headers = { 'Access-Token' => token }
  headers['X-User-Id'] = widget.user_id unless widget.user_id.nil?
  headers['X-User-Email'] = widget.user_email unless widget.user_email.nil?
  response = post(endpoint, widget, headers)
  JSON.parse(response.body)
end

.get_agreements(token, base_uri) ⇒ Hash

Performs REST GET /agreements operation

Parameters:

  • token (String) —

    Auth Token

Returns:

  • (Hash) —

    Agreements response body



21
22
23
24
25
 
# File 'lib/echosign/agreement/request.rb', line 21

def self.get_agreements(token, base_uri)
  headers = { 'Access-Token' => token }
  response = get(ENDPOINT.fetch(:agreement, base_uri), headers)
  JSON.parse(response.body)
end

.get_base_uris(token) ⇒ Object 



49
50
51
52
53
54
 
# File 'lib/echosign/request.rb', line 49

def self.get_base_uris(token)
  endpoint = ENDPOINT.fetch(:base_uri, BASE_URL)
  headers = { 'Access-Token' => token }
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_library_document(token, base_uri, library_document_id) ⇒ Hash

Retrieves library document metadata for a user.

Parameters:

  • token (String) —

    Auth Token

  • library_document_id (String)

Returns:

  • (Hash) —

    Library document metadata



24
25
26
27
28
29
 
# File 'lib/echosign/library_documents/request.rb', line 24

def self.get_library_document(token, base_uri, library_document_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:libraryDocument, base_uri)}/#{library_document_id}"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_library_document_file(token, base_uri, library_document_id, file_id) ⇒ String

Retrieves library document file data

Parameters:

  • token (String) —

    Auth Token

  • library_document_id (String) —

    (REQUIRED)

  • file_id (String) —

    (REQUIRED)

Returns:

  • (String) —

    Library document file data



49
50
51
52
53
 
# File 'lib/echosign/library_documents/request.rb', line 49

def self.get_library_document_file(token, base_uri, library_document_id, file_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:libraryDocument, base_uri)}/#{library_document_id}/documents/#{file_id}"
  response = get(endpoint, headers)
end

.get_library_document_files(token, base_uri, library_document_id) ⇒ Hash

Retrieves library document file

Parameters:

  • token (String) —

    Auth Token

  • library_document_id (String) —

    (REQUIRED)

Returns:

  • (Hash) —

    Library document files metadata



36
37
38
39
40
41
 
# File 'lib/echosign/library_documents/request.rb', line 36

def self.get_library_document_files(token, base_uri, library_document_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:libraryDocument, base_uri)}/#{library_document_id}/documents"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_library_documents(token, base_uri, user_id = nil, user_email = nil) ⇒ Hash

Retrieves library documents for a user.

Parameters:

  • token (String) —

    Auth Token

  • user_id (String) (defaults to: nil) —

    The ID of the user whose library documents are being requested.

  • user_email (String) (defaults to: nil) —

    The email address of the user whose library documents are being requested. If both user_id and user_email are provided then user_id is given preference. If neither is specified then the user is inferred from the access token.

Returns:

  • (Hash) —

    Library documents metadata



10
11
12
13
14
15
16
17
 
# File 'lib/echosign/library_documents/request.rb', line 10

def self.get_library_documents(token, base_uri, user_id = nil, user_email = nil)
  headers = { 'Access-Token' => token }
  headers['X-User-Id'] = user_id unless user_id.nil?
  headers['X-User-Email'] = user_email unless user_email.nil?
  endpoint = ENDPOINT.fetch(:libraryDocument, base_uri)
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_mega_signs(token, base_uri) ⇒ Hash

Performs REST GET /mega_signs operation

Parameters:

  • token (String) —

    Auth Token

Returns:

  • (Hash) —

    MegaSigns response body



23
24
25
26
27
 
# File 'lib/echosign/mega_sign/request.rb', line 23

def self.get_mega_signs(token, base_uri)
  headers = { 'Access-Token' => token }
  response = get(ENDPOINT.fetch(:megaSign, base_uri), headers)
  JSON.parse(response.body)
end

.get_user(token, base_uri, user_id) ⇒ Hash

Gets all the users in an account that the caller has permissions to access.

Parameters:

  • token (String) —

    Auth Token

  • user_id (String)

Returns:

  • (Hash) —

    User info hash



117
118
119
120
121
122
 
# File 'lib/echosign/request.rb', line 117

def self.get_user(token, base_uri, user_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:user, base_uri)}/#{user_id}"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_users(token, base_uri, user_email) ⇒ Hash

Gets all the users in an account that the caller has permissions to access.

Parameters:

  • token (String) —

    Auth Token

  • user_email (String) —

    The email address of the user whose details are being requested.

Returns:

  • (Hash) —

    User info hash



105
106
107
108
109
110
 
# File 'lib/echosign/request.rb', line 105

def self.get_users(token, base_uri, user_email)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:user, base_uri)}?x-user-email=#{user_email}"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_widget(token, base_uri, widget_id) ⇒ Hash

Performs GET /widget operation

Parameters:

  • widget_id (String)

Returns:

  • (Hash) —

    Response body



62
63
64
65
66
67
 
# File 'lib/echosign/widget/request.rb', line 62

def self.get_widget(token, base_uri, widget_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}/#{widget_id}"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_widget_audit_trail(token, base_uri, widget_id) ⇒ Hash

Performs GET /widget/:id/auditTrail

Parameters:

  • widget_id (String)

Returns:

  • (Hash) —

    Response body



96
97
98
99
100
 
# File 'lib/echosign/widget/request.rb', line 96

def self.get_widget_audit_trail(token, base_uri, widget_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}/#{widget_id}/auditTrail"
  response = get(endpoint, headers)
end

.get_widget_document_file(token, base_uri, widget_id, document_id) ⇒ Hash

Performs GET /widget/:id/documents/:id operation

Parameters:

  • widget_id (String)

Returns:

  • (Hash) —

    Response body



86
87
88
89
90
 
# File 'lib/echosign/widget/request.rb', line 86

def self.get_widget_document_file(token, base_uri, widget_id, document_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}/#{widget_id}/documents/#{document_id}"
  response = get(endpoint, headers)
end

.get_widget_documents(token, base_uri, widget_id, version_id = nil, participant_email = nil) ⇒ Hash

Performs GET /widget/:id/documents operation

Parameters:

  • widget_id (String)

Returns:

  • (Hash) —

    Response body



73
74
75
76
77
78
79
80
 
# File 'lib/echosign/widget/request.rb', line 73

def self.get_widget_documents(token, base_uri, widget_id, version_id = nil, participant_email = nil)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}/#{widget_id}/documents"
  endpoint << add_query(endpoint, "versionId=#{version_id}") unless version_id.nil?
  endpoint << add_query(endpoint, "participantEmail=#{participant_email}") unless participant_email.nil?
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.get_widget_form_data(token, base_uri, widget_id) ⇒ Hash

Performs GET /widget/:id/formData

Parameters:

  • widget_id (String)

Returns:

  • (Hash) —

    Response body



106
107
108
109
110
 
# File 'lib/echosign/widget/request.rb', line 106

def self.get_widget_form_data(token, base_uri, widget_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}/#{widget_id}/formData"
  response = get(endpoint, headers)
end

.get_widgets(token, base_uri, user_id = nil, user_email = nil) ⇒ Hash

Performs GET /widgets operation

Parameters:

  • token (String) —

    Auth Token

  • user_id (String) (defaults to: nil)
  • user_email (String) (defaults to: nil)

Returns:

  • (Hash) —

    Response body



49
50
51
52
53
54
55
56
 
# File 'lib/echosign/widget/request.rb', line 49

def self.get_widgets(token, base_uri, user_id = nil, user_email = nil)
  headers = { 'Access-Token' => token }
  headers['X-User-Id'] = user_id unless user_id.nil?
  headers['X-User-Email'] = user_email unless user_email.nil?
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.library_combined_document(token, base_uri, library_document_id, auditReport) ⇒ String

Retrieves library combined document file

Parameters:

  • token (String) —

    Auth Token

  • library_document_id (String) —

    (REQUIRED)

Returns:

  • (String) —

    Raw library combined document file data



71
72
73
74
75
76
 
# File 'lib/echosign/library_documents/request.rb', line 71

def self.library_combined_document(token, base_uri, library_document_id, auditReport)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:libraryDocument, base_uri)}/#{library_document_id}/combinedDocument"
  endpoint << add_query(endpoint, "auditReport=#{auditReport}")
  response = get(endpoint, headers)
end

.library_document_audit_trail(token, base_uri, library_document_id) ⇒ String

Retrieves library document file data

Parameters:

  • token (String) —

    Auth Token

  • library_document_id (String) —

    (REQUIRED)

Returns:

  • (String) —

    Library document file data



60
61
62
63
64
 
# File 'lib/echosign/library_documents/request.rb', line 60

def self.library_document_audit_trail(token, base_uri, library_document_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:libraryDocument, base_uri)}/#{library_document_id}/auditTrail"
  response = get(endpoint, headers)
end

.mega_sign_combined_pdf(token, base_uri, mega_sign_id, versionId, participantEmail, attachSupportingDocuments, auditReport) ⇒ String

Gets a single combined PDF document for the documents associated with an mega_sign.

Parameters:

  • token (String) —

    Auth Token

  • mega_sign_id (String) —

    ID of mega_sign to retrieve info on.

Returns:

  • (String) —

    Raw bytes from document file



58
59
60
61
62
63
64
65
66
67
 
# File 'lib/echosign/mega_sign/request.rb', line 58

def self.mega_sign_combined_pdf(token, base_uri, mega_sign_id, versionId, participantEmail,
                                attachSupportingDocuments, auditReport)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:megaSign, base_uri)}/#{mega_sign_id}/combinedDocument"
  endpoint << add_query(endpoint, "versionId=#{versionId}") unless versionId.nil?
  endpoint << add_query(endpoint, "participantEmail=#{participantEmail}") unless participantEmail.nil?
  endpoint << add_query(endpoint, "attachSupportingDocuments=#{attachSupportingDocuments}")
  endpoint << add_query(endpoint, "auditReport=#{auditReport}")
  response = get(endpoint, headers)
end

.mega_sign_document_file(token, base_uri, mega_sign_id, document_id) ⇒ String

Retrieve mega_sign document PDF

Parameters:

  • token (String) —

    Auth Token

  • mega_sign_id (String) —

    ID of mega_sign to retrieve info on.

Returns:

  • (String) —

    Raw bytes from document file



85
86
87
88
89
 
# File 'lib/echosign/mega_sign/request.rb', line 85

def self.mega_sign_document_file(token, base_uri, mega_sign_id, document_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:megaSign, base_uri)}/#{mega_sign_id}/documents/#{document_id}"
  response = get(endpoint, headers)
end

.mega_sign_documents(token, base_uri, mega_sign_id, recipient_email = nil, format = nil, version_id = nil) ⇒ Hash

Performs REST GET /mega_sign/:id/documents

Parameters:

  • mega_sign_id (String) —

    (REQUIRED)

  • recipient_email (String) (defaults to: nil) —

    The email address of the participant to be used to retrieve documents. (REQUIRED)

  • format (String) (defaults to: nil) —

    Content format of the supported documents. It can have two possible values ORIGINAL or CONVERTED_PDF. (REQUIRED)

  • version_id (String) (defaults to: nil) —

    Version of the mega_sign as provided by mega_sign_info. If not provided, the latest version of the mega_sign is used.

Returns:

  • (Hash) —

    MegaSign documents response body



111
112
113
114
115
116
117
118
119
 
# File 'lib/echosign/mega_sign/request.rb', line 111

def self.mega_sign_documents(token, base_uri, mega_sign_id, recipient_email = nil, format = nil, version_id = nil)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:megaSign, base_uri)}/#{mega_sign_id}/documents"
  endpoint << add_query(endpoint, "versionId=#{version_id}") unless version_id.nil?
  endpoint << add_query(endpoint, "participantEmail=#{recipient_email}") unless version_id.nil?
  endpoint << add_query(endpoint, "supportingDocumentContentFormat=#{format}") unless format.nil?
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.mega_sign_form_data(token, base_uri, mega_sign_id) ⇒ String

Retrieves data entered by the user into interactive form fields at the time they signed the mega_sign

Parameters:

  • token (String) —

    Auth Token

  • mega_sign_id (String) —

    (REQUIRED)

Returns:

  • (String) —

    Raw bytes representing CSV file



74
75
76
77
78
 
# File 'lib/echosign/mega_sign/request.rb', line 74

def self.mega_sign_form_data(token, base_uri, mega_sign_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:megaSign, base_uri)}/#{mega_sign_id}/formData"
  response = get(endpoint, headers)
end

.mega_sign_info(token, base_uri, mega_sign_id) ⇒ Hash

Performs REST GET /mega_sign/:id operation

Parameters:

  • token (String) —

    Auth Token

  • mega_sign_id (String) —

    ID of mega_sign to retrieve info on.

Returns:

  • (Hash) —

    MegaSign info response body



34
35
36
37
38
39
 
# File 'lib/echosign/mega_sign/request.rb', line 34

def self.mega_sign_info(token, base_uri, mega_sign_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:megaSign, base_uri)}/#{mega_sign_id}"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.mega_sign_signing_urls(token, base_uri, mega_sign_id) ⇒ Hash

Performs REST GET /mega_sign/:id/signingUrls operation

Parameters:

  • token (String) —

    Auth Token

  • mega_sign_id (String) —

    ID of mega_sign to retrieve info on.

Returns:

  • (Hash) —

    URL information for the eSign page of the mega_sign



46
47
48
49
50
51
 
# File 'lib/echosign/mega_sign/request.rb', line 46

def self.mega_sign_signing_urls(token, base_uri, mega_sign_id)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:megaSign, base_uri)}/#{mega_sign_id}/signingUrls"
  response = get(endpoint, headers)
  JSON.parse(response.body)
end

.personalize_widget(token, base_uri, widget_id, personalization) ⇒ Hash

Performs REST PUT /agreement/:id operation

Parameters:

Returns:

  • (Hash) —

    Response body



23
24
25
26
27
28
 
# File 'lib/echosign/widget/request.rb', line 23

def self.personalize_widget(token, base_uri, widget_id, personalization)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}/#{widget_id}/personalize"
  response = put(endpoint, personalization.to_json, headers)
  JSON.parse(response.body)
end

.update_agreement_status(token, base_uri, agreement_id, request_body) ⇒ Hash

Performs REST PUT /agreement/:id operation

Parameters:

  • token (String) —

    Auth Token

  • agreement_id (String) —

    ID of agreement to retrieve info on.

  • request_body (Hash) —

    Hash for Agreement status update

Returns:

  • (Hash) —

    Agreements response body



128
129
130
131
132
133
 
# File 'lib/echosign/agreement/request.rb', line 128

def self.update_agreement_status(token, base_uri, agreement_id, request_body)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:agreement, base_uri)}/#{agreement_id}/status"
  response = put(endpoint, request_body.to_json, headers)
  JSON.parse(response.body)
end

.update_mega_sign_status(token, base_uri, mega_sign_id, request_body) ⇒ Hash

Performs REST PUT /mega_sign/:id operation

Parameters:

  • token (String) —

    Auth Token

  • mega_sign_id (String) —

    ID of mega_sign to retrieve info on.

  • request_body (Hash) —

    Hash for MegaSign status update

Returns:

  • (Hash) —

    MegaSigns response body



127
128
129
130
131
132
 
# File 'lib/echosign/mega_sign/request.rb', line 127

def self.update_mega_sign_status(token, base_uri, mega_sign_id, request_body)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:megaSign, base_uri)}/#{mega_sign_id}/status"
  response = put(endpoint, request_body.to_json, headers)
  JSON.parse(response.body)
end

.update_widget_status(token, base_uri, widget_id, status) ⇒ Hash

Performs REST PUT /agreement/:id operation

Parameters:

Returns:

  • (Hash) —

    Response body



36
37
38
39
40
41
 
# File 'lib/echosign/widget/request.rb', line 36

def self.update_widget_status(token, base_uri, widget_id, status)
  headers = { 'Access-Token' => token }
  endpoint = "#{ENDPOINT.fetch(:widget, base_uri)}/#{widget_id}/status"
  response = put(endpoint, status.to_json, headers)
  JSON.parse(response.body)
end