ratsit 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fe41a466ccf397de54bac8fb52e76f96ada4bac
-  data.tar.gz: c81222eb134bd582d1c5b708dff6bfddc14b03c6
+  metadata.gz: 2e5949f1ca309cd41832cb8f648f0f51e6957302
+  data.tar.gz: 53be756f285f8a21e755a09c62428b2b588abe00
 SHA512:
-  metadata.gz: e33317326a6c442affc955fc4dda650e43495b205ff22e394ea487d71ac47598c0e5584d8bede38a6531a14d71cc34eb580d662ccdc340eab3289fcaf0adf3d0
-  data.tar.gz: f15ac274848fe9da25ebceccca9c472ed1be104fabe49658c03edf4ebf0c6ff886f55de5fc6c185cfb3a482586095a39901cd4d7bf20c6d86c1f9b23221562eb
+  metadata.gz: bf45d638a1fd05c20c29fe7ebf3c9ea49d85826dc195797ffbf1171c97d7b386494cb5438a4d111e64a176b47b2955316e43ef5c8bf6296563caef0986bc372c
+  data.tar.gz: be59024c037d0b9597d2ed7168a46d1fc45331a985a4b909fb9b9f3e16ce6d0b09206b06d9938b7a927c53b3742843d2441c6d43f6346020f49d1679ea9bc31c

data/README.md

@@ -1,5 +1,7 @@
 # Ratsit
 
