your_membership 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e167609f71a1eb9be5e05117ef8baa58039ba2c9
+  data.tar.gz: 46cb16feb9c4cf28145a18b4ef23a2ebc8f79f4e
+SHA512:
+  metadata.gz: a9d00bfa496efd4a21c47bbc0a613f5fab98f245a3d87d3ca252837ebd9cdafc8fa5a4af2ca6a7c0a62e231d870833f55337ce00959fd8db22894523335063fb
+  data.tar.gz: c73d3f40ea5053b5dbebc54309be0bca063befcc2c6fa371007c393b8ff5840c166ad00969d40b6564fd5888c141a4deaac4265c0f9e1b2f9e37f4ae22ffd32d

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in your_membership.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 ECHO Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,261 @@
+YourMembership: Ruby SDK for the YourMembership.Com XML API
+===========================================
+
+_This SDK for Version 2.00 of the YourMembership.com API_
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'your_membership'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install your_membership
+
+## Usage
+
+Every effort has been made to expose the YourMembership.com API as transparently as possible while still providing a natively Ruby interface. 
+
+### Scope and Naming
+
+Everything is scoped under the `YourMembership` namespace.
+
+Methods are named according to the naming conventions used in the API mapped to appropriate Ruby conventions:
+
+	`Events.All.Search` becomes `YourMembership::Events.all_search`
+	`Member.Commerce.Store.GetOrderIDs` becomes `YourMembership::Member.commerce_store_getOrderIDs`
+	`Sa.Members.All.GetIDs` becomes `YourMembership::Sa::Members.all_getIDs`
+
+Note that the dot `.` notation has been converted to Ruby's preferred all-lowercase underscore "snake" `_` conventions, but that the method name camelCasing has been preserved for all characters other than the first.
+
+### Configuration
+
+You can configure the gem in one of two ways:
+
+#### YAML
+
+Pass a YAML file through `YourMembership.configure_with(YourFilename.YAML)`
+
+_Example YAML File_
+
+```YAML
+---
+# Configuration settings for YourWebsiteHere.com
+publicKey: 45G2E6DC-98NA-45W7-8493-D97C4E2C156A
+privateKey: D74H44B2-2348-4ACT-B531-45W385TGB966
+saPasscode: WPIkriJtqS4m
+baseUri: 'https://api.yourmembership.com'
+version: '2.00'
+```
+
+#### Configuration Hash
+
+Pass in one or more parameters through a hash of configuration keys
+
+_Example Configuration Hash_
+
+```RUBY
+YourMembership.configure :publicKey => 45G2E6DC-98NA-45W7-8493-D97C4E2C156A, :privateKey => D74H44B2-2348-4ACT-B531-45W385TGB966, :saPasscode => WPIkriJtqS4m
+```
+
+*Note that the baseUri and version are both defaulted to the current API for the release version.
+
+### Method Arguments and Returned Value Types
+
+#### Arguments
+
+Method arguments marked as required in the YourMembership.com API must are implemented as required arguments to the SDK methods in this pattern:
+
+`YourMembership::Namespace.some_methodName(sessionArgument, requiredArgument(s), optionsHash)`
+
+The `sessionArgument` is required for most method calls in the API, but is sometimes not required. The ::Sa:: (System Administrator) namespaced methods usually do not require a session.
+
+The options hash is present any time optional arguments can be passed to a method. These are sent as key-value pairs with the keys being `:symbol` objects named and cased in the way the API requires. For instance:
+
+`YourMembership::Events.all_search` takes one required argument (a session object/key) and up to three optional arguments passed as a hash.
+
+```RUBY
+session = YourMembership::Session.new
+options = {:SearchText => "A string to search for", :PageSize => 5, :StartRecord => 6}
+YourMembership::Events.all_search session, options
+```
+**Note:** _Arguments passed as symbols need to be capitalized in the way that the API expects them. Many Rubyists prefer camelCased symbols, but in the case of the SDK you'll need to provide first-letter-capitalized CamelCase arguments._
+
+You can pass strings as keys if you do not prefer to use Symbols.
+
+##### SDK-Specific Implementation of Argument Types
+
+You should use the standard Ruby types to represent data, for instance: 
+
+`:Timestamp` and other date or time arguments should be passed as DateTime objects rather than formatted strings, the formatting will be done for you.
+
+**A little added Syntactic Sugar:** Where a limited scope of static options is present some handy symbols have been added for convenience. For instance:
+
+`YourMembership::Member.commerce_store_getOrderIDs` takes an optional `:Timestamp` argument (which should be passed as a Ruby `DateTime` object) and an optional `:Status` argument. The `:Status` argument can either be an integer that represents a status as documented in the API or you can use a symbol that will automatically be mapped through a helper method. In this case you can pass `:open`, `:processed`, `:shipped`, `:closed`, or `:cancelled`.
+
+#### Returned Values
+
+The SDK translates the returned data into Ruby Objects of only a few types. Nearly all methods return an Array, this may be an Array of Strings or, more likely, it will be an Array of Hashes. 
+
+If only a single record can ever be retrieved at a time through a method a Hash object will be returned instead of an Array.
+
+In the case that multiple records could be returned, but no records are returned you should receive an empty Array.
+
+The return type you should expect is documented along with every method in the source.
+
+**Special Case:** The `YourMembership::Feeds.feed_get` method returns a Nokogiri::XML object
+
+--------------------------------------------------------------------------------
+
+### SDK Special Objects
+
+The SDK implements some representative objects that provide convenience.
+
+#### YourMembership::Session
+
+**Note:** *It is important to note that the Auth Namespace has been consumed by Sessions in the SDK as sessions and authentication are inextricably linked.*
+
+Session objects encapsulate the creation, storage, authentication, maintenance, and destruction of sessions in the YourMembership.com API.
+
+Sessions can be **generic** (unauthenticated), **authenticated**, or **abandoned**.
+
++ **Generic sessions** are used extensively whenever the scope of a specific user is not necessary.
++ **Authenticated sessions** are used when the called method requires the scope of a specific user.
++ **Abandoned sessions** are no longer usable and are essentially the same as logging out. A session can be forcibly abandoned and is automatically considered abandoned if it is not used for more than 20 minutes. If a session is needed for a length of more than 20 minutes the `ping` method can be called to extend the life-cycle for another 20 minutes.
+
+##### Examples:
+```RUBY
+# Generic (unauthenticated) Session
+session = YourMembership::Session.new
+
+# Authenticated Session
+auth_session = YourMembership::Session.new 'username', 'password'
+
+# Sessions can also be authenticated after creation in one of two ways:
+
+# By providing Credentials
+session.authenticate 'username', 'password'
+
+# Or through Token Authentication
+token = session.createToken
+```
+
+##### Additional Methods
+These additional methods report on the status of the session on the YourMembership.com server.
+
++ `.valid?` indicates if a session is still _alive_ and able to be used to make calls
++ `.authenticated?` indicates if a session is authenticated
+
+#### YourMembership::Member
+
+The Member object builds upon the Session object to more fully represent an authenticated session and provide an easy way to encapsulate the Member methods within the session's authenticated scope.
+
+##### Instantiation:
+```RUBY
+# Members can be created by authenticating directly with the YourMembership API,
+# the session is automatically created and bound to the Member instance. 
+member = YourMembership::Member.create_by_authentication 'username', 'password'
+
+# Members can also be created by passing in an already existing Session instance
+# this is especially useful when Sessions are authenticated through token
+# authentication.
+auth_session = YourMembership::Session.new 'username', 'password'
+member = YourMembership::Member.create_from_session auth_session
+```
+_Member objects can be created directly without a bound Session, but there is (as of yet) very little use for this._
+
+#### Making use of a Member Instance
+
+When a Member object is instantiated some basic properties of the represented member are cached in the object:
++ id - The member's API ID String
++ website_id - The member's unique identifier within your community
++ first_name
++ last_name
++ email
+
+These fields are useful in reducing the number of round trips to the API for some commonly used attributes, but the real benefit of the Member instance is to be able to access all of the Member namespaced methods within the scope of the member.
+
+Any method in the Member Namespace can be called like these examples:
+```RUBY
+member = YourMembership::Member.create_by_authentication 'username', 'password'
+
+profile = member.profile_get
+sent_messages = member.messages_getSent
+...
+order = member.commerce_store_order_get member.commerce_store_getOrderIDs[0]
+```
+**NOTE:** *Of course all of the methods of the Member namespace can be called without a Member instance, but an authorized session will need to be passed as the first argument.*
+
+##### Member Session Management:
+
+The Member instance's bound Session instance is accessible as an attribute.
+
+#### YourMembership::Profile
+
+The Profile object provides a convenient abstraction that encapsulates a person's profile allowing clear and concise access to both the core fields provided by YourMembership and the custom fields added by site administrators.
+
+The API has some required fields for new members so a specific method (Profile.create_new) exists for the convenience of quickly creating a new profile for a new person.
+
+A profile can be loaded by passing a hash directly to the initializer (Profile.new) method. This can be useful in creating a profile object from an API response. This is how profile objects are created internally through the YourMembership::Member.profile_get, YourMembership::People.profile_get, and YourMembership::Sa::People.profile_get methods.
+
+A profile can be created empty or by passing a hash for standard fields. This is useful for updating an existing profile without changing unnecessary records.
+
+An *outdated* list of standard fields can be found here: https://api.yourmembership.com/reference/YM_API_Member_Field_Documentation.pdf
+
+##### Data Access
++ **Profile#data** `Hash` This internal hash can be read and written to and should contain only fields that are standard in the YourMembership system.
++ **Profile#custom_data** `Hash` This internal hash can be read and written to and should contain the fields that are specified as custom responses in a specific YourMembership community. 
++ **Profile#to_h** `Hash` is a read-only method for returning a single nested hash of both standard and custom fields.
+
+#### YourMembership::Export
+
+Export objects are returned when any YourMembership::Sa::Export method is called. This provides an easy way to keep track of the status of the export request. Export requests are handled asynchronously and therefore should be polled until the results are ready.
+
+The Export object provides the Export#status method. It is necessary to call the Export#status method at least once in the export objects lifecycle as the export_uri will not be made available until status is called.
+
+**Example:**
+
+```RUBY
+donations = YourMembership::Sa::Export.donations_transactions(DateTime.now, True)
+
+# Implement a loop to check status
+
+case donations.status
+when :failure, :error
+	# Stop looping, the process failed
+when :unknown, :working
+	# Continue looping
+when :complete
+	# Export is ready
+	donations.export_uri
+end
+``` 
+
+## About The Author(s)
+
+![ECHO Inc.](http://static.squarespace.com/static/516da119e4b00686219e2473/t/51e95357e4b0db0cdaadcb4d/1407936664333/?format=1500w)
+
+This library is an open-source project built by ECHO, an international nonprofit working to help those who are teaching farmers around the world know how to be more effective in producing enough to meet the needs of their families and their communities. ECHO is an information hub for international development practitioners specifically focused on sustainable, small-scale, agriculture. Through educational programs, publications, and networking ECHO is sharing solutions from around the world that are solving hunger problems.
+
+Charity Navigator ranks ECHO as the #1 International Charity in the state of Florida (where their US operations are based) and among the top 100 in the US.
+
+Thanks to grants and donations from people like you, ECHO is able to connect trainers and farmers with valuable (and often hard-to-find) resources. One of ECHO's greatest resources is the network of development practitioners, around the globe, that share help and specialized knowledge with each other. ECHO uses the YourMembership product to help facilitate these connections.
+
+To find out more about ECHO, or to help with the work that is being done worldwide please visit http://www.echonet.org
+
+## Contributing
+
+If you find a problem with this library or would like to contribute an improvement please fork and submit a pull request.
+
+If you're a developer that would like to help solve world hunger problems with some of your spare time, we are always looking for talented volunteers. Contact Nate Flood by email: nate [at] echonet [dot] org
+
+1. Fork it ( https://github.com/ECHOInternational/your_membership/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/httparty/patch.rb

@@ -0,0 +1,33 @@
+require 'cgi'
+
+# Monkey Patch for the HTTParty Gem
+module HTTParty
+  # In order to parse the HTML encoded documents returned by the YourMembership
+  # API we need to HTML decode the <![CDATA[ tags. This is a bug workaround.
+  class Request
+    # This is the encode_body method from HTTParty's Request Class adding an additional method call to fix
+    # the CDATA elements that are improperly formatted in the YourMembership API's XML. This is done here to ensure that
+    # the fix is in place before the data is parsed.
+    def encode_body(body)
+      body = fix_cdata body
+      if ''.respond_to?(:encoding)
+        _encode_body(body)
+      else
+        body
+      end
+    end
+
+    # Bug Fix for HTML encoded < and > in XML body.
+    # @param body [String] an XML document that needs to be checked for this specific issue.
+    # @return [String] If the HTML encoding issue is found it is repaired and the document is returned.
+    def fix_cdata(body)
+      # <![CDATA[ = &lt;![CDATA[
+      # ]]> =  ]]&gt;
+      if body.include? '&lt;![CDATA['
+        body.gsub! '&lt;![CDATA[', '<![CDATA['
+        body.gsub! ']]&gt', ']]>'
+      end
+      body
+    end
+  end
+end

data/lib/your_membership/base.rb

@@ -0,0 +1,197 @@
+module YourMembership
+  # Base Class inherited by all Your Membership SDK Classes.
+  class Base
+    include HTTParty
+
+    base_uri YourMembership.config[:baseUri]
+
+    # rubocop:disable Style/ClassVars
+
+    # Call IDs are usually tied to sessions, this is a unique call id for use whenever a session is not needed.
+    @@genericCallID = nil
+
+    # @return [Integer] Auto Increments ad returns the genericCallID as required by the YourMembership.com API
+    def self.new_call_id
+      if @@genericCallID.nil?
+        # We start with a very high number to avoid conflicts when initiating a new session.
+        @@genericCallID = 10_000
+      else
+        @@genericCallID += 1
+      end
+      @@genericCallID
+    end
+    # rubocop:enable Style/ClassVars
+
+    # A Guard Method that returns true if the response from the API can be processed and raises an exception if not.
+    # @param [Hash] response
+    # @return [Boolean] true if no errors found.
+    # @raise [HTTParty::ResponseError] if a communication error is found.
+    def self.response_valid?(response)
+      if response.success?
+        !response_ym_error?(response)
+      else
+        raise HTTParty::ResponseError.new(response), 'Connection to YourMembership API failed.'
+      end
+    end
+
+    # Checks for error codes in the API response and raises an exception if an error is found.
+    # @param [Hash] response
+    # @return [Boolean] false if no error is found
+    # @raise [YourMembership::Error] if an error is found
+    def self.response_ym_error?(response)
+      if response['YourMembership_Response']['ErrCode'] != '0'
+        raise YourMembership::Error.new(
+          response['YourMembership_Response']['ErrCode'],
+          response['YourMembership_Response']['ErrDesc']
+        )
+      else
+        return false
+      end
+    end
+
+    # Creates an XML string to send to the API
+    # @todo THIS SHOULD BE MARKED PRIVATE and refactored to DRY up the calls.
+    def self.build_XML_request(callMethod, session = nil, params = {}) # rubocop:disable Style/MethodLength, Style/MethodName
+      builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        # Root Node Is always <YourMembership>
+        xml.YourMembership do
+          # API Version
+          xml.Version_ YourMembership.config[:version]
+
+          # API Key: For System Administrative tasks it is the private key and
+          # passcode, for all others it is the public key
+          if callMethod.downcase.start_with?('sa.')
+            xml.ApiKey_ YourMembership.config[:privateKey]
+            xml.SaPasscode_ YourMembership.config[:saPasscode]
+          else
+            xml.ApiKey_ YourMembership.config[:publicKey]
+          end
+
+          # Pass Session ID and Session Call ID unless there is no session, then
+          # send call id from class
+          if session
+            if session.is_a? YourMembership::Session
+              xml.SessionID_ session.session_id
+            else
+              xml.SessionID_ session
+            end
+            xml.CallID_ session.call_id
+          else
+            xml.CallID_ new_call_id
+          end
+
+          xml.Call(:Method => callMethod) do
+            params.each do |key, value|
+              xml_process(key, value, xml)
+            end
+          end
+        end
+      end
+
+      builder.to_xml
+    end
+
+    # This is a helper method to always return an array (potentially empty) of responses (Hashes) for methods that can
+    # have multiple results. The default behavior of the API is to return a nil if no records are found, a hash if one
+    # record is found and an array if multiple records are found.
+    #
+    # @param [Hash] response_body This is the nodeset that returns nil if an empty data set is returned.
+    # @param [Array] keys This is a list of keys, in order that are nested inside the response body, these keys will be
+    #  traversed in order before retrieving the data associated with the last key in the array
+    # @return [Array] A single dimension array of hashes.
+    def self.response_to_array_of_hashes(response_body, keys = [])
+      return_array = []
+      if  response_body
+        # http://stackoverflow.com/questions/13259181/what-is-the-most-ruby-ish-way-of-accessing-nested-hash-values-at-arbitrary-depth
+        response_body_items = keys.reduce(response_body) { |h, key| h[key] }
+        if response_body_items.class == Array
+          response_body_items.each do |response_item|
+            return_array.push response_item
+          end
+        else
+          return_array.push response_body_items
+        end
+      end
+      return_array
+    end
+
+    # Converts the desired portion of the XML response to a single dimension array.
+    # This is useful when you don't have a need for key, value pairs and want a clean array of values to work with.
+    #
+    # @param [Hash] response_body This is the nodeset that returns nil if an empty data set is returned.
+    # @param [Array] keys This is a list of keys, in order that are nested inside the response body, these keys will be
+    #  traversed in order before retrieving the data associated with the key_for_array
+    # @param [String] key_for_array this is the key that represents the list of items you want to turn into an array.
+    # @return [Array] A single dimension array of values.
+    def self.response_to_array(response_body, keys = [], key_for_array)
+      return_array = []
+      response_hash_array = response_to_array_of_hashes(response_body, keys)
+      response_hash_array.each do |item|
+        return_array.push item[key_for_array]
+      end
+      return_array
+    end
+
+    private
+
+    # Convenience method to convert Ruby DateTime objects into ODBC canonical strings as are expected by the API
+    # @param [DateTime] dateTime
+    # @return [String] An ODBC canonical string representation of a date as is expected by the API
+    def self.format_date_string(dateTime)
+      dateTime.strftime('%Y-%m-%d %H:%M:%S')
+    end
+
+    def self.xml_process(key, value, xml)
+      case value
+      when Array
+        xml_process_array(key, value, xml)
+      when Hash
+        xml_process_hash(key, value, xml)
+      when YourMembership::Profile
+        xml_process_profile(value, xml)
+      when DateTime
+        xml.send(key, format_date_string(value))
+      else
+        xml.send(key, value)
+      end
+    end
+
+    def self.xml_process_profile(profile, xml)
+      profile.data.each do |k, v|
+        xml_process(k, v, xml)
+      end
+      xml.send('CustomFieldResponses') do
+        profile.custom_data.each do |k, v|
+          xml_process_custom_field_responses(k, v, xml)
+        end
+      end
+    end
+
+    def self.xml_process_hash(key, value, xml)
+      xml.send(key) do
+        value.each { |k, v| xml_process(k, v, xml) }
+      end
+    end
+
+    def self.xml_process_array(key, value, xml)
+      xml.send(key) do
+        value.each { |tag| xml.send(tag[0], tag[1]) }
+      end
+    end
+
+    def self.xml_process_custom_field_responses(key, value, xml)
+      xml.send('CustomFieldResponse', :FieldCode => key) do
+        xml.send('Values') do
+          case value
+          when Array
+            value.each do | item |
+              xml.send('Value', item)
+            end
+          else
+            xml.send('Value', value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/your_membership/commerce.rb

@@ -0,0 +1,25 @@
+module YourMembership
+  # The Commerce Namespace does not currently have any methods in the
+  # YourMembership.com API. This is used for some helper methods.
+  class Commerce
+    # Converts some convenient Symbols to the Integer that the YourMembership API expects
+    # @param [Symbol] status Accepts :cancelled, :open, :processed, :shipped
+    # @return [Integer] Returns the integer that the API expects
+    def self.convert_order_status(status)
+      status_code = 0
+      case status
+      when :cancelled, :Cancelled
+        status_code = -1
+      when :open, :Open
+        status_code = 0
+      when :processed, :Processed
+        status_code = 1
+      when :shipped, :Shipped, :closed, :Closed
+        status_code = 2
+      else
+        status_code = status
+      end
+      status_code
+    end
+  end
+end

data/lib/your_membership/config.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+module YourMembership
+  # Configuration defaults
+  @config = {
+    :publicKey => '',
+    :privateKey => '',
+    :saPasscode => '',
+    :baseUri => 'https://api.yourmembership.com',
+    :version => '2.00'
+  }
+
+  @valid_config_keys = @config.keys
+
+  # Configure through hash
+  # @example
+  #  YourMembership.configure(:publicKey => 45G2E6DC-98NA-45W7-8493-D97C4E2C156A,
+  #  :privateKey => D74H44B2-2348-4ACT-B531-45W385TGB966, :saPasscode => WPIkriJtqS4m)
+  # @note The baseUri and version are both defaulted to the current API for the release version.
+  def self.configure(opts = {})
+    opts.each { |k, v| @config[k.to_sym] = v if @valid_config_keys.include? k.to_sym }
+  end
+
+  # Configure through yaml file
+  # @example
+  #  ---
+  #  publicKey: 45G2E6DC-98NA-45W7-8493-D97C4E2C156A
+  #  privateKey: D74H44B2-2348-4ACT-B531-45W385TGB966
+  #  saPasscode: WPIkriJtqS4m
+  #  baseUri: 'https://api.yourmembership.com'
+  #  version: '2.00'
+  # @note The baseUri and version are both defaulted to the current API for the release version.
+  def self.configure_with(path_to_yaml_file)
+    config = YAML.load(IO.read(path_to_yaml_file))
+    configure(config)
+  end
+
+  # Access configuration variables by calling YourMembership.config[ :attribute ]
+  def self.config # rubocop:disable Style/TrivialAccessors
+    @config
+  end
+end

data/lib/your_membership/convert.rb

@@ -0,0 +1,24 @@
+module YourMembership
+  # YourMembership Convert Namespace
+  class Convert < YourMembership::Base
+    # Converts the given local time to current Eastern Time, factoring in adjustments for Daylight Savings Time.
+    # @see https://api.yourmembership.com/reference/2_00/Convert_ToEasternTime.htm
+    #
+    # @param [YourMembership::Session] session
+    # @param [DateTime] localTime A DateTime that you want to convert to US/Eastern Time
+    # @param [Integer] localGMTBias The Number of hours the local time zone is away from GMT
+    # @return [Hash] Returns an Hash with 'Converted' and 'ServerGmtBias'
+    # @note This is probably not necessary as Ruby will happily convert dates.
+    def self.ToEasternTime(session, localTime, localGMTBias) # rubocop:disable Style/MethodName
+      options = {}
+      options[:LocalTime] = format_date_string localTime
+      options[:LocalGmtBias] = localGMTBias
+
+      response = post('/', :body => build_XML_request('Convert.ToEasternTime', session, options))
+
+      if response_valid? response
+        response['YourMembership_Response']['Convert.ToEasternTime']
+      end
+    end
+  end
+end

data/lib/your_membership/error.rb

@@ -0,0 +1,21 @@
+module YourMembership
+  # Custom exception for YourMembership error codes.
+  # @attr [Integer] error_code The Error Code
+  # @attr [String] error_description A Description of what the error means.
+  class Error < StandardError
+    attr_accessor :error_code, :error_description
+
+    # @param [Integer] error_code The Error Code
+    # @param [String] error_description A Description of what the error means.
+    # @see https://api.yourmembership.com/reference/2_00/Error_Codes.htm
+    def initialize(error_code, error_description)
+      self.error_code = error_code
+      self.error_description = error_description
+    end
+
+    # @return [String] A highly readable error message.
+    def to_s
+      "Your Membership Returned An Error Code: #{error_code} With Message: #{error_description}"
+    end
+  end
+end