docu_sign 0.0.3

data/lib/docu_sign/client.rb

@@ -0,0 +1,98 @@
+module DocuSign
+  class Client
+    attr_accessor :client
+
+    # A CA file used to verify certificates when connecting to Adyen.
+    #
+    # @see http://curl.haxx.se/ca/cacert.pem
+    CACERT = File.expand_path('../cacert.pem', __FILE__)
+
+    class << self
+      def login(options={})
+
+        client  = Savon::Client.new do |wsdl, http|
+          wsdl.document = File.expand_path("../../../wsdl/dsapi.wsdl", __FILE__)
+          wsdl.endpoint = options[:endpoint_url] if options[:endpoint_url]  
+          #http.auth.ssl.ca_cert_file = CACERT
+          http.auth.ssl.verify_mode = :none
+          http.open_timeout = 1200
+          http.read_timeout = 1200
+        end
+
+
+
+        if options[:integrator_key]
+          client.wsse.credentials "[#{options[:integrator_key]}]#{options[:username]}", options[:password]
+          client.http.headers["X-DocuSign-Authentication"] = "<DocuSignCredentials><Username>#{options[:username]}</Username><Password>#{options[:password]}</Password><IntegratorKey>#{options[:integrator_key]}</IntegratorKey></DocuSignCredentials>"
+        end
+
+        # if options[:integrators_key]
+        #           header = IntegratorsKeyAuthHeaderHandler.new(
+        #             :email           => options.delete(:email),
+        #             :integrators_key => options.delete(:integrators_key),
+        #             :password        => options.delete(:password)
+        #           )
+        #         else
+        #           header = AuthHeaderHandler.new(
+        #             :user_name => options.delete(:user_name),
+        #             :password  => options.delete(:password)
+        #           )
+        #         end
+        #
+        #         connection.headerhandler << header
+        #
+        #         options.each do |key, value|
+        #           connection.send("#{key}=", value)
+        #         end
+
+        client
+      end
+
+      def credentials(email, password, endpoint_url=nil)
+
+        connection = DocuSign::Credential::CredentialSoap.new
+        connection.endpoint_url = endpoint_url if endpoint_url
+
+        connection.login(:email => email, :password => password).login_result
+      end
+    end
+
+    def initialize(options={})
+      self.client = self.class.login(options)
+    end
+
+    def method_missing(api_method, *args, &block) # :nodoc:
+      if self.client.wsdl.soap_actions.include?(api_method)
+        begin
+          response = self.client.request(api_method) do
+            soap.body = (args.first.respond_to?(:to_savon) ? args.first.to_savon : convert_hash_keys(args.first)) if args.first
+          end
+          return DocuSignResponse.new(response)
+        rescue Savon::SOAP::Fault => e
+          raise DocuSign::Error.new(e)
+        end
+      else
+        super
+      end
+    end
+
+    private
+
+    def camelize_key(k)
+      k.to_s.gsub(/(^|_)(id)($|_)/){ $2.upcase }.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+
+    def convert_hash_keys(value)
+      case value
+      when Array
+        value.map { |v| convert_hash_keys(v) }
+        # or `value.map(&method(:convert_hash_keys))`
+      when Hash
+        Hash[value.map { |k, v| [camelize_key(k), convert_hash_keys(v)] }]
+      else
+        value
+      end
+    end
+
+  end
+end

data/lib/docu_sign/docu_sign_model.rb

@@ -0,0 +1,23 @@
+module DocuSign
+  class DocuSignModel
+    ATTRIBUTES = []
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+
+    def to_savon
+      {}
+    end
+
+    def method_missing(method, *args, &block)
+      if method =~ /(.+)\?$/
+        self.send($1).nil? ? nil : (self.send($1) == true ? "true" : "false")
+      else
+        super
+      end
+    end
+  end
+end

data/lib/docu_sign/docu_sign_response.rb

