responsys-api 0.0.3 → 0.0.4

data/lib/responsys/api/object/optional_data.rb

@@ -0,0 +1,23 @@
+module Responsys
+  module Api
+    module Object
+      class OptionalData
+        include Responsys::Exceptions
+        attr_accessor :name, :value
+
+        def initialize(name = "", value = "")
+          raise ParameterException, I18n.t("api.object.optional_data.incorrect_optional_data_type") unless (name.is_a? String) && (value.is_a? String)
+          @name = name
+          @value = value
+        end
+
+        def to_api
+          {
+            Name: @name,
+            Value: @value
+          }
+        end
+      end
+    end
+  end
+end

data/lib/responsys/api/object/query_column.rb

@@ -0,0 +1,23 @@
+module Responsys
+  module Api
+    module Object
+      class QueryColumn
+        include Responsys::Exceptions
+        attr_accessor :query_column_string
+        AVAILABLE_QUERY_COLUMN = %w(RIID CUSTOMER_ID EMAIL_ADDRESS MOBILE_NUMBER)
+
+        def initialize(query_column)
+          if AVAILABLE_QUERY_COLUMN.include? query_column
+            @query_column_string = query_column
+          else
+            raise ParameterException, I18n.t("api.object.query_column.incorrect_query_column")
+          end
+        end
+
+        def to_api
+          @query_column_string
+        end
+      end
+    end
+  end
+end

data/lib/responsys/api/object/recipient.rb

@@ -0,0 +1,30 @@
+module Responsys
+  module Api
+    module Object
+      class Recipient
+        include Responsys::Api::Object
+        attr_accessor :list_name, :recipient_id, :customer_id, :email_address, :mobile_number, :email_format
+
+        def initialize(options = {})
+          @list_name = options[:listName] || InteractObject.new("", "")
+          @recipient_id = options[:recipientId] || ""
+          @customer_id = options[:customerId] || ""
+          @email_address = options[:emailAddress] || ""
+          @mobile_number = options[:mobileNumber] || ""
+          @email_format = options[:emailFormat] || EmailFormat.new
+        end
+
+        def to_api
+          { 
+            listName: @list_name.to_api,
+            recipientId: @recipient_id.to_i,
+            customerId: @customer_id.to_s,
+            emailAddress: @email_address.to_s,
+            mobileNumber: @mobile_number.to_s,
+            emailFormat: @email_format.to_api
+          }
+        end
+      end
+    end
+  end
+end

data/lib/responsys/api/object/recipient_data.rb

@@ -0,0 +1,21 @@
+module Responsys
+  module Api
+    module Object
+      class RecipientData
+        attr_accessor :recipient, :optional_data
+
+        def initialize(recipient, optional_data = Responsys::Api::Object::OptionalData.new)
+          @recipient = recipient
+          @optional_data = optional_data
+        end
+
+        def to_api
+          {
+            recipient: @recipient.to_api,
+            optionalData: @optional_data.to_api
+          }
+        end
+      end
+    end
+  end
+end

data/lib/responsys/api/object/record.rb

@@ -0,0 +1,19 @@
+module Responsys
+  module Api
+    module Object
+      class Record
+        include Responsys::Exceptions
+        attr_accessor :field_values
+
+        def initialize(field_values)
+          raise ParameterException, I18n.t("api.object.record.incorrect_field_values_type") unless field_values.is_a? Array
+          @field_values = field_values
+        end
+
+        def to_api
+          { fieldValues: @field_values }
+        end
+      end
+    end
+  end
+end

data/lib/responsys/api/object/record_data.rb

@@ -0,0 +1,31 @@
+module Responsys
+  module Api
+    module Object
+      class RecordData
+        include Responsys::Exceptions
+        include Responsys::Api::Object
+        attr_accessor :field_names, :records
+
+        def initialize(data)
+          raise ParameterException, I18n.t("api.object.record_data.incorrect_record_data_type") unless data.is_a? Array
+
+          self.field_names = data.map { |record| record.keys }.flatten.uniq
+
+          new_data = []
+          field_names.each { |field_name|
+            data.each_with_index { |entity, index|
+              new_data[index] ||= Record.new([])
+              new_data[index].field_values << (entity.has_key?(field_name) ? entity[field_name.to_sym] : "")
+            }
+          }
+
+          self.records = new_data
+        end
+
+        def to_api
+          { fieldNames: field_names, records: records.map(&:to_api) }
+        end
+      end
+    end
+  end
+end

data/lib/responsys/api/session.rb

@@ -0,0 +1,30 @@
+module Responsys
+  module Api
+    module Session
+      def login
+        response = run("login", credentials)
+        establish_session_id(response)
+        establish_jsession_id(response)
+        set_session_credentials
+      end
+
+      def logout
+        api_method(:logout)
+      end
+
+      private
+
+      def establish_session_id(login_response)
+        @session_id = login_response.body[:login_response][:result][:session_id]
+      end
+
+      def establish_jsession_id(login_response)
+        @jsession_id = login_response.http.cookies[0]
+      end
+
+      def set_session_credentials
+        @header = { SessionHeader: { sessionId: session_id } }
+      end
+    end
+  end
+end

