hawatel_search_jobs 0.1.0

data/lib/hawatel_search_jobs/api/xing.rb

@@ -0,0 +1,121 @@
+require 'xing_api'
+
+module HawatelSearchJobs::Api
+  module Xing
+    class << self
+      include HawatelSearchJobs::Helpers::Base
+
+      DEFAULT = {
+          :keywords => '',
+          :location => '',
+          :company  => ''
+      }
+
+      # @see https://github.com/xing/xing_api
+      # Search jobs based on specified keywords
+      #
+      # @param args [Hash]
+      # @option args :query [Hash] search criteria
+      #   - *:keywords* (String )
+      # @option args :setting [Hash] @see https://dev.xing.com/docs/authentication
+      #   - *:consumer_key* (String) - consumer key, required for authentication
+      #   - *:consumer_secret* (String) - consumer secret, required for authentication
+      #   - *:oauth_token* (String) - outh toker, required for authentication
+      #   - *:oauth_token_secret* (String) - outh token secret, required for authentication
+      #
+      # @example
+      #   search(:settings => HawatelSearchJobs.xing,:query => {:keywords => 'ruby'})
+      #
+      # @return [Hash<OpenStruct>]
+      def search(args)
+        args[:query] = DEFAULT.merge(args[:query]) if args[:query]
+        keywords = args[:query][:keywords]
+        result = send_request({:keywords => keywords, :offset => 0, :settings => args[:settings]})
+        if !result[:code]
+          set_attributes({:result => result, :page => 0, :keywords => keywords})
+        else
+          OpenStruct.new({:code => 501, :msg => 'incorrect settings'})
+        end
+      end
+
+      # Show next page of results
+      #
+      # @param args [Hash]
+      # @option page [Integer] page numer (default 0)
+      # @option query_key [String] keywords from last query
+      #
+      # @example
+      #   page({:query_key => result.key, :page => 2}
+      #
+      # @return [Hash<OpenStruct>]
+      def page(args)
+        args[:page] = 0 if args[:page].nil?
+        result = XingApi::Job.search(args[:query_key], {:limit => 25, :offset => args[:page]*25})
+        set_attributes({:result => result, :page => args[:page], :keywords => args[:query_key]})
+      rescue XingApi::Error => e
+        {:code => e.status_code, :msg => e.text}
+      end
+
+      private
+      # Call Xing client request
+      #
+      # @param args [Hash]
+      # @option settings [Hash] authentication attributes
+      # @option keywords [String] keywords for query
+      #
+      # @return [Hash<OpenStruct>]
+      def send_request(args)
+        set_settings(args[:settings])
+        XingApi::Job.search(args[:keywords], {:limit => 25, :offset => 0})
+      rescue XingApi::Error => e
+        {:code => e.status_code, :msg => e.text}
+      end
+
+      # Build final result - set required attributes and return openstruct object
+      #
+      def set_attributes(args)
+        attributes = Hash.new
+        attributes[:totalResults] = args[:result][:jobs][:total]
+        attributes[:code]  = '200'
+        attributes[:msg]   = "OK"
+        attributes[:page]  = args[:page]
+        attributes[:last]  = args[:result][:jobs][:total] / 25
+        attributes[:key]   = args[:keywords]
+        attributes[:jobs]  = parse_raw_data(args[:result])
+        OpenStruct.new(attributes)
+      end
+
+      # Build jobs array with specified attributes
+      #
+      # @return [Array<OpenStruct>]
+      def parse_raw_data(result)
+        jobs = Array.new
+        return jobs if result['jobs'].to_s.empty?
+        result[:jobs][:items].each do |offer|
+          job = Hash.new
+          job[:jobtitle] = offer[:title]
+          job[:location] = "#{offer[:location][:country]}, #{offer[:location][:city]}"
+          job[:company]  = offer[:company][:name]
+          job[:date]     = convert_date_to_format(offer[:published_at], '%d/%m/%y')
+          job[:url]      = offer[:links][:xing]
+          job = convert_empty_to_nil(job)
+          jobs << OpenStruct.new(job)
+        end
+        return jobs
+      end
+
+      # Set settings for XingApi client
+      #
+      # @param args [Hash]
+      def set_settings(args)
+        XingApi::Client.configure do |config|
+          config.consumer_key = args[:consumer_key]
+          config.consumer_secret = args[:consumer_secret]
+          config.oauth_token = args[:oauth_token]
+          config.oauth_token_secret = args[:oauth_token_secret]
+        end
+      end
+
+    end
+  end
+end

