corepro 0.0.4

data/lib/CorePro/Utils/requestor.rb

@@ -0,0 +1,89 @@
+require_relative '../version'
+require_relative 'logger'
+require_relative '../models/envelope'
+require_relative '../core_pro_api_exception'
+
+require 'openssl'
+require 'base64'
+require 'net/https'
+require 'uri'
+require 'json'
+
+module CorePro
+  module Utils
+    class Requestor
+
+      SDK_USER_AGENT = "CorePro Ruby SDK v #{CorePro::VERSION}"
+
+      def self.get(relativeUrl, classDef, connection, loggingObject)
+        url = "https://#{connection.domainName}/#{relativeUrl}"
+        http = Net::HTTP.new(connection.domainName, 443)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        headers = { 'User-Agent' => SDK_USER_AGENT,
+                  'Content-Type' => 'application/json; charset=utf-8',
+                  'Accept' => 'application/json; charset=utf-8',
+                  'Authorization' => connection.headerValue,
+                  'Host' => connection.domainName}
+        request = Net::HTTP::Get.new(url, headers)
+
+        response = http.request(request)
+
+        #Logger.write("hi mom", loggingObject)
+        parseResponse(request, response, classDef, connection, loggingObject)
+
+      end
+
+      def self.post(relativeUrl, classDef, toPost, connection, loggingObject)
+        uri = URI.parse("https://#{connection.domainName}/#{relativeUrl}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        headers = { 'User-Agent' => SDK_USER_AGENT,
+                    'Content-Type' => 'application/json; charset=utf-8',
+                    'Accept' => 'application/json; charset=utf-8',
+                    'Authorization' => connection.headerValue,
+                    'Host' => connection.domainName}
+        request = Net::HTTP::Post.new(uri.request_uri, headers)
+        request.body = toPost.to_json
+        response = http.request(request)
+
+        #Logger.write("hi mom", loggingObject)
+        parseResponse(request, response, classDef, connection, loggingObject)
+
+      end
+
+      def self.parseResponse(req, resp, classDef, conn, loggingObject)
+        case resp.code
+          when '501'
+            raise 501
+          when '502'
+            raise 502
+          when '503'
+            raise 503
+          when '504'
+            raise 504
+          when '505'
+            raise 505
+          else
+            envelope = CorePro::Models::Envelope.new
+            envelope.rawRequestBody = req.body
+            envelope.rawResponseBody = resp.body
+            parsedJson = JSON.parse(resp.body)
+            envelope.from_json! parsedJson, { 'data' => classDef }
+            if envelope.errors.length > 0
+              raise CorePro::CoreProApiException.new(envelope.errors)
+            else
+              if classDef == NIL
+                # no class definition given, return raw envelope
+                envelope
+              else
+                # class definition given, return just that data
+                envelope.data
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/CorePro/account.rb