@@ -0,0 +1,33 @@
+module DocuSign
+
+  class DocuSignResponse
+
+    def self.new(*args)
+      response = args.first
+      case response.to_hash.keys.first.to_sym
+        when :create_and_send_envelope_response
+          return EnvelopeStatus.new(response.to_hash[:create_and_send_envelope_response][:create_and_send_envelope_result])
+        when :request_status_response
+          return EnvelopeStatus.new(response.to_hash[:request_status_response][:request_status_result])
+        when :request_status_ex_response
+          return EnvelopeStatus.new(response.to_hash[:request_status_ex_response][:request_status_ex_result])
+        when :request_statuses_response
+          #puts response.to_hash.inspect
+          return response.to_hash[:request_statuses_response][:request_statuses_result][:envelope_statuses][:envelope_status].map {|envelope_status_attributes| 
+            EnvelopeStatus.new(envelope_status_attributes)}
+        when :request_envelope_response
+          return Envelope.new(response.to_hash[:request_envelope_response][:request_envelope_result])
+        when :void_envelope_response
+          return VoidEnvelopeStatus.new(response.to_hash[:void_envelope_response][:void_envelope_result])
+        when :correct_and_resend_envelope_response
+          return nil
+        when :request_document_pd_fs_ex_response
+          return response.to_hash[:request_document_pd_fs_ex_response][:request_document_pd_fs_ex_result][:document_pdf].map {|document_pdf_attributes| DocumentPDF.new(document_pdf_attributes)}
+        else
+          puts response.to_hash.inspect
+          return response
+      end
+    end
+  end
+
+end

data/lib/docu_sign/document.rb

@@ -0,0 +1,57 @@
+module DocuSign
+  class Document < DocuSignModel
+    ATTRIBUTES = [:tabs, :id, :name, :pdf_bytes, :password, :transform_pdf_fields, :file_extension, :match_boxes,
+      :attachment_description]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+    attr_writer :tab_builder
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+
+    def tabs(recipient = nil, &block)
+      @tabs ||= DocuSign::ArrayOfTab.new
+
+      return @tabs unless block_given?
+
+      self.tab_builder = DocuSign::Builder::TabBuilder.new(self, recipient)
+
+      @tabs.tap do |a|
+        yield self if block_given?
+      end
+    end
+
+    def tab(options = {}, &block)
+      tab_builder.build(options, &block).tap do |t|
+        tabs << t
+      end
+    end
+
+    def tab_builder
+      @tab_builder ||= DocuSign::Builder::TabBuilder.new(self)
+    end
+
+    def to_savon
+      {
+        "ID" => self.id,
+        "Name" => self.name,
+        "PDFBytes" => self.pdf_bytes,
+        "Password" => self.password,
+        "TransformPdfFields" => self.transform_pdf_fields,
+        "FileExtension" => self.file_extension,
+        "MatchBoxes" => self.match_boxes,
+        "AttachmentDescription" => self.attachment_description
+      }.delete_if{|key, value| value.nil?}
+    end
+  end
+end
+
+# {http://www.docusign.net/API/3.0}ArrayOfDocument
+module DocuSign
+  class ArrayOfDocument < ::Array
+  end
+end

data/lib/docu_sign/document_pdf.rb

@@ -0,0 +1,14 @@
+module DocuSign
+  class DocumentPDF < DocuSignModel
+    ATTRIBUTES = [:name, :pdf_bytes, :document_id, :document_type]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+  end
+end

data/lib/docu_sign/document_status.rb

@@ -0,0 +1,15 @@
+module DocuSign
+
+  class DocumentStatus < DocuSignModel
+    ATTRIBUTES = [:id, :name, :template_name, :sequence]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+  end
+end

data/lib/docu_sign/envelope.rb