+[![Gem Version](https://badge.fury.io/rb/ratsit.svg)](https://rubygems.org/gems/ratsit)
+
 Ruby gem for performing Ratsit searches.
 
 _Note_: This gem is under active development and might not be suitable for use yet...

data/lib/ratsit.rb

@@ -1,82 +1,106 @@
-require 'ratsit/version'
-require 'ratsit/package'
-require 'ratsit/search_type'
-require 'ratsit/request'
-require 'ratsit/filters'
+
 require 'ratsit/errors'
-require 'json'
+require 'ratsit/monkey'
+require 'ratsit/version'
 
-module Ratsit
+require 'ratsit/filter/filter'
+require 'ratsit/filter/filter_company'
+require 'ratsit/filter/filter_get_annual_report'
+require 'ratsit/filter/filter_get_companies'
+require 'ratsit/filter/filter_get_company_information_package'
+require 'ratsit/filter/filter_get_person_information_package'
+require 'ratsit/filter/filter_person'
+require 'ratsit/filter/filter_search_one_person'
+require 'ratsit/filter/filter_search_persons'
 
-  api_key_key = 'RATSIT_API_KEY'
-  @env_api_key = ENV[api_key_key]
-  if @env_api_key.nil?
-    puts "No api key specified. The library can only search using the open api. Set your api key using key #{api_key_key}"
-  end
+require 'ratsit/request/request'
+require 'ratsit/request/open_request'
+require 'ratsit/request/token_request'
+require 'ratsit/request/request_get_companies'
+require 'ratsit/request/request_search_one_person'
+require 'ratsit/request/request_search_persons'
 
-  class RatsitSearch
 
-    attr_reader :filter
-    attr_reader :results
+module Ratsit
 
-    def initialize(search_type, filter_instance)
-      @filter = filter_instance
-      @search_type = search_type
-      @results = nil
-      @api_key = @env_api_key
+  def Ratsit.get_api_key
+    key_key = 'RATSIT_API_KEY'
+    if ENV[key_key].nil?
+      raise RatsitError, 'No api key specified'
     end
+    return ENV[key_key]
+  end
 
-    def search(search_arg, search_area='')
-      if !search_arg.is_a?(String)
-        raise RatsitError, 'Invalid search argument'
-      end
-      if search_arg.length == 0
-        raise RatsitError, 'Invalid search argument length'
-      end
-      if !search_area.is_a?(String)
-        raise RatsitError, 'Invalid search area'
-      end
-      request_class = (!@api_key.nil?)? Ratsit::RatsitTokenRequest: Ratsit::RatsitOpenRequest
-      @request = request_class.new(search_arg, search_area, @search_type, @filter)
-      @request.exec()
-      # check this...
-      if @request.response_ok
-        #puts "response ok"
-        #@results = @request.response_body.to_json
-        @results = @request.response_body
-      else
-        @results = nil
-      end
-      @results
+  def Ratsit.OpenPersonSearch(search_term, search_area, filter_instance=nil)
+    if !filter_instance.nil? && !filter_instance.instance_of?(Ratsit::Filter::PersonFilter)
+      raise RatsitFilterError, 'Invalid filter given to function'
     end
+    req = Ratsit::Request::OpenRequest.new(Ratsit::Request::OPEN_REQUEST_EPTS[:person], search_term, search_area, filter_instance || Ratsit::Filter::PersonFilter.new())
+    req.exec()
+    if req.response_ok
+      return req.response_body
+    end
+    nil
+  end
 
+  def Ratsit.OpenCompanySearch(search_term, search_area, filter_instance=nil)
+    if !filter_instance.nil? && !filter_instance.instance_of?(Ratsit::Filter::CompanyFilter)
+      raise RatsitFilterError, 'Invalid filter given to function'
+    end
+    req = Ratsit::Request::OpenRequest.new(Ratsit::Request::OPEN_REQUEST_EPTS[:company], search_term, search_area, filter_instance || Ratsit::Filter::CompanyFilter.new())
+    req.exec()
+    if req.response_ok
+      return req.response_body
+    end
+    nil
   end
 
-  class PersonSearch < RatsitSearch
+  def Ratsit.doTokenRequest(req_class, filter_args)
+      req = req_class.new(filter_args)
+      puts req
+      req.exec()
+      return req.response
+    nil
+  end
 
-    def initialize()
-      super(Ratsit::SEARCH_TYPE_PERSON, Ratsit::PersonFilter.new())
-      self
-    end
+  def Ratsit.SearchCompanies(args=nil)
+    return Ratsit.doTokenRequest(Ratsit::Request::GetCompaniesRequest, args)
+  end
 
+  def Ratsit.SearchOnePerson(args=nil)
+    return Ratsit.doTokenRequest(Ratsit::Request::SearchOnePersonRequest, args)
   end
 
-  class CompanySearch < RatsitSearch
+  def Ratsit.SearchPersons(args=nil)
+    return Ratsit.doTokenRequest(Ratsit::Request::SearchPersonsRequest, args)
+  end
 
-    def initialize()
-      super(Ratsit::SEARCH_TYPE_COMPANY, Ratsit::CompanyFilter.new())
-      self
-    end
 
+end
+
+=begin
+  def Ratsit.GetAnnualReport(args=nil)
+    return Ratsit.doTokenRequest('GetAnnualReport', Ratsit.parseFilterArgs(args, Ratsit::Filter::GetAnnualReportFilter))
   end
 
-  class EstateSearch < RatsitSearch
+  def Ratsit.GetCompanies(args=nil)
+    return Ratsit.doTokenRequest('GetCompanies', Ratsit.parseFilterArgs(args, Ratsit::Filter::GetCompaniesFilter))
+  end
 
-    def initialize()
-      super(Ratsit::SEARCH_TYPE_ESTATE, Ratsit::EstateFilter.new())
-      self
-    end
+  def Ratsit.GetCompanyInformationPackage(args=nil)
+    return Ratsit.doTokenRequest('GetCompanyInformationPackage', Ratsit.parseFilterArgs(args, Ratsit::Filter::GetCompanyInformationPackageFilter))
+  end
 
+  def Ratsit.GetPersonInformationPackage(args=nil)
+    return Ratsit.doTokenRequest('GetPersonInformationPackage', Ratsit.parseFilterArgs(args, Ratsit::Filter::GetPersonInformationPackageFilter))
   end
 
-end
+  def Ratsit.SearchOnePerson(args=nil)
+    return Ratsit.doTokenRequest('SearchOnePerson', Ratsit.parseFilterArgs(args, Ratsit::Filter::SearchOnePersonFilter))
+  end
+
+  def Ratsit.SearchPersons(args=nil)
+    return Ratsit.doTokenRequest('SearchPersons', Ratsit.parseFilterArgs(args, Ratsit::Filter::SearchPersonsFilter))
+  end
+=end
+

data/lib/ratsit/errors.rb

@@ -2,6 +2,9 @@
 class RatsitError < StandardError
 end
 
+class RatsitAbstractError < RatsitError
+end
+
 class RatsitRequestError < RatsitError
 end
 

data/lib/ratsit/filter/filter.rb

@@ -0,0 +1,212 @@
+
+require 'json'
+require 'ratsit/errors'
+
+module Ratsit
+  module Filter
+
+    # Person filters
+    FILTER_MARRIED = 'Married'
+    FILTER_UNMARRIED = 'Unmarried'
+    FILTER_MALE = 'Male'
+    FILTER_FEMALE = 'Female'
+    FILTER_COMPANY_ENGAGEMENT = 'CompanyEngagement'
+    FILTER_NO_COMPANY_ENGAGEMENT = 'NoCompanyEngagement'
+    FILTER_AGE_FROM = 'AgeFrom'
+    FILTER_AGE_TO = 'AgeTo'
+
+    FILTER_FIRST_NAME = 'firstName'
+    FILTER_LAST_NAME = 'lastName'
+    FILTER_SSN = 'ssn'
+    FILTER_USE_PHONETIC_SEARCH = 'usePhoneticSearch'
+
+    # Company filters
+    FILTER_AB = 'AB'
+    FILTER_EF = 'EF'
+    FILTER_HB = 'HB'
+    FILTER_KB = 'KB'
+    FILTER_HB_KB = "#{FILTER_HB}/#{FILTER_KB}"
+    FILTER_OTHER = 'Other'
+
+
+    # token filters
+    FILTER_TOKEN = 'token'
+    FILTER_IDS = 'IDs'
+    FILTER_COMPANY_NAME = 'companyName'
+    FILTER_ADDRESS = 'address'
+    FILTER_ZIP_CODE = 'zipCode'
+    FILTER_CITY = 'city'
+    FILTER_MUNICIPALITY = 'municipality'
+    FILTER_PHONE = 'phone'
+    FILTER_COMPANY_TYPE = 'companyType'
+    FILTER_SEARCH_AGE = 'searchAge'
+
+    FILTER_PACKAGES = 'packages'
+    FILTER_ORG_NR = 'orgnr'
+    FILTER_PNR = 'pnr'
+
+    FILTER_NUMBER_OF_HITS = 'numberOfHits'
+
+    FILTER_PACKAGE_SMALL_1 = 'small 1'
+    FILTER_PACKAGE_SMALL_2 = 'small 2'
+    FILTER_PACKAGE_SMALL_3 = 'small 3'
+    FILTER_PACKAGE_REMARK = 'anmärkning'
+    FILTER_PACKAGE_MEDIUM = 'medium'
+    FILTER_PACKAGE_LARGE = 'large'
+
+    class RatsitFilter
+
+      def abstract(msg=nil)
+        _msg = msg || 'This class should not be used directly'
+        raise RatsitAbstractError, _msg
+      end
+
+      def initialize()
+        @abstract_interface_msg = 'This interface is abstract. Implement method in subclass'
+        if self.instance_of?(RatsitFilter)
+          abstract
+        end
+        @active_filters = {}
+        @filter_defaults = {}
+      end
+
+      def active_filters
+        return (@active_filters.nil?)? nil: @active_filters
+      end
+
+      def to_json
+        af = self.active_filters
+        return '{}' if af.nil?
+        af.to_json
+      end
+
+      def to_obj
+        @active_filters
+      end
+
+      def update(filter_key='', filter_value)
+        #puts "update #{filter_key}: #{filter_value}"
+        if !filter_key.is_a?(String)
+          raise RatsitFilterError, 'Invalid filter key'
+        end
+        if filter_value.nil?
+          raise RatsitFilterError, 'Invalid filter value'
+        end
+        if !@active_filters.has_key?(filter_key)
+          raise RatsitFilterError, 'Non-existent filter key'
+        end
+        @curr_filters = Marshal.load(Marshal.dump(@active_filters))
+        @curr_filters[filter_key] = filter_value
+        @active_filters = validate_filters(@filter_defaults, @curr_filters)
+      end
+
+      def reset(filter_name='')
+        if !filter_name.is_a?(String)
+          raise RatsitFilterError, 'Invalid filter key'
+        end
+        if !@filter_defaults.has_key?(filter_name)
+          raise RatsitFilterError, 'Non-existent filter key'
+        end
+        @active_filters[filter_name] = @filter_defaults[filter_name][:default]
+      end
+
+    end
+
+    private
+
+    def parse_string(arg)
+      return arg if arg.is_a?(String)
+      raise RatsitFilterError, 'Invalid string'
+    end
+
+    def parse_bool(arg)
+      return arg if arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
+      raise RatsitFilterError, 'Invalid bool representation' if !arg.is_a?(String)
+      return true if arg.downcase == 'true'
+      return false if arg.downcase == 'false'
+      raise RatsitFilterError, 'Invalid textual bool value'
+    end
+
+    def parse_bool_string(arg)
+      return arg if arg == 'true' || arg == 'false'
+      return 'true' if arg.is_a?(TrueClass)
+      return 'false' if arg.is_a?(FalseClass)
+      raise RatsitFilterError, 'Invalid string representation of bool'
+    end
+
+    def parse_age(arg)
+      if arg.is_a?(String)
+        if !(arg =~ /^[0-9]+$/)
+          raise RatsitFilterError, 'Invalid age in filter'
+        end
+        larg = arg.to_i
+      elsif arg.is_a?(Integer)
+        larg = arg
+      else
+        raise RatsitFilterError, 'Invalid arg type in filter'
+      end
+      # ratsit specifies these ages.
+      if larg < 0 || larg > 150
+        raise RatsitFilterError, 'Invalid age'
+      end
+      "#{larg}"
+    end
+
+    def parse_int(arg)
+      return arg if arg.is_a?(Integer)
+      return arg.to_i if arg =~ /^[0-9]+$/
+      raise RatsitFilterError, 'Invalid integer'
+    end
+
+    def parse_list(arg)
+      return arg.join(',') if arg.is_a?(Array)
+      return arg if arg.is_a?(String)
+      raise RatsitFilterError, 'Invalid array'
+    end
+
+    def validate_list(lst, accepted_values=[])
+      if lst.is_a?(Array)
+        arr = lst
+      elsif lst.is_a?(String)
+        arr = lst.split(',').map(&:strip)
+      end
+      err = []
+      arr.each { |v| err.push(v) if !accepted_values.include?(v) }
+      if err.length > 0
+        raise RatsitFilterError, "Invalid list values: #{err.join(',')}"
+      end
+      arr.join(',')
+    end
+
+    def validate_company_types(lst)
+      return validate_list(lst, [FILTER_AB, FILTER_EF, FILTER_HB_KB, FILTER_OTHER])
+    end
+
+    def validate_package_types(lst)
+      return validate_list(lst, [FILTER_PACKAGE_SMALL_1, FILTER_PACKAGE_SMALL_2, FILTER_PACKAGE_SMALL_3, FILTER_PACKAGE_REMARK, FILTER_PACKAGE_MEDIUM, FILTER_PACKAGE_LARGE])
+    end
+
+    def validate_filters(filter_defaults={}, filters={})
+      if !filters.is_a?(Hash)
+        filters = {}
+      end
+      filters.reject! { |k,_| !filter_defaults.keys.include? k }
+      filter_defaults.each do |filter_name, defs|
+        if !filters.keys.include? filter_name
+          filters[filter_name] = defs[:default]
+        end
+        filters[filter_name] = defs[:parse].call(filters[filter_name])
+        if defs.has_key?(:validate)
+          filters[filter_name] = defs[:validate].call(filters[filter_name])
+        end
+      end
+      if filters.keys.include?(FILTER_AGE_TO) && filters.keys.include?(FILTER_AGE_FROM)
+        if filters[FILTER_AGE_TO].to_i < filters[FILTER_AGE_FROM].to_i
+          raise RatsitFilterError, 'Invalid age span'
+        end
+      end
+      filters
+    end
+
+  end
+end

data/lib/ratsit/filter/filter_company.rb

@@ -0,0 +1,27 @@
+
+
+require 'ratsit/errors'
+require 'ratsit/filter/filter'
+
+module Ratsit
+  module Filter
+
+
+
+    class CompanyFilter < Ratsit::Filter::RatsitFilter
+      include Ratsit::Filter
+      #{"AB":true,"EF":true,"HB":true,"Other":true}
+      def initialize(filters={})
+        super()
+        @filter_defaults = {
+            FILTER_AB => {:parse => method(:parse_bool), :default => true},
+            FILTER_EF => {:parse => method(:parse_bool), :default => true},
+            FILTER_HB => {:parse => method(:parse_bool), :default => true},
+            FILTER_OTHER => {:parse => method(:parse_bool), :default => true}
+        }
+        @active_filters = validate_filters(@filter_defaults, filters)
+      end
+    end
+
+  end
+end

data/lib/ratsit/filter/filter_get_annual_report.rb

@@ -0,0 +1,21 @@
+
+require 'ratsit/errors'
+require 'ratsit/filter/filter'
+
+module Ratsit
+  module Filter
+    class GetAnnualReportFilter < Ratsit::Filter::RatsitFilter
+      include Ratsit::Filter
+
+      def initialize(filters={})
+        super()
+        @filter_defaults = {
+            FILTER_TOKEN => {:parse => method(:parse_string), :default => Ratsit.get_api_key()},
+            FILTER_IDS => {:parse => method(:parse_list), :default => '', :validate => method(:validate_list)}
+        }
+        @active_filters = validate_filters(@filter_defaults, filters)
+      end
+    end
+
+  end
+end