data/lib/hawatel_search_jobs/client.rb

@@ -0,0 +1,165 @@
+module HawatelSearchJobs
+  ##
+  # = Client for a jobs search engine
+  #
+  # @!attribute [rw] indeed
+  #   @return [Hash] settings of API
+  # @!attribute [rw] xing
+  #   @return [Hash] settings of API
+  # @!attribute [rw] reed
+  #   @return [Hash] settings of API
+  # @!attribute [rw] careerbuilder
+  #   @return [Hash] settings of API
+  # @!attribute [rw] careerjet
+  #   @return [Hash] settings of API
+  class Client
+    include HawatelSearchJobs::Api
+
+    # Values have to be the same name like module name of usesd APIs (HawatelSearchJobs::Api::[ApiName])
+    APIS = ['Indeed', 'Xing', 'Reed', 'Careerbuilder', 'CareerJet']
+
+    attr_reader :jobs_table
+
+    DEFAULT = {
+        :keywords => '',
+        :location => '',
+        :company  => '',
+    }
+
+    def initialize
+      APIS.each do |api|
+        metaclasses.send(:attr_reader, api.downcase.to_sym)
+        instance_variable_set("@#{api.downcase}", HawatelSearchJobs.instance_variable_get("@"+api.downcase))
+      end
+    end
+
+    def metaclasses
+      class << self; self; end
+    end
+
+    # Search Jobs by specific criteria
+    # @param query [Hash]
+    # @option query [String] :keywords
+    # @option query [String] :location
+    # @option query [String] :company not working in Reed API
+    # @example
+    #       HawatelSearchJobs.configure do |config|
+    #           config.indeed[:activated] = true
+    #           config.indeed[:api]       = 'api.indeed.com'
+    #           config.indeed[:version]   = '2'
+    #           config.indeed[:publisher] = 'secret-key'
+    #
+    #           config.xing[:activated]           = true
+    #           config.xing[:consumer_key]        = 'secret-key'
+    #           config.xing[:consumer_secret]     = 'secret-key'
+    #           config.xing[:oauth_token]         = 'secret-key'
+    #           config.xing[:oauth_token_secret]  = 'secret-key'
+    #
+    #           config.reed[:activated] = true
+    #           config.reed[:api]       = 'reed.co.uk/api'
+    #           config.reed[:clientid]  = 'secret-key'
+    #           config.reed[:version]   = '1.0'
+    #
+    #           config.careerbuilder[:activated]  = true
+    #           config.careerbuilder[:api]        = 'api.careerbuilder.com'
+    #           config.careerbuilder[:clientid]   = 'secret-key'
+    #           config.careerbuilder[:version]    = 'v2'
+    #
+    #           config.careerjet[:activated]   = true
+    #           config.careerjet[:api]         = 'public.api.careerjet.net'
+    #         end
+    #
+    #       client = HawatelSearchJobs::Client.new
+    #       client.search_jobs({:keywords => 'ruby'})
+    #
+    #       p client.jobs_table[:indeed]
+    #       p client.jobs_table[:xing]
+    #       p client.jobs_table[:reed]
+    #       p client.jobs_table[:careerbuilder]
+    #       p client.jobs_table[:careerjet]
+    #
+    #       client.next
+    # @return [Hash] First page of result for all providers (default maximum 25 records for each page)
+    def search_jobs(query = {})
+      query = DEFAULT.merge(query)
+
+      @jobs_table = Hash.new
+
+      APIS.each do |api|
+        api_module_name = Object.const_get('HawatelSearchJobs').const_get('Api').const_get(api)
+        api_inst_var = instance_variable_get("@"+api.downcase)
+        @jobs_table[api.downcase.to_sym] = api_module_name.search({:settings => api_inst_var, :query => query}) if api_inst_var[:activated]
+      end
+
+      @jobs_table
+    end
+
+    # Get next page of result
+    # @example
+    #   p client.next
+    #   p client.jobs_table
+    # @return [Hash] Next page of result for all providers (default maximum 25 records for each)
+    def next
+      next_result = Hash.new
+      APIS.each do |api|
+        api_module_name = Object.const_get('HawatelSearchJobs').const_get('Api').const_get(api)
+        api_inst_var = instance_variable_get("@"+api.downcase)
+        api_sym_name = api.downcase.to_sym
+
+        if api_inst_var[:activated] && next_result?(api_sym_name)
+          next_result[api_sym_name] = api_module_name.page({:settings => api_inst_var,
+                                                            :page => @jobs_table[api_sym_name].page + 1,
+                                                            :query_key => @jobs_table[api_sym_name].key})
+        end
+      end
+
+      return nil if next_result.empty?
+
+      @jobs_table = next_result
+    end
+
+
+    # Sum jobs offers from specified api or count all
+    #
+    # @param args [Hash]
+    # @option args [String] :api name
+    # @example
+    #   p client.count
+    #   p client.count('indeed')
+    #
+    # @return [Integer]
+    def count(api = nil)
+      sum = 0
+
+      if api
+        api = api.downcase
+        api_inst_var = instance_variable_get("@"+api)
+        if api_inst_var[:activated]
+          sum = @jobs_table[:"#{api}"].totalResults if @jobs_table[:"#{api}"].totalResults
+        end
+      else
+        APIS.each do |provider|
+          api_inst_var = instance_variable_get("@"+provider.downcase)
+          if api_inst_var[:activated]
+            provider = provider.downcase
+            sum += @jobs_table[:"#{provider}"].totalResults if @jobs_table[:"#{provider}"].totalResults
+          end
+        end
+      end
+      return sum
+    end
+
+    private
+    def next_result?(provider)
+      if @jobs_table[provider] && @jobs_table[provider].page && @jobs_table[provider].last &&
+          @jobs_table[provider].page < @jobs_table[provider].last
+        true
+      else
+        false
+      end
+
+    end
+
+  end
+end
+