@@ -0,0 +1,136 @@
+module DocuSign
+  class Envelope < DocuSignModel
+    ATTRIBUTES = [:transaction_id, :asynchronous, :account_id, :documents, :recipients, :tabs, :subject, :email_blurb,
+      :signing_location, :custom_fields, :vaulting_options, :auto_navigation, :envelope_id_stamping,
+      :authoritative_copy, :notification, :envelope_attachment, :enforce_signer_visibility, :enable_wet_sign,
+      :allow_markup, :event_notification, :allow_reassign]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+    
+    attr_writer :document_builder
+    attr_writer :recipient_builder
+    attr_writer :tab_builder
+    attr_writer :notification_builder
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+
+    ##
+    # Documents
+    def documents(&block)
+      @documents ||= DocuSign::ArrayOfDocument.new
+
+      return @documents unless block_given?
+
+      self.document_builder = DocuSign::Builder::DocumentBuilder.new()
+
+      @documents.tap do |a|
+        yield self if block_given?
+      end
+    end
+
+    def document(options = {}, &block)
+      document_builder.build(options, &block).tap do |d|
+        documents << d
+      end
+    end
+
+    def document_builder
+      @document_builder ||= DocuSign::Builder::DocumentBuilder.new()
+    end
+
+    ##
+    # Recipients
+    def recipients(&block)
+      @recipients ||= DocuSign::ArrayOfRecipient.new
+
+      return @recipients unless block_given?
+
+      self.recipient_builder = DocuSign::Builder::RecipientBuilder.new()
+
+      @recipients.tap do |r|
+        yield self if block_given?
+      end
+    end
+
+    def recipient(options = {}, &block)
+      recipient_builder.build(options, &block).tap do |r|
+        recipients << r
+      end
+    end
+
+    def recipient_builder
+      @recipient_builder ||= DocuSign::Builder::RecipientBuilder.new()
+    end
+
+    ##
+    # Tabs
+    def tabs(recipient = nil, &block)
+      @tabs ||= DocuSign::ArrayOfTab.new
+
+      return @tabs unless block_given?
+
+      self.tab_builder = DocuSign::Builder::TabBuilder.new(nil, recipient)
+
+      @tabs.tap do |a|
+        yield self if block_given?
+      end
+    end
+
+    def tab(options = {}, &block)
+      tab_builder.build(options, &block).tap do |t|
+        tabs << t
+      end
+    end
+
+    def tab_builder
+      @tab_builder ||= DocuSign::Builder::TabBuilder.new(nil)
+    end
+
+    def notification(options = {}, &block)
+      @notification ||= notification_builder.build(options, &block)
+    end
+
+    def notification_builder
+      @notification_builder ||= DocuSign::Builder::NotificationBuilder.new
+    end
+
+    def to_savon
+      {"Envelope" => {
+        "TransactionID" => self.transaction_id,
+        "Asynchronous" => self.asynchronous?,
+        "AccountId" => self.account_id,
+        "Documents" => {
+          "Document" => self.documents.collect(&:to_savon)
+        },
+        "Recipients" => {
+          "Recipient" => self.recipients.collect(&:to_savon)
+        },
+        "Tabs" => {
+          "Tab" => self.tabs.collect(&:to_savon)
+        },
+        "Subject" => self.subject,
+        "EmailBlurb" => self.email_blurb,
+        "SigningLocation" => self.signing_location,
+        # TODO: CustomFields
+        # TODO: VaultingOptions
+        "AutoNavigation" => self.auto_navigation?,
+        "EnvelopeIDStamping" => self.envelope_id_stamping?,
+        "AuthoritativeCopy" => self.authoritative_copy?,
+        # TODO: EnvelopeAttachment
+        "Notification" => self.notification.try(:to_savon),
+        "EnforceSignerVisibility" => self.enforce_signer_visibility?,
+        "EnableWetSign" => self.enable_wet_sign?,
+        "AllowMarkup" => self.allow_markup?,
+        # TODO: EventNotification
+        "AllowReassign" => self.allow_reassign?
+      }.delete_if{|key, value| value.nil?}}
+    end
+
+  end
+
+end

data/lib/docu_sign/envelope_status.rb

@@ -0,0 +1,33 @@
+module DocuSign
+  class EnvelopeStatus < DocuSignModel
+    ATTRIBUTES = [:recipient_statuses, :time_generated, :envelope_id, :subject, :user_name, :email, :status, :created, :deleted, :sent, :delivered, :signed, :completed, :declined, :timed_out,
+      :ac_status, :ac_status_date, :ac_holder, :ac_holder_email, :ac_holder_location, :signing_location, :sender_ip_address, :envelope_pdf_hash, :custom_field, :vaulting_details, :envelope_stamping,
+      :authoritative_copy, :envelope_attachment, :document_statuses, :form_data]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+
+    def recipient_statuses=(status_attributes)
+      if status_attributes && status_attributes[:recipient_status].is_a?(Hash)
+        @recipient_statuses = [RecipientStatus.new(status_attributes[:recipient_status])]
+      elsif status_attributes && status_attributes[:recipient_status].is_a?(Array)
+        @recipient_statuses = status_attributes[:recipient_status].map{|attributes| DocuSign::RecipientStatus.new(attributes)}
+      end
+    end
+
+    def document_statuses=(status_attributes)
+      if status_attributes && status_attributes[:document_status].is_a?(Hash)
+        @document_statuses = [DocumentStatus.new(status_attributes[:document_status])]
+      elsif status_attributes && status_attributes[:document_status].is_a?(Array)
+        @document_statuses = status_attributes[:document_status].map{|attributes| DocuSign::DocumentStatus.new(attributes)}
+      end
+    end
+
+  end
+end