@@ -0,0 +1,74 @@
+require_relative 'models/model_base'
+require_relative 'utils/requestor'
+require_relative 'models/account_id_only'
+require_relative 'connection'
+
+module CorePro
+  class Account < Models::ModelBase
+
+    attr_accessor :customerId
+    attr_accessor :accountId
+    attr_accessor :name
+    attr_accessor :accountNumber
+    attr_accessor :accountNumberMasked
+    attr_accessor :status
+    attr_accessor :type
+    attr_accessor :createdDate
+    attr_accessor :closedDate
+    attr_accessor :availableBalance
+    attr_accessor :accountBalance
+    attr_accessor :isPrimary
+    attr_accessor :isCloseable
+    attr_accessor :routingNumber
+    attr_accessor :targetAmount
+    attr_accessor :targetDate
+    attr_accessor :category
+    attr_accessor :subCategory
+    attr_accessor :tag
+    attr_accessor :miscellaneous
+    attr_accessor :recurringContributionType
+    attr_accessor :recurringContributionAmount
+    attr_accessor :recurringContributionFromExternalAccountId
+    attr_accessor :recurringContributionStartDate
+    attr_accessor :recurringContributionEndDate
+    attr_accessor :recurringContributionNextDate
+
+    def initialize()
+    end
+
+    def self.list(customerId, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/account/list/#{customerId}", Account, connection, loggingObject)
+    end
+
+    def self.get(customerId, accountId, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/account/get/#{customerId}/#{accountId}", Account, connection, loggingObject)
+    end
+
+    def self.getByTag(customerId, tag, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/account/getByTag/#{customerId}/#{tag}", Account, connection, loggingObject)
+    end
+
+    def create(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      aid = CorePro::Utils::Requestor.post('/account/create', CorePro::Models::AccountIdOnly, self, connection, loggingObject)
+      aid.accountId
+    end
+
+    def update(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/account/update', nil, self, connection, loggingObject)
+      true
+    end
+
+    def close(closeToAccountId, transactionTag, connection = nil, loggingObject = nil)
+      ac = CorePro::AccountClose.new
+      ac.closeToAccountId = closeToAccountId
+      ac.transactionTag = transactionTag
+      ac.close(connection, loggingObject)
+    end
+
+  end
+end

data/lib/CorePro/account_close.rb

@@ -0,0 +1,22 @@
+require_relative 'models/model_base'
+require_relative 'utils/requestor'
+
+module CorePro
+  class AccountClose < Models::ModelBase
+    attr_accessor :customerId
+    attr_accessor :accountId
+    attr_accessor :closeToAccountId
+    attr_accessor :transactionId
+    attr_accessor :transactionTag
+    attr_accessor :closingBalanceAmount
+    attr_accessor :interestPaidAmount
+    attr_accessor :backupWithholdingAmount
+    attr_accessor :totalClosingAmount
+    attr_accessor :isClosedToExternalAccount
+
+    def close(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/account/close', AccountClose, self, connection, loggingObject)
+    end
+  end
+end

data/lib/CorePro/connection.rb

@@ -0,0 +1,68 @@
+require 'base64'
+require 'yaml'
+
+module CorePro
+  class Connection
+
+    @@config = begin
+      YAML.load(File.open('config.yml'))
+    rescue ArgumentError => e
+      puts "Could not parse YAML: #{e.message}"
+    end
+
+    def self.createFromConfig(apiKey = nil, apiSecret = nil, domainName = nil)
+      c = Connection.new
+      c.apiKey = apiKey || @@config['CoreProApiKey']
+      c.apiSecret = apiSecret || @@config['CoreProApiSecret']
+      c.domainName = domainName || @@config['CoreProDomainName']
+      c
+    end
+
+    def initialize(apiKey = nil, apiSecret = nil, domainName = nil)
+      @apiKey = apiKey || @@config['CoreProApiKey']
+      @apiSecret = apiSecret || @@config['CoreProApiSecret']
+      @domainName = domainName || @@config['CoreProDomainName']
+      @headerValue = ''
+    end
+
+    def apiKey
+      @apiKey
+    end
+
+    def apiKey=(value)
+      @apiKey = value
+      @headerValue = ''
+    end
+
+    def apiSecret
+      @apiSecret
+    end
+
+    def apiSecret=(value)
+      @apiSecret = value
+      @headerValue = ''
+    end
+
+    def headerValue
+      if (@headerValue || '' == '')
+        utf8Value = "#{@apiKey}:#{@apiSecret}".force_encoding('iso-8859-1').encode('utf-8')
+        b64 = Base64.encode64(utf8Value)
+        @headerValue = "Basic #{b64}"
+      end
+      @headerValue
+    end
+
+    def domainName
+      @domainName
+    end
+
+    def domainName=(value)
+      value.gsub! 'https://', ''
+      value.gsub! 'http://', ''
+      value.gsub! 'www.', ''
+
+      @domainName = value.split('/')[0]
+    end
+
+  end
+end

data/lib/CorePro/core_pro_api_exception.rb

@@ -0,0 +1,21 @@
+module CorePro
+  class CoreProApiException < StandardError
+    def initialize(errors)
+      @errors = errors
+    end
+
+    attr_accessor :errors
+
+    def firstMessage
+      @errors[0].message
+    end
+
+    def firstCode
+      @errors[0].code
+    end
+
+    def to_s
+      "#{@errors[0]}. See errors collection for more information."
+    end
+  end
+end

data/lib/CorePro/customer.rb

@@ -0,0 +1,150 @@
+require_relative 'models/model_base'
+require_relative 'connection'
+require_relative 'models/customer_verify_request'
+require_relative 'models/customer_response'
+require_relative 'models/customer_id_only'
+require_relative 'models/customer_phone'
+require_relative 'models/customer_address'
+require_relative 'account'
+require_relative 'external_account'
+
+module CorePro
+  class Customer < Models::ModelBase
+
+    attr_accessor :customerCount
+    attr_accessor :customerId
+    attr_accessor :firstName
+    attr_accessor :middleName
+    attr_accessor :lastName
+    attr_accessor :birthDate
+    attr_accessor :gender
+    attr_accessor :culture
+    attr_accessor :tag
+    attr_accessor :status
+    attr_accessor :createdDate
+    attr_accessor :taxId
+    attr_accessor :driversLicenseNumber
+    attr_accessor :driversLicenseState
+    attr_accessor :driversLicenseExpirationDate
+    attr_accessor :passportNumber
+    attr_accessor :passportCountry
+    attr_accessor :emailAddress
+    attr_accessor :isActive
+    attr_accessor :isLocked
+    attr_accessor :lockedDate
+    attr_accessor :lockedReason
+    attr_accessor :isSubjectToBackupWithholding
+    attr_accessor :isOptedInToBankCommunication
+    attr_accessor :isDocumentsAccepted
+    attr_accessor :phones
+    attr_accessor :addresses
+    attr_accessor :deceasedDate
+    attr_accessor :accounts
+    attr_accessor :externalAccounts
+
+    def from_json! json, classDefs
+      classDefs = classDefs || {}
+      classDefs['phones'] = CorePro::Models::CustomerPhone
+      classDefs['addresses'] = CorePro::Models::CustomerAddress
+      classDefs['accounts'] = CorePro::Account
+      classDefs['externalAccounts'] = CorePro::ExternalAccount
+      super json, classDefs
+    end
+
+    def initialize()
+      @phones = []
+      @addresses = []
+      @accounts = []
+      @externalAccount = []
+    end
+
+    def self.list(pageNumber = 0, pageSize = 200, connection = nil, loggingObject = nil)
+      Customer.new.list pageNumber, pageSize, connection, loggingObject
+    end
+
+    def list(pageNumber = 0, pageSize = 200, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/customer/list?pageNumber=#{pageNumber}&pageSize=#{pageSize}", Customer, connection, loggingObject)
+    end
+
+    def self.get(customerId, connection = nil, loggingObject = nil)
+      c = Customer.new
+      c.customerId = customerId
+      c.get(connection, loggingObject)
+    end
+
+    def get(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/customer/get/#{self.customerId}", Customer, connection, loggingObject)
+    end
+
+    def self.getByTag(tag, connection = nil, loggingObject = nil)
+      c = Customer.new
+      c.tag = tag
+      c.getByTag(connection, loggingObject)
+    end
+
+    def getByTag(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/customer/getByTag/#{self.tag}", Customer, connection, loggingObject)
+    end
+
+    def self.search(tag = nil, taxId = nil, passportNumber = nil, driversLicenseNumber = nil, birthDate = nil, emailAddress = nil, lastName = nil, firstName = nil, pageNumber = 0, pageSize = 200, connection = nil, loggingObject = nil)
+      c = Customer.new
+      c.tag = tag
+      c.taxId = taxId
+      c.passportNumber = passportNumber
+      c.driversLicenseNumber = driversLicenseNumber
+      c.birthDate = birthDate
+      c.emailAddress = emailAddress
+      c.lastName = lastName
+      c.firstName = firstName
+      c.search(pageNumber, pageSize, connection, loggingObject)
+    end
+
+    def search(pageNumber = 0, pageSize = 200, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post("/customer/search?pageNumber=#{pageNumber}&pageSize=#{pageSize}", Customer, self, connection, loggingObject)
+    end
+
+    def create(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customer/create', Customer, self, connection, loggingObject)
+    end
+
+    def update(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customer/update', CorePro::Models::CustomerIdOnly, self, connection, loggingObject)
+    end
+
+    def self.deactivate(customerId, connection = nil, loggingObject = nil)
+      c = Customer.new
+      c.customerId = customerId
+      c.deactivate(connection, loggingObject)
+    end
+
+    def deactivate(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customer/deactivate', CorePro::Models::CustomerIdOnly, self, connection, loggingObject)
+    end
+
+    def initiate(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customer/initiate', CorePro::Models::CustomerResponse, self, connection, loggingObject)
+    end
+
+    def self.verify(verificationId, answers, connection = nil, loggingObject = nil)
+      cvr = CorePro::Models::CustomerVerifyRequest.new
+      cvr.verificationId = verificationId
+      cvr.answers = answers
+      cvr.verify connection, loggingObject
+    end
+
+    def verify(verificationId, answers, connection = nil, loggingObject = nil)
+      cvr = CorePro::Models::CustomerVerifyRequest.new
+      cvr.verificationId = verificationId
+      cvr.answers = answers
+      cvr.verify connection, loggingObject
+    end
+  end
+end

data/lib/CorePro/customer_beneficiary.rb

@@ -0,0 +1,55 @@
+require_relative 'models/model_base'
+
+module CorePro
+  class CustomerBeneficiary < Models::ModelBase
+
+    attr_accessor :customerId
+    attr_accessor :customerBeneficiaryId
+    attr_accessor :firstName
+    attr_accessor :lastName
+    attr_accessor :birthDate
+    attr_accessor :taxId
+    attr_accessor :taxIdMasked
+    attr_accessor :isActive
+
+    def self.list(customerId, connection = nil, loggingObject = nil)
+      cb = CustomerBeneficiary.new
+      cb.customerId = customerId
+      cb.list connection, loggingObject
+    end
+
+    def list(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/customerbeneficiary/list/#{self.customerId}", CustomerBeneficiary, connection, loggingObject)
+    end
+
+    def self.get(customerId, customerBeneficiaryId, connection = nil, loggingObject = nil)
+      cb = CustomerBeneficiary.new
+      cb.customerId = customerId
+      cb.customerBeneficiaryId = customerBeneficiaryId
+      cb.get connection, loggingObject
+    end
+
+    def get(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/customerbeneficiary/get/#{self.customerId}/#{self.customerBeneficiaryId}", CustomerBeneficiary, connection, loggingObject)
+    end
+
+    def create(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customerbeneficiary/create', CustomerBeneficiary, self, connection, loggingObject)
+    end
+
+    def update(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customerbeneficiary/update', CustomerBeneficiary, self, connection, loggingObject)
+    end
+
+    def deactivate(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customerbeneficiary/deactivate', CustomerBeneficiary, nil, connection, loggingObject)
+      true
+    end
+
+  end
+end

data/lib/CorePro/customer_document.rb

@@ -0,0 +1,34 @@
+require_relative 'models/mdoel_base'
+require_relative 'utils/requestor'
+require 'base64'
+
+module CorePro
+  class CustomerDocument < Models::ModelBase
+
+    attr_accessor :customerId
+    attr_accessor :documentType
+    attr_accessor :documentName
+    attr_accessor :documentContent
+    attr_accessor :reasonType
+
+    def self.upload(customerId, documentType, documentName, documentContent, reasonType, connection = nil, loggingObject = nil)
+      cd = CustomerDocument.new
+      cd.customerId = customerId
+      cd.documentType = documentType
+      cd.documentName = documentName
+      cd.documentContent = documentContent
+      cd.reasonType = reasonType
+      cd.upload connection, loggingObject
+    end
+
+    def upload(connection = nil, loggingObject = nil)
+      # NOTE: documentContent is assumed to be raw content bytes.
+      #       corepro API expects base64 encoded string. so we convert that here.
+      documentContent = Base64.encode64(documentContent)
+
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/customerdocument/upload', nil, self, connection, loggingObject)
+    end
+
+  end
+end

data/lib/CorePro/document.rb

@@ -0,0 +1,23 @@
+require_relative 'models/model_base'
+require_relative 'utils/requestor'
+module CorePro
+  class Document < Models::ModelBase
+
+    attr_accessor :bankId
+    attr_accessor :customerId
+    attr_accessor :documentId
+    attr_accessor :documentType
+    attr_accessor :culture
+    attr_accessor :html
+    attr_accessor :title
+    attr_accessor :downloadUrl
+    attr_accessor :effectiveDate
+    attr_accessor :expireDate
+
+    def self.list(cultureName, documentType = nil, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/document/list/#{cultureName}/#{documentType}", Document, connection, loggingObject)
+    end
+
+  end
+end

data/lib/CorePro/external_account.rb

@@ -0,0 +1,86 @@
+require_relative 'models/model_base'
+require_relative 'utils/requestor'
+require_relative 'models/external_account_id_only'
+require_relative 'models/external_account_verify'
+require_relative 'connection'
+
+module CorePro
+  class ExternalAccount < Models::ModelBase
+
+    attr_accessor :customerId
+    attr_accessor :externalAccountId
+    attr_accessor :name
+    attr_accessor :tag
+    attr_accessor :nickName
+    attr_accessor :firstName
+    attr_accessor :lastName
+    attr_accessor :type
+    attr_accessor :status
+    attr_accessor :statusDate
+    attr_accessor :routingNumber
+    attr_accessor :routingNumberMasked
+    attr_accessor :accountNumber
+    attr_accessor :accountNumberMasked
+    attr_accessor :nocCode
+    attr_accessor :isActive
+    attr_accessor :lockedDate
+    attr_accessor :lockedReason
+
+    def self.list(customerId, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/externalaccount/list/#{customerId}", ExternalAccount, connection, loggingObject)
+    end
+
+    def self.get(customerId, externalAccountId, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/externalaccount/get/#{customerId}/#{externalAccountId}", ExternalAccount, connection, loggingObject)
+    end
+
+    def self.getByTag(customerId, tag, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.get("/externalaccount/getByTag/#{customerId}/#{tag}", ExternalAccount, connection, loggingObject)
+    end
+
+    def create(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      eaid = CorePro::Utils::Requestor.post('/externalaccount/create', CorePro::Models::ExternalAccountIdOnly, self, connection, loggingObject)
+      eaid.externalAccountId
+    end
+
+    def initiate(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/externalaccount/initiate', CorePro::Models::ExternalAccountIdOnly, self, connection, loggingObject)
+    end
+
+    def self.verify(customerId, externalAccountId, amount1, amount2, connection = nil, loggingObject = nil)
+      ea = ExternalAccount.new
+      ea.customerId = customerId
+      ea.externalAccountId = externalAccountId
+      ea.verify(amount1, amount2, connection, loggingObject)
+    end
+
+    def verify(amount1, amount2, connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      eav = CorePro::Models::ExternalAccountVerify.new
+      eav.customerId = @customerId
+      eav.externalAccountId = @externalAccountId
+      eav.amount1 = @amount1
+      eav.amount2 = @amount2
+      CorePro::Utils::Requestor.post('/externalaccount/verify', eav, self, connection, loggingObject)
+      true
+    end
+
+    def update(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/externalaccount/update', nil, self, connection, loggingObject)
+      true
+    end
+
+    def deactivate(connection = nil, loggingObject = nil)
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/externalaccount/deactivate', nil, self, connection, loggingObject)
+      true
+    end
+
+  end
+end

data/lib/CorePro/external_account_document.rb

@@ -0,0 +1,36 @@
+require_relative 'Models/model_base'
+require_relative 'utils/requestor'
+require 'base64'
+
+module CorePro
+  class ExternalAccountDocument < Models::ModelBase
+
+    attr_accessor :customerId
+    attr_accessor :externalAccountId
+    attr_accessor :documentType
+    attr_accessor :documentName
+    attr_accessor :documentContent
+    attr_accessor :reasonType
+
+    def self.upload(customerId, externalAccountId, documentType, documentName, documentContent, reasonType, connection = nil, loggingObject = nil)
+      ead = ExternalAccountDocument.new
+      ead.customerId = customerId
+      ead.externalAccountId = externalAccountId
+      ead.documentType = documentType
+      ead.documentName = documentName
+      ead.documentContent = documentContent
+      ead.reasonType = reasonType
+      ead.upload connection, loggingObject
+    end
+
+    def upload(connection = nil, loggingObject = nil)
+      # NOTE: documentContent is assumed to be raw content bytes.
+      #       corepro API expects base64 encoded string. so we convert that here.
+      documentContent = Base64.encode64(documentContent)
+
+      connection ||= Connection.createFromConfig()
+      CorePro::Utils::Requestor.post('/externalaccountdocument/upload', nil, self, connection, loggingObject)
+    end
+
+  end
+end