biro 0.2.0

data/lib/biro/gateways/bvs/request.rb

@@ -0,0 +1,71 @@
+require 'rest_client'
+
+module Biro
+  module Bvs
+    class Request < BaseRequest
+      def production_url
+        "https://bvsntt.bvsnet.com.br/cgi-bin/db2www/netpo028.mbr/string?consulta="
+      end
+
+      def development_url
+        "http://localhost:8900/"
+      end
+
+      def required_params
+        [:username, :password]
+      end
+
+      def find(document, options = {})
+        bvs_results = {}
+        bvs_results[:score] = score(document) if options.keys.include?(:score)
+        bvs_results[:debits] = debits(document) if options.keys.include?(:debits)
+
+        get_response(bvs_results)
+      end
+
+      private
+
+      def get_response(result)
+        response = Response.new result
+
+        raise DocumentNotFoundError.new("BVS Error: Document not found - SCORE: #{response.score_error_message} - DEBITS: #{response.debits_error_message}" ) if auth_error?(response)
+        raise AuthenticationError.new("BVS Error: Invalid user or password - SCORE: #{response.score_error_message} - DEBITS: #{response.debits_error_message}" ) if document_error?(response)
+        raise StandardError.new("Error at BVS Request: SCORE: #{response.score_error_message} - DEBITS: #{response.debits_error_message}" ) unless response.score_error_message.blank? && response.debits_error_message.blank?
+
+        response
+      end
+
+      def document_error?(response)
+        response.score_error_message == "SENHA INVALIDA" || response.debits_error_message == "SENHA INVALIDA"
+      end
+
+      def auth_error?(response)
+        response.score_error_message == "DOCUMENTO INVALIDO" || response.debits_error_message == "DOCUMENTO INVALIDO"
+      end
+
+      def score(document)
+        params = ScoreRequestBuilder.new(document, @username, @password).build
+
+        begin
+          response = RestClient::Request.execute(url: url + URI.encode(params), method: :get, verify_ssl: false)
+          return response
+        rescue => e
+          Biro.log(:warn, "Unable to process BVS score request")
+          raise StandardError.new("Error at BVS score request: #{e.message}")
+        end
+      end
+
+      def debits(document)
+        params = DebitsRequestBuilder.new(document, @username, @password).build
+
+        begin
+          response = RestClient::Request.execute(url: url + URI.encode(params), method: :get, verify_ssl: false)
+          return response
+        rescue => e
+          Biro.log(:warn, "Unable to process BVS debits request")
+          raise StandardError.new("Error at BVS debits request: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/biro/gateways/bvs/response.rb

@@ -0,0 +1,56 @@
+require 'rest_client'
+
+module Biro
+  module Bvs
+    class Response < BaseResponse
+      attr_reader :body
+
+      def initialize(responses)
+        @body = { }
+        [:score, :debits].each { |r| @body[r] = responses[r].body if responses[r] }
+      end
+
+      def returning_score?
+        score_body.return_code == "0"
+      end
+
+      def returning_debits?
+        debits_body.return_code == "0"
+      end
+
+      def name
+        score_body.response_text_name.strip
+      end
+
+      def document
+        score_body.response_text_document.to_i
+      end
+
+      def scores
+        score_body.response_text_result_score.to_i
+      end
+
+      def debits?
+        debits_body.debits_info == 'S'
+      end
+
+      def debits_error_message
+        debits_body.error_message.strip unless returning_debits?
+      end
+
+      def score_error_message
+        score_body.error_message.strip unless returning_score?
+      end
+
+      private
+
+      def score_body
+        ScoreResponseBuilder.new @body[:score]
+      end
+
+      def debits_body
+        DebitsResponseBuilder.new @body[:debits]
+      end
+    end
+  end
+end

data/lib/biro/gateways/bvs.rb

@@ -0,0 +1,7 @@
+require_relative 'bvs/request'
+require_relative 'bvs/response'
+require_relative 'bvs/builders/base_builder'
+require_relative 'bvs/builders/debits_request_builder'
+require_relative 'bvs/builders/score_request_builder'
+require_relative 'bvs/builders/debits_response_builder'
+require_relative 'bvs/builders/score_response_builder'

data/lib/biro/gateways/cred_defense/request.rb

@@ -0,0 +1,69 @@
+require 'rest_client'
+
+module Biro
+  module CredDefense
+    class Request < BaseRequest
+
+      def production_url
+        'https://www.creddefense.com/index.php/api/v2'
+      end
+
+      def development_url
+        'https://test.creddefense.com/index.php/api/v2'
+      end
+
+      def required_params
+        [:username, :password]
+      end
+
+      def find(document)
+        params = {
+          authentication: { token: token },
+          advancedsearch: { identifier_code: document }
+        }
+
+        begin
+          response = RestClient.post(search_path, params.to_json, headers)
+          Response.new(response)
+        rescue => e
+          Biro.log(:warn, "Unable to process CredDefense request")
+          raise "Error at CredDefense request: #{e.message}"
+        end
+      end
+
+      private
+
+      def login_path
+        url + '/login'
+      end
+
+      def search_path
+        url + '/advancedsearch'
+      end
+
+      def token
+        @token ||= get_token
+      end
+
+      def get_token
+        auth = { authentication: { username: @username, password: @password } }
+        response = JSON.parse(RestClient.post(login_path, auth.to_json, headers).body)
+
+        raise AuthenticationError.new('Invalid authentication credentials') unless success?(response)
+
+        response.dig('authentication', 'token')
+      end
+
+      def success?(response)
+        response['result'] == 'success'
+      end
+
+      def headers
+        {
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json'
+        }
+      end
+    end
+  end
+end

data/lib/biro/gateways/cred_defense/response.rb

@@ -0,0 +1,131 @@
+require 'active_support/core_ext/array'
+
+module Biro
+  module CredDefense
+    class Response < BaseResponse
+      def initialize(response)
+        @body = response.body
+      end
+
+      def cpf
+        text('nrcpf').gsub(/\D/, '')
+      end
+
+      def birthdate
+        text('dtnascimento')
+      end
+
+      def mothers_name
+        text('nomae')
+      end
+
+      def name
+        text('nopessoa')
+      end
+
+      def income
+        text('nrrenda')
+      end
+
+      def profession
+        text('nrcbo')
+      end
+
+      def emails
+        email = text('noemail')
+        Array.wrap(email)
+      end
+
+      def receita_federal
+        rf = data.dig('dmcomprovantereceita')&.first
+
+        return nil unless rf
+
+        { name: rf.dig('nopessoa'), status: rf.dig('nosituacao'), date: rf.dig('dhprocessamento'), death: text('boobito') }
+      end
+
+      def equities
+        data.dig('dmlistaparticipacaosocietaria')&.map do |e|
+          cpf = e.dig('nrdocumentosocio')&.gsub(/\D/, '')
+          cnpj = e.dig('nrcnpj')&.gsub(/\D/, '')
+          name = e.dig('nosocio')&.strip
+          company = e.dig('norazaosocial')&.strip
+          shares = e.dig('qtpercentualcapitalsocial')
+          position = e.dig('noqualificacaosocio')&.strip
+          since = e.dig('dtentradasociedade')&.strip
+
+          {
+            cpf: cpf,
+            cnpj: cnpj,
+            name: name,
+            company: company,
+            shares: shares,
+            position: position,
+            since: since,
+          }
+        end
+      end
+
+      def addresses
+        data.fetch('dmlistaenderecos', nil).map do |a|
+          parts =  a['nologradouro'].split('-')
+          street = parts[0]&.split[0..-2].join(' ')
+          number = parts[0]&.split&.pop
+          city_parts = a['cdibgemunicipio']&.split('/')
+          city = city_parts && city_parts[0]
+          state = city_parts && city_parts[1]
+
+
+          {
+            street: street,
+            number: number,
+            complement: parts[1]&.strip,
+            city: city,
+            state: state,
+            zipcode: a['nrcep']
+          }
+        end
+      end
+
+      def phones
+        data.fetch('dmlistatelefones', nil).map do |p|
+          parts = p['nrtelefone']&.split(' ')
+          ddd = parts&.fetch(0, nil)&.gsub(/\D/, '')
+          number = parts&.fetch(1)
+          kind = (number.to_s[0] == '9' ? :mobile : :landline) if number
+
+          {
+            ddd: ddd,
+            number: number,
+            kind: kind
+          }
+        end
+
+      end
+
+      def success?
+        error.blank?
+      end
+
+      def error
+        if json['result'] == 'error'
+          json['messages']&.first
+        end
+      end
+
+      private
+
+      def text(field)
+        data.dig('dmlistapessoafisica', field).strip
+      end
+
+      def data
+        json.dig('advancedsearch')
+      end
+
+      def json
+        JSON.parse(@body)
+      end
+    end
+  end
+end

data/lib/biro/gateways/cred_defense.rb

@@ -0,0 +1,2 @@
+require_relative 'cred_defense/request'
+require_relative 'cred_defense/response'

data/lib/biro/gateways/midia100/request.rb

@@ -0,0 +1,59 @@
+module Biro
+  module Midia100
+    class Request < BaseRequest
+      include Utils::Soap
+
+      def production_url
+        'http://177.70.121.160/WSSisconsulta/consulta.asmx?wsdl'
+      end
+
+      def required_params
+        [:username, :password]
+      end
+
+      def find(document, options = {})
+        responses = { registration: soap.call(:consultar, message: params(document)) }
+        verify_response responses
+
+        [:rf, :equity, :job, :default].each do |i|
+          if options.keys.include?("include_#{i}".to_sym)
+            begin
+              responses[i] = soap.call(:consultar, message: params(document, SearchType.by(i)))
+            rescue
+              Biro.log(:warn, "Unable to process Midia100 #{i} request")
+              raise StandardError.new("Error at Midia100 request: #{e.message}")
+            end
+          end
+        end
+
+        Response.new(responses)
+      end
+
+      private
+
+      def verify_response responses
+        raise AuthenticationError.new("Error at Midia100 request: #{responses[:registration].body[:consultar_response][:consultar_result]}") if responses[:registration]&.body[:consultar_response][:consultar_result]&.include? "Usuário ou Senha Estão Incorretos"
+        raise DocumentNotFoundError.new("Error at Midia100 request: #{responses[:registration].body[:consultar_response][:consultar_result]}") if responses[:registration]&.body[:consultar_response][:consultar_result]&.include? "Cpf Inválido"
+        raise StandardError.new("Error at Midia100 request: #{responses[:registration].body[:consultar_response][:consultar_result]}") if responses[:registration]&.body[:consultar_response][:consultar_result]&.include? "<ERRO>"
+      end
+
+      def params(document, search_type = SearchType.by(:registration))
+        { 'usuario' => @username, 'senha' => @password, 'CodConsulta' => search_type, 'parametros' => document }
+      end
+    end
+
+    module SearchType
+      TYPES = {
+        registration: 2004,
+        rf: 2076,
+        equity: 2010,
+        job: 2017,
+        default: 2075
+      }
+
+      def self.by(type)
+        TYPES[type.to_sym]
+      end
+    end
+  end
+end

data/lib/biro/gateways/midia100/response.rb

@@ -0,0 +1,166 @@
+require 'active_support/core_ext/array'
+
+module Biro
+  module Midia100
+    class Response < BaseResponse
+      def initialize(responses)
+        @body = { registration: responses[:registration].body }
+
+        [:rf, :equity, :job, :default].each { |r| @body[r] = responses[r].body if responses[r] }
+      end
+
+      def cpf
+        text('Cpf')&.gsub(/\D/, '')
+      end
+
+      def birthdate
+        text('DtNasc')
+      end
+
+      def marital_status
+        text('EstadoCivil')
+      end
+
+      def pis
+        text('Pis')
+      end
+
+      def mothers_name
+        text('NomeMae')
+      end
+
+      def income
+        text('RendaPresumida')
+      end
+
+      def profession
+        text('IdProfissao')
+      end
+
+      def education
+        text('Escolaridade')
+      end
+
+      def name
+        text('Nome')
+      end
+
+      def gender
+        text('Sexo')
+      end
+
+      def receita_federal
+        return nil unless rf
+
+        data = rf['Receita_x0020_Federal_x0020_Pf']
+
+        { name: data.dig('Nome'), status: data.dig('Situacao'), date: data.dig('DataPesquisa'), death: data.dig('Obito') }
+      end
+
+      def jobs
+        Array.wrap(job&.fetch('Funcionarios', nil)).map do |j|
+          {
+            cnpj: j['Cnpj']&.gsub(/[\s\.\-\/]/, ''),
+            company: j['Empresa']&.strip,
+          }
+        end
+      end
+
+      def defaults
+        Array.wrap(default&.fetch('spc', nil)).map do |d|
+          {
+            bureau: :spc,
+            company: d['nomeassociado']&.strip,
+            created_at: d['datainclusao'],
+            due_at: d['datavencimento'],
+            value: d['valor'],
+            city: d['nome'],
+            state: d['siglauf'],
+            phone: { ddd: d['numeroddd'], number: d['numero'] },
+            contract: d['contrato']
+          }
+        end
+      end
+
+      def success?
+        error.blank?
+      end
+
+      def error
+        return nil unless registration.keys.first =~ /Erro/
+
+        error = registration.flatten
+        "#{error[0]} - #{error[1]['Mensagem']}"
+      end
+
+      def addresses
+        Array.wrap(registration&.fetch('Enderecos', nil)).map do |e|
+          {
+            street: e['Logradouro']&.strip,
+            number: e['Numero']&.strip,
+            complement: e['Complemento']&.strip,
+            city: e['Cidade']&.strip,
+            state: e['Uf']&.strip,
+            zipcode: e['Cep']&.strip
+          }
+        end
+      end
+
+      def emails
+        Array.wrap(registration&.fetch('Emails', nil)).map do |e|
+          e['EMail']&.strip
+        end
+      end
+
+      def phones
+        landline_phones.to_a + mobile_phones.to_a
+      end
+
+      def landline_phones
+        Array.wrap(registration&.fetch('Telefones', nil)).map do |t|
+          {
+            ddd: t['Ddd'],
+            number: t['Fone'],
+            kind: :landline
+          }
+        end
+      end
+
+      def mobile_phones
+        Array.wrap(registration&.fetch('Celulares', nil)).map do |c|
+          {
+            ddd: c['Ddd'],
+            number: c['Fone'],
+            kind: :mobile
+          }
+        end
+      end
+
+      private
+
+      def text(field)
+        registration.dig('Pf', field)&.strip
+      end
+
+      def rf
+        result(@body[:rf])
+      end
+
+      def default
+        result(@body[:default])
+      end
+
+      def job
+        result(@body[:job])
+      end
+
+      def registration
+        result(@body[:registration])
+      end
+
+      def result(data)
+        Nori.new.parse(data[:consultar_response][:consultar_result])['NewDataSet'] unless data.nil?
+      end
+    end
+  end
+end

data/lib/biro/gateways/midia100.rb

@@ -0,0 +1,2 @@
+require_relative 'midia100/request'
+require_relative 'midia100/response'

data/lib/biro/gateways/ph3a/builders/login_builder.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/array'
+
+class LoginBuilder
+  def initialize response
+    @body = response.body
+  end
+
+  def token
+    login_result.dig(:token)
+  end
+
+  def login_result
+    @body.dig(:login_response).dig(:login_result)
+  end  
+end

data/lib/biro/gateways/ph3a/request.rb

@@ -0,0 +1,72 @@
+module Biro
+  module Ph3a
+    class Request < BaseRequest
+      include Utils::Soap
+
+      def development_url
+        'https://ws.databusca.com.br/DataHistory.svc?wsdl'
+      end
+
+      def production_url
+        'https://ws.databusca.com.br/DataHistory.svc?wsdl'
+      end
+
+      def required_params
+        [:username, :password, :domain]
+      end
+
+      def find(document)
+        raise AuthenticationError.new('Invalid authentication credentials') if token.blank?
+
+        begin
+          params = {}
+          get_parameters params, document
+          response = soap.call(:get_person_data, message: params)
+          Response.new(response)
+        rescue => e
+          Biro.log(:warn, "Unable to process Ph3a request")
+          raise StandardError.new("Error at PH3A request: #{e.message}")
+        end
+      end
+
+      private
+
+      def token
+        @token ||= get_token
+      end
+
+      def get_token
+        login_params = {}
+        get_login_parameters login_params
+
+        begin
+          response = soap.call(:login, message: login_params)
+        rescue
+          raise AuthenticationError.new('Authentication Error')
+        end
+
+        LoginBuilder.new(response).token
+      end
+
+      def get_login_parameters login_params
+        login_params['tns:user'] = {}
+        login_params['tns:user']['ph3a:DomainId'] = @domain
+        login_params['tns:user']['ph3a:Password'] = @password
+        login_params['tns:user']['ph3a:UserName'] = @username
+      end
+
+      def get_parameters params, document
+        params['tns:token'] = token
+        params['tns:document'] = document
+      end
+
+      def savon_options
+        { namespaces: {
+            "xmlns:soapenv"=>"http://schemas.xmlsoap.org/soap/envelope/",
+            "xmlns:tem"=>"http://tempuri.org/",
+            "xmlns:ph3a"=>"http://schemas.datacontract.org/2004/07/PH3A.Viper.Web.PortalService.Models"
+        }}
+      end
+    end
+  end
+end