data/lib/docu_sign/error.rb

@@ -0,0 +1,7 @@
+module DocuSign
+
+  class Error < RuntimeError
+
+  end
+
+end

data/lib/docu_sign/extensions.rb

@@ -0,0 +1,81 @@
+class Module
+  def alias_attribute(new_name, old_name)
+    module_eval <<-STR, __FILE__, __LINE__ + 1
+      def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
+      def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
+      def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
+    STR
+  end
+end
+
+# AutoCamelize
+#
+# This module enables a class to automatically map
+# Ruby-esque snake_case method calls to the equivalent
+# camelCase calls. If a method with a camelCase equivalent
+# is found, we alias the snake_case method on the
+# class, to avoid tripping method_missing for the same
+# method in the future.
+module ConstEnhancements
+  def const_descendants
+    constants.reject { |c| c == 'Enumerator' }.inject([]) do |collection, constant|
+      c = const_get(constant)
+      collection << c
+
+      if [Module, Class].include?(c.class)
+        collection + c.const_descendants
+      else
+        collection
+      end
+    end
+  end
+end
+
+[Module, Class].each do |i|
+  i.send :include, ConstEnhancements
+end
+
+module AutoCamelize
+  def method_missing(method_name, *args, &block)
+    ds_name = ds_equivalent(method_name)
+
+    if ds_name && respond_to?(ds_name)
+      self.class.class_eval %Q{
+        def #{method_name}(*args, &block)
+          send "#{ds_name}", *args, &block
+        end
+      }
+
+      send method_name, *args, &block
+    else
+      super
+    end
+  end
+
+  # Find the equivalent built-in method name, if there is one.
+  # Example:
+  # ds_equivalent('pdf_bytes') => 'pDFBytes'
+
+  def ds_equivalent(string)
+    string = string.to_s.camelize(:lower)
+    methods.find { |m| m.downcase == string.downcase }
+  end
+end
+
+module AutoQuery
+  def method_missing(method_name, *args, &block)
+    string_name = method_name.to_s
+
+    if (string_name =~ /\?$/) && respond_to?(string_name.gsub(/\?/, ''))
+      self.class.class_eval %Q{
+        def #{string_name}(*args, &block)
+          !! (send "#{string_name.gsub(/\?/, '')}", *args, &block)
+        end
+      }
+
+      send method_name, *args, &block
+    else
+      super
+    end
+  end
+end

data/lib/docu_sign/notification.rb

@@ -0,0 +1,21 @@
+module DocuSign
+  class Notification < DocuSignModel
+    ATTRIBUTES = [:use_account_defaults, :reminders, :expirations]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+
+    def to_savon
+      { "UseAccountDefaults" => self.use_account_defaults?,
+        "Reminders" => (self.reminders.is_a?(Hash) ? {"ReminderEnabled" => self.reminders[:reminder_enabled], "ReminderDelay" => self.reminders[:reminder_delay], "ReminderFrequency" => self.reminders[:reminder_frequency]} : nil),
+        "Expirations" => (self.expirations.is_a?(Hash) ? {"ExpireEnabled" => self.expirations[:expire_enabled], "ExpireAfter" => self.expirations[:expire_after], "ExpireWarn" => self.expirations[:expire_warn]} : nil)
+      }.delete_if{|key, value| value.nil?}
+    end
+  end
+end

data/lib/docu_sign/railtie.rb

@@ -0,0 +1,7 @@
+require 'docu_sign'
+require 'rails'
+module DocuSign
+  class Railtie < Rails::Railtie
+
+  end
+end