data/lib/hawatel_search_jobs/helpers.rb

@@ -0,0 +1 @@
+require 'hawatel_search_jobs/helpers/base'

data/lib/hawatel_search_jobs/helpers/base.rb

@@ -0,0 +1,39 @@
+require 'net/http'
+require 'json'
+require 'date'
+
+module HawatelSearchJobs
+  module Helpers
+    module Base
+
+      private
+      def send_request(url, opt = {})
+        uri = URI.parse(url)
+        req = Net::HTTP::Get.new(uri)
+        if opt[:basic_auth] && opt[:basic_auth][:username] && opt[:basic_auth][:password]
+          req.basic_auth(opt[:basic_auth][:username], opt[:basic_auth][:password])
+        end
+        sock = Net::HTTP.new(uri.host, uri.port)
+        sock.use_ssl = true if uri.scheme == 'https'
+        
+        sock.start { |http| http.request(req) }
+      end
+
+      def convert_empty_to_nil(hash)
+        new = {}
+        hash.each do |k,v|
+          if v.to_s.empty?
+            new[k] = nil
+          else
+            new[k] = v
+          end
+        end
+        new
+      end
+
+      def convert_date_to_format(date, format)
+        DateTime.parse(date).to_date.strftime(format) if !date.to_s.empty?
+      end
+    end
+  end
+end

data/lib/hawatel_search_jobs/version.rb

@@ -0,0 +1,3 @@
+module HawatelSearchJobs
+  VERSION = "0.1.0"
+end