data/lib/responsys/api/table.rb

@@ -0,0 +1,49 @@
+module Responsys
+  module Api
+    module Table
+      def create_table(interact_object, fields)
+        api_method(:create_table, { table: interact_object.to_api, fields: fields.map(&:to_api) })
+      end
+
+      def create_table_with_pk(interact_object, fields, primary_keys)
+        api_method(:create_table_with_pk, { table: interact_object.to_api, fields: fields.map(&:to_api), primaryKeys: primary_keys })
+      end
+
+      def delete_table(interact_object)
+        api_method(:delete_table, { table: interact_object.to_api })
+      end
+
+      def merge_into_profile_extension(interact_object, record_data, match_column, insert_on_no_match = false, update_on_match = "REPLACE_ALL")
+        api_method(:merge_into_profile_extension, { profileExtension: interact_object.to_api, recordData: record_data.to_api, matchColumn: match_column, insertOnNoMatch: insert_on_no_match, updateOnMatch: update_on_match })
+      end
+
+      def retrieve_profile_extension_records(interact_object, query_column, field_list, ids_to_retrieve)
+        api_method(:retrieve_profile_extension_records, { profileExtension: interact_object.to_api, queryColumn: query_column.to_api, fieldList: field_list, idsToRetrieve: ids_to_retrieve })
+      end
+
+      def delete_profile_extension_members(interact_object, query_column, ids_to_delete)
+        api_method(:delete_profile_extension_members, { profileExtension: interact_object.to_api, queryColumn: query_column.to_api, idsToDelete: ids_to_delete })
+      end
+
+      def merge_table_records
+
+      end
+
+      def merge_table_records_with_pk
+
+      end
+
+      def delete_table_records
+
+      end
+
+      def retrieve_table_records
+
+      end
+
+      def truncate_table
+
+      end
+    end
+  end
+end

data/lib/responsys/configuration.rb

@@ -1,13 +1,13 @@
-class ResponsysApi
+module Responsys
   class Configuration
     attr_accessor :settings
-    # Put all these constants into a configurable setting hash
 
     def initialize
       @settings = {
         username: nil,
         password: nil,
-        wsdl: ""
+        wsdl: "",
+        debug: false
       }
     end
   end

data/lib/responsys/exceptions/all.rb

@@ -0,0 +1 @@
+require "responsys/exceptions/parameter_exception"

data/lib/responsys/exceptions/parameter_exception.rb

@@ -0,0 +1,7 @@
+module Responsys
+  module Exceptions
+    class ParameterException < Exception
+    end
+  end
+end
+

data/lib/responsys/helper.rb

@@ -1,7 +1,83 @@
-class ResponsysApi
+module Responsys
   module Helper
-    def self.format_response(response, action)
+    def self.format_response_result(response, action)
       response.body[("#{action}_response").to_sym][:result]
     end
+
+    def self.format_response_hash(response, action)
+      formatted_response = { status: "ok" }
+
+      return formatted_response unless response.body.has_key? "#{action}_response".to_sym
+
+      if response.body["#{action}_response".to_sym].has_key?(:result) and response.body["#{action}_response".to_sym][:result].is_a? Hash
+        formatted_response[:data] = handle_response_types(response.body["#{action}_response".to_sym])
+      elsif response.body["#{action}_response".to_sym].has_key?(:result)
+        formatted_response[:result] = response.body["#{action}_response".to_sym][:result]
+      elsif response.body["#{action}_response".to_sym].is_a? Hash and !response.body["#{action}_response".to_sym].empty?
+        formatted_response[:result] = response.body["#{action}_response".to_sym].values[0]
+      end
+
+      formatted_response
+    end
+
+    def self.format_record_data(record_data)
+      field_names = record_data[:field_names]
+      records = record_data[:records]
+
+      data = []
+      if records.is_a? Array
+        records.each do |record|
+          data << format_field_values(record, field_names)
+        end
+      else
+        data << format_field_values(records, field_names)
+      end
+
+      data
+    end
+
+    def self.format_field_values(record, field_names)
+      values = {}
+
+      if record.is_a? Hash and record[:field_values].is_a? Array
+        record[:field_values].each_with_index do |value, index|
+          values[field_names[index].to_sym] = value
+        end
+      elsif record.is_a? Hash
+          values[field_names.to_sym] = record[:field_values]
+      end
+
+      values
+    end
+
+    def self.handle_response_types(response_body)
+      data = []
+
+      if response_body[:result].has_key? :record_data
+        data = format_record_data(response_body[:result][:record_data])
+      else
+        data << response_body
+      end
+
+      data
+    end
+
+    def self.format_response_with_errors(error)
+      error_response = { status: "failure" }
+
+      if error.to_hash[:fault].has_key?(:detail) and !error.to_hash[:fault][:detail].nil?
+        key = error.to_hash[:fault][:detail].keys[0]
+        error_response[:error] = { http_status_code: error.http.code, code: error.to_hash[:fault][:detail][key][:exception_code], message: error.to_hash[:fault][:detail][key][:exception_message] }
+        error_response[:error][:trace] = error.to_hash[:fault][:detail][:source] if error.to_hash[:fault][:detail].has_key?(:source)
+      else
+        error_response[:error] = { http_status_code: error.http.code, code: error.to_hash[:fault][:faultcode], message: error.to_hash[:fault][:faultstring] }
+      end
+
+      error_response
+    end
+
+    def self.format_response_with_message(i18n_key)
+      { status: "failure", error: { http_status_code: "", code: i18n_key.split('.')[-1], message: I18n.t(i18n_key) } }
+    end
   end
 end