data/lib/docu_sign/recipient.rb

@@ -0,0 +1,61 @@
+module DocuSign
+  class Recipient < DocuSignModel
+    ATTRIBUTES = [:id, :user_name, :signer_name, :email, :type, :access_code, :add_access_code_to_email,
+      :require_id_lookup, :id_check_configuration_name, :live_id_recipient_authentication,
+      :facebook_recipient_authentication, :linkedin_recipient_authentication, :google_recipient_authentication,
+      :salesforce_recipient_authentication, :twitter_recipient_authentication, :yahoo_recipient_authentication,
+      :open_id_recipient_authentication, :phone_authentication, :signature_info, :captive_info, :custom_fields,
+      :routing_order, :id_check_information_input, :auto_navigation, :recipient_attachment, :note, :role_name,
+      :template_locked, :template_required, :template_access_code_required, :default_recipient]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+
+    def to_savon
+      {
+        "ID" => self.id,
+        "UserName" => self.user_name,
+        "SignerName" => self.signer_name,
+        "Email" => self.email,
+        "Type" => self.type,
+        "AccessCode" => self.access_code,
+        "AddAccessCodeToEmail" => self.add_access_code_to_email,
+        "RequireIDLookup" => self.require_id_lookup,
+        "IDCheckConfigurationName" => self.id_check_configuration_name,
+        "LiveIDRecipientAuthentication" => self.live_id_recipient_authentication,
+        "FacebookRecipientAuthentication" => self.facebook_recipient_authentication,
+        "LinkedinRecipientAuthentication" => self.linkedin_recipient_authentication,
+        "GoogleRecipientAuthentication" => self.google_recipient_authentication,
+        "SalesforceRecipientAuthentication" => self.salesforce_recipient_authentication,
+        "TwitterRecipientAuthentication" => self.twitter_recipient_authentication,
+        "YahooRecipientAuthentication" => self.yahoo_recipient_authentication,
+        "OpenIDRecipientAuthentication" => self.open_id_recipient_authentication,
+        "PhoneAuthentication" => self.phone_authentication,
+        "SignatureInfo" => self.signature_info,
+        "CaptiveInfo" => self.captive_info,
+        # TODO: CustomFields
+        "RoutingOrder" => self.routing_order,
+        "IDCheckInformationInput" => self.id_check_information_input,
+        "AutoNavigation" => self.auto_navigation,
+        # TODO: RecipientAttachment
+        "Note" => self.note,
+        "RoleName" => self.role_name,
+        "TemplateLocked" => self.template_locked,
+        "TemplateRequired" => self.template_required,
+        "TemplateAccessCodeRequired" => self.template_access_code_required,
+        "DefaultRecipient" => self.default_recipient
+        # TODO: EmailNotification
+      }.delete_if{|key, value| value.nil?}
+    end
+  end
+
+  # {http://www.docusign.net/API/3.0}ArrayOfRecipient
+  class ArrayOfRecipient < ::Array
+  end
+end

data/lib/docu_sign/recipient_status.rb

@@ -0,0 +1,25 @@
+module DocuSign
+  class RecipientStatus < DocuSignModel
+    ATTRIBUTES = [:type, :email, :user_name, :routing_order, :sent, :delivered, :signed, :declined, :decline_reason,
+      :status, :recipient_ip_address, :client_user_id, :custom_field, :auto_navigation, :id_check_information,
+      :recipient_authentication_status, :tab_statuses, :recipient_attachment, :account_status,
+      :esign_agreement_information, :form_data, :recipient_id]
+    ATTRIBUTES.each do |attr|
+      self.send(:attr_accessor, attr)
+    end
+
+    def initialize(attributes = {})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attributes[attr])
+      end
+    end
+
+    def tab_statuses=(status_attributes)
+      if status_attributes && status_attributes[:tab_status].is_a?(Hash)
+        @tab_statuses = [DocuSign::TabStatus.new(status_attributes[:tab_status])]
+      elsif status_attributes && status_attributes[:tab_status].is_a?(Array)
+        @tab_statuses = status_attributes[:tab_status].map{|attributes| DocuSign::TabStatus.new(attributes)}
+      end
+    end
+  end
+end