module Echosign::Request

Constants

BASE_PATH
BASE_URL
ENDPOINT

Public Class Methods

agreement_combined_pdf(token, base_uri, agreement_id, versionId, participantEmail, attachSupportingDocuments, auditReport) click to toggle source

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

@param token [String] Auth Token @param agreement_id [String] ID of agreement to retrieve info on. @return [String] Raw bytes from document file

# 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) click to toggle source

Retrieve agreement document PDF

@param token [String] Auth Token @param agreement_id [String] ID of agreement to retrieve info on. @return [String] Raw bytes from document file

# 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) click to toggle source

Performs REST GET /agreement/:id/documents

@param agreement_id [String] (REQUIRED) @param recipient_email [String] The email address of the participant to be used to retrieve documents. (REQUIRED) @param format [String] Content format of the supported documents. It can have two possible values ORIGINAL or

CONVERTED_PDF. (REQUIRED)

@param version_id [String] Version of the agreement as provided by {agreement_info agreement_info}. If not

provided, the latest version of the agreement is used.

@return [Hash] Agreement documents response body

# 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) click to toggle source

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

@param token [String] Auth Token @param agreement_id [String] (REQUIRED) @return [String] Raw bytes representing CSV file

# 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) click to toggle source

Performs REST GET /agreement/:id operation

@param token [String] Auth Token @param agreement_id [String] ID of agreement to retrieve info on. @return [Hash] Agreement info response body

# 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) click to toggle source

Performs REST GET /agreement/:id/signingUrls operation

@param token [String] Auth Token @param agreement_id [String] ID of agreement to retrieve info on. @return [Hash] URL information for the eSign page of the agreement

# 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, agreement_id) click to toggle source

Performs REST GET /agreement/:id/auditTrail operation

@param token [String] Auth Token @param agreement_id [String] ID of agreement to retrieve info on. @return [String] Raw bytes from audit pdf file

# 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) click to toggle source

Performs REST create_agreement operation

@param body [Hash] Request body (REQUIRED) @param token [String] Auth token (REQUIRED) @param user_id [String] Echosign user ID (REQUIRED) @param user_email [String] Echosign user email @return [Hash] Agreement response body

# 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) click to toggle source

Performs REST create_mega_sign operation

@param body [Hash] Request body (REQUIRED) @param token [String] Auth token (REQUIRED) @param user_id [String] Echosign user ID (REQUIRED) @param user_email [String] Echosign user email @return [Hash] MegaSign response body

# 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) click to toggle source

Sends a reminder for an agreement.

@param body [Hash] Valid request body @param token [String] Auth Token @return [Hash] Response body

# 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) click to toggle source

Performs REST create_transient_document operation

@param token [String] Auth token (REQUIRED) @param file_name [String] File name (REQUIRED) @param file_handle [File] File handle (REQUIRED) @param mime_type [String] Mime type @return [Hash] Transient Document Response Body

# 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) click to toggle source

Performs REST create_user operation

@param body [Hash] Valid request body @param token [String] Auth Token @return [Hash] New user response body

# 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) click to toggle source

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

the client

@param token [String] Auth token @param widget [Echosign::Widget] @return [Hash]

# 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) click to toggle source

Performs REST GET /agreements operation

@param token [String] Auth Token @return [Hash] Agreements response body

# 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) click to toggle source
# 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) click to toggle source

Retrieves library document metadata for a user.

@param token [String] Auth Token @param library_document_id [String] @return [Hash] Library document metadata

# 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) click to toggle source

Retrieves library document file data

@param token [String] Auth Token @param library_document_id [String] (REQUIRED) @param file_id [String] (REQUIRED) @return [String] Library document file data

# 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) click to toggle source

Retrieves library document file

@param token [String] Auth Token @param library_document_id [String] (REQUIRED) @return [Hash] Library document files metadata

# 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) click to toggle source

Retrieves library documents for a user.

@param token [String] Auth Token @param user_id [String] The ID of the user whose library documents are being requested. @param user_email [String] 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.

@return [Hash] Library documents metadata

# 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) click to toggle source

Performs REST GET /mega_signs operation

@param token [String] Auth Token @return [Hash] MegaSigns response body

# 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) click to toggle source

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

@param token [String] Auth Token @param user_id [String] @return [Hash] User info hash

# 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) click to toggle source

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

@param token [String] Auth Token @param user_email [String] The email address of the user whose details are being requested. @return [Hash] User info hash

# 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) click to toggle source

Performs GET /widget operation

@param widget_id [String] @return [Hash] Response body

# 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) click to toggle source

Performs GET /widget/:id/auditTrail

@param widget_id [String] @return [Hash] Response body

# 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) click to toggle source

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

@param widget_id [String] @return [Hash] Response body

# 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) click to toggle source

Performs GET /widget/:id/documents operation

@param widget_id [String] @return [Hash] Response body

# 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) click to toggle source

Performs GET /widget/:id/formData