data/lib/responsys/i18n/en.yml

@@ -0,0 +1,20 @@
+en:
+  api:
+    object:
+      field_type:
+        incorrect_field_type: The field type string you provided is incorrect
+      query_column:
+        incorrect_query_column: The query column you provided is incorrect
+      record_data:
+        incorrect_record_data_type: The data you provided is not an array
+      optional_data:
+        incorrect_optional_data_type: The name and value need to be Strings
+      email_format:
+        incorrect_email_format: The email format is not supported
+      record:
+        incorrect_field_values_type: The field_values must be an array
+    campaign:
+      incorrect_recipients_type: Recipients parameter must be an array
+  member:
+    riid_missing: Variable riid is not provided to the member
+    record_not_found: The member has not been found in the list

data/lib/responsys/member.rb

@@ -0,0 +1,80 @@
+require "responsys/api/all"
+require "responsys/api/object/all"
+
+module Responsys
+  class Member
+    include Responsys::Api
+    include Responsys::Api::Object
+    attr_accessor :email, :user_riid
+
+    def initialize(email, riid = nil)
+      @email = email
+      @user_riid = riid
+      @client = Client.instance
+    end
+
+    def add_to_list(list, subscribe = false)
+      data = { EMAIL_ADDRESS_:  @email, EMAIL_PERMISSION_STATUS_: subscribe ? "I" : "O" }
+      record = RecordData.new([data])
+
+      @client.merge_list_members_riid(list, record, ListMergeRule.new(insertOnNoMatch: true, updateOnMatch: "NO_UPDATE"))
+    end
+
+    def retrieve_profile_extension(profile_extension, fields)
+      return Responsys::Helper.format_response_with_message("member.riid_missing") if @user_riid.nil?
+      return Responsys::Helper.format_response_with_message("member.record_not_found") unless present_in_profile?(profile_extension)
+
+      @client.retrieve_profile_extension_records(profile_extension, QueryColumn.new("RIID"), fields, [@user_riid])
+    end
+
+    def subscribe(list)
+      update(list, [{ EMAIL_ADDRESS_: @email, EMAIL_PERMISSION_STATUS_: "I" }])
+    end
+
+    def unsubscribe(list)
+      update(list, [{ EMAIL_ADDRESS_: @email, EMAIL_PERMISSION_STATUS_: "O" }])
+    end
+
+    def update(list, data)
+      return Responsys::Helper.format_response_with_message("member.record_not_found") unless present_in_list?(list)
+
+      record = RecordData.new(data)
+      @client.merge_list_members(list, record)
+    end
+
+    def present_in_profile?(list)
+      return Responsys::Helper.format_response_with_message("member.riid_missing") if @user_riid.nil?
+
+      response = lookup_profile_via_key(list, "RIID", @user_riid)
+
+      !(response[:status] == "failure" && response[:error][:code] == "RECORD_NOT_FOUND")
+    end
+
+    def present_in_list?(list)
+      if !@user_riid.nil?
+        response = lookup_list_via_key(list, "RIID", @user_riid)
+      else
+        response = lookup_list_via_key(list, "EMAIL_ADDRESS", @email)
+      end
+
+      !(response[:status] == "failure" && response[:error][:code] == "RECORD_NOT_FOUND")
+    end
+
+    def subscribed?(list)
+      return Responsys::Helper.format_response_with_message("member.record_not_found") unless present_in_list?(list)
+
+      response = @client.retrieve_list_members(list, QueryColumn.new("EMAIL_ADDRESS"), %w(EMAIL_PERMISSION_STATUS_), [@email])
+      response[:data][0][:EMAIL_PERMISSION_STATUS_] == "I"
+    end
+
+    private
+
+    def lookup_profile_via_key(profile_extension, key, value)
+      @client.retrieve_profile_extension_records(profile_extension, QueryColumn.new(key), %w(RIID_), [value])
+    end
+
+    def lookup_list_via_key(list, key, value)
+      @client.retrieve_list_members(list, QueryColumn.new(key), %w(EMAIL_PERMISSION_STATUS_), [value])
+    end
+  end
+end