data/spec/careerbuilder_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe HawatelSearchJobs::Api::Careerbuilder do
+  context 'APIs returned jobs' do
+    before(:each) do
+      HawatelSearchJobs.configure do |config|
+        config.careerbuilder[:api]      = 'api.careerbuilder.com'
+        config.careerbuilder[:version]  = 'v2'
+        config.careerbuilder[:clientid] = ''
+      end
+
+      @query_api = {:keywords => 'ruby', :location => ''}
+      @result = HawatelSearchJobs::Api::Careerbuilder.search(
+          :settings => HawatelSearchJobs.careerbuilder,
+          :query => {
+              :keywords => @query_api[:keywords],
+              :location => @query_api[:location]
+          })
+    end
+
+    xit '#search' do
+      validate_result(@result, @query_api)
+      expect(@result.page).to be >= 0
+      expect(@result.last).to be >= 0
+    end
+
+    xit '#page' do
+      validate_result(@result, @query_api)
+      page_result = HawatelSearchJobs::Api::Careerbuilder.page({
+                                                                   :settings => HawatelSearchJobs.careerbuilder,
+                                                                   :query_key => @result.key,
+                                                                   :page => 1})
+      expect(page_result.key).to match(/&PageNumber=2/)
+      expect(page_result.page).to be == 1
+      expect(page_result.last).to be >= 0
+    end
+  end
+
+  context 'APIs returned empty table' do
+    before(:each) do
+      HawatelSearchJobs.configure do |config|
+        config.careerbuilder[:api]      = 'api.careerbuilder.com'
+        config.careerbuilder[:version]  = 'v2'
+        config.careerbuilder[:clientid] = ''
+      end
+
+      @query_api = {:keywords => 'job-not-found-zero-records', :location => 'London'}
+      @result = HawatelSearchJobs::Api::Careerbuilder.search(
+          :settings => HawatelSearchJobs.careerbuilder,
+          :query => {
+              :keywords => @query_api[:keywords],
+              :location => @query_api[:location]
+          })
+    end
+
+    xit '#search' do
+      validate_result(@result, @query_api)
+      expect(@result.totalResults).to eq(0)
+      expect(@result.page).to be_nil
+      expect(@result.last).to be_nil
+      expect(@result.jobs).to be_nil
+    end
+
+    xit '#page' do
+      validate_result(@result, @query_api)
+      page_result = HawatelSearchJobs::Api::Careerbuilder.page({
+                                                                   :settings => HawatelSearchJobs.careerbuilder,
+                                                                   :query_key => @result.key,
+                                                                   :page => 1})
+      expect(page_result.key).to match(/&PageNumber=2/)
+      expect(@result.totalResults).to eq(0)
+      expect(@result.page).to be_nil
+      expect(@result.last).to be_nil
+      expect(@result.jobs).to be_nil
+    end
+  end
+
+  private
+
+  def validate_result(result, query_api)
+    expect(result.code).to eq(200)
+    expect(result.msg).to eq('OK')
+    expect(result.totalResults).to be >= 0
+    expect(result.key).to match("Location=#{query_api[:location]}")
+    expect(result.key).to match("Keywords=#{query_api[:keywords]}")
+  end
+end

data/spec/careerjet_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe HawatelSearchJobs::Api::CareerJet  do
+
+  let(:client) { return HawatelSearchJobs::Client.new }
+  let(:result) {
+    return HawatelSearchJobs::Api::CareerJet.search(
+          :settings => HawatelSearchJobs.careerjet,
+          :query    => { :keywords => 'ruby', :company => '' }
+    )
+  }
+
+  before(:each) do
+    HawatelSearchJobs.configure do |config|
+      config.careerjet[:api]   = 'public.api.careerjet.net'
+    end
+  end
+
+  it "metadata from search() result" do
+    expect(result.totalResults).to be_a_kind_of(Integer)
+    expect(result.page).to be_a_kind_of(Integer)
+    expect(result.last).to be_a_kind_of(Integer)
+    expect(result.key).to be_a_kind_of(String)
+  end
+
+  it "job attributes from search() result" do
+    expect(result.jobs.size).to be > 0
+    result.jobs.each do |job|
+      expect(job.jobtitle).to be_a_kind_of(String)
+      expect(job.url).to include('http')
+    end
+  end
+
+  it "call page() without page param (default 0)" do
+    jobs =  HawatelSearchJobs::Api::CareerJet.page({:query_key => result.key})
+    expect(jobs.page).to eq(0)
+  end
+
+  it "call page() with specified page" do
+    jobs =  HawatelSearchJobs::Api::CareerJet.page({:query_key => result.key, :page => 2})
+    expect(jobs.page).to eq(2)
+  end
+
+  it "call search() with location param" do
+    result =  HawatelSearchJobs::Api::CareerJet.search(:settings => HawatelSearchJobs.careerjet,
+                                                       :query => { :keywords => 'ruby', :location => 'London' })
+    result.jobs.each do |job|
+      expect(job.location).to include("London")
+    end
+  end
+
+
+end