@param widget_id [String] @return [Hash] Response body

# 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) click to toggle source

Performs GET /widgets operation

@param token [String] Auth Token @param user_id [String] @param user_email [String] @return [Hash] Response body

# 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) click to toggle source

Retrieves library combined document file

@param token [String] Auth Token @param library_document_id [String] (REQUIRED) @return [String] Raw library combined document file data

# 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) click to toggle source

Retrieves library document file data

@param token [String] Auth Token @param library_document_id [String] (REQUIRED) @return [String] Library document file data

# 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) click to toggle source

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

@param token [String] Auth Token @param mega_sign_id [String] ID of mega_sign to retrieve info on. @return [String] Raw bytes from document file

# 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) click to toggle source

Retrieve mega_sign document PDF

@param token [String] Auth Token @param mega_sign_id [String] ID of mega_sign to retrieve info on. @return [String] Raw bytes from document file

# 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) click to toggle source

Performs REST GET /mega_sign/:id/documents

@param mega_sign_id [String] (REQUIRED) @param recipient_email [String] The email address of the participant to be used to retrieve documents. (REQUIRED) @param format [String] Content format of the supported documents. It can have two possible values ORIGINAL or

CONVERTED_PDF. (REQUIRED)

@param version_id [String] Version of the mega_sign as provided by {mega_sign_info mega_sign_info}. If not

provided, the latest version of the mega_sign is used.

@return [Hash] MegaSign documents response body

# 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) click to toggle source

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

@param token [String] Auth Token @param mega_sign_id [String] (REQUIRED) @return [String] Raw bytes representing CSV file

# 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) click to toggle source

Performs REST GET /mega_sign/:id operation

@param token [String] Auth Token @param mega_sign_id [String] ID of mega_sign to retrieve info on. @return [Hash] MegaSign info response body

# 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) click to toggle source

Performs REST GET /mega_sign/:id/signingUrls operation

@param token [String] Auth Token @param mega_sign_id [String] ID of mega_sign to retrieve info on. @return [Hash] URL information for the eSign page of the mega_sign

# 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) click to toggle source

Performs REST PUT /agreement/:id operation

@param token [String] Auth Token @param widget_id [String] @param personalization [Echosign::WidgetPersonalization] @return [Hash] Response body

# 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) click to toggle source

Performs REST PUT /agreement/:id operation

@param token [String] Auth Token @param agreement_id [String] ID of agreement to retrieve info on. @param request_body [Hash] Hash for Agreement status update @return [Hash] Agreements response body

# 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) click to toggle source

Performs REST PUT /mega_sign/:id operation

@param token [String] Auth Token @param mega_sign_id [String] ID of mega_sign to retrieve info on. @param request_body [Hash] Hash for MegaSign status update @return [Hash] MegaSigns response body

# 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) click to toggle source

Performs REST PUT /agreement/:id operation

@param token [String] Auth Token @param widget_id [String] @param status [Echosign::WidgetStatus] @return [Hash] Response body

# 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

Private Class Methods

add_query(url, query) click to toggle source
# File lib/echosign/request.rb, line 168
def self.add_query(url, query)
  (url.include?('?') ? '&' : '?') + query
end
check_response(response) click to toggle source
# File lib/echosign/request.rb, line 179
def self.check_response(response)
  raise_error(response) unless response.success?
  response
end
get(endpoint, headers) click to toggle source
# File lib/echosign/request.rb, line 126
def self.get(endpoint, headers)
  # puts "[Echosign] #{endpoint}"
  begin
    response = HTTParty.get(
      endpoint,
      headers: headers
    )
  rescue Exception => error
    raise_error(error)
  end

  check_response(response)
end
post(endpoint, body, headers, options = {}) click to toggle source
# File lib/echosign/request.rb, line 140
def self.post(endpoint, body, headers, options = {})
  option = { json: false }.merge(options)
  # puts "[Echosign] #{endpoint}"
  # puts "[Echosign] #{body}"
  begin
    if options[:json]
      headers['Content-Type'] = 'application/json'
      body = body.to_json if body.is_a?(Hash)
    end
    response = HTTParty.post(endpoint, body: body, headers: headers)
  rescue Exception => error
    raise_error(error)
  end

  check_response(response)
end
put(endpoint, query, headers) click to toggle source
# File lib/echosign/request.rb, line 157
def self.put(endpoint, query, headers)
  begin
    headers['Content-Type'] = 'application/json'
    response = HTTParty.put(endpoint, body: query, headers: headers)
  rescue Exception => error
    raise_error(error)
  end

  check_response(response)
end
raise_error(error) click to toggle source
# File lib/echosign/request.rb, line 172
def self.raise_error(error)
  puts error
  message = "#{error.inspect}.  \nSee Adobe Echosign REST API documentation for Error code meanings: " \
    "https://secure.echosign.com/public/docs/restapi/v5"
  raise Failure.new message, error
end