spear-cb-api 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c347867ceceb0398580e288d134eb2aa2b3e9c4a
-  data.tar.gz: 7d488d3e2419fb71060740d8a5f8b6cf25e94942
+  metadata.gz: 29b5f37465df0d5077509166f6c6ddf4a213199c
+  data.tar.gz: c360be2ffff026916b5db1aee3152b5a0973d9e6
 SHA512:
-  metadata.gz: 5350b889086c8cbadea37283ac9507dfbc6c43e1d965246a53e4ea0bb03c08f51447c296b22556161a7227a2ba1cf112fdc0cb1534a0c489908c8cf102d452d4
-  data.tar.gz: 978e149c92640f48eb988ff4a09f8ab072aa6f920c17bc5f8fe9c11faef7314c0861340315db137a07e5f8b79bad0c63aec645c49217ab77f701a8352715edbc
+  metadata.gz: 3a006f99f34b2a912857f5f574de2028f673ffba67662333aff12e07685843d1c1303dd5980392690d98af45984c0a90235f9f0ce92d5e2c27399eaba7e9dbfa
+  data.tar.gz: 8469319fd0519780ac29a35347c0696271516a8e1ae2ae2d73c5ae6b87d94c348aeca4c97cc6cecde7c2c13c5dd297a10fad8637bc8e12831246bc9ba777069c

data/lib/spear.rb

@@ -1,17 +1,70 @@
 # encoding: utf-8
 
-require "spear/version"
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'sucker_punch'
+require 'httparty'
 
 module Spear
-  autoload :AsyncJob, 'spear/async_job'
-  autoload :Client, 'spear/client'
+  autoload :Configuration, 'spear/configuration'
+  autoload :Resources, 'spear/resources'
   autoload :Request, 'spear/request'
 
-  # exception
-  autoload :InvalidClientOptionsException, 'spear/exceptions'
+  autoload :ParametersRequired, 'spear/exceptions'
+  autoload :ParametersNotValid, 'spear/exceptions'
+  autoload :NetworkError, 'spear/exceptions'
+  autoload :ObjectTypeError, 'spear/exceptions'
+
+  module Structure
+    autoload :Base, 'spear/structure/base'
+
+    module User
+      autoload :CheckExisting, 'spear/structure/user/check_existing'
+      autoload :Create, 'spear/structure/user/create'
+      autoload :Retrieve, 'spear/structure/user/retrieve'
+    end
+
+    module Resume
+      autoload :EmbededClass, 'spear/structure/resume/embeded_class'
+      autoload :Create, 'spear/structure/resume/create'
+      autoload :Edit, 'spear/structure/resume/edit'
+      autoload :Ownall, 'spear/structure/resume/ownall'
+      autoload :Parse, 'spear/structure/resume/parse'
+      autoload :Retrieve, 'spear/structure/resume/retrieve'
+      autoload :Upload, 'spear/structure/resume/upload'
+    end
+
+    module Application
+    end
+
+    module Job
+    end
+
+    module TalentNetwork
+    end
+  end
+
+  module Plugins
+    autoload :SaveApis, 'spear/plugins/save_apis'
+    autoload :Models, 'spear/plugins/models'
+
+    module Model
+      autoload :User, 'spear/plugins/model/user'
+      autoload :Resume, 'spear/plugins/model/resume'
+      autoload :Application, 'spear/plugins/model/application'
+      autoload :Job, 'spear/plugins/model/job'
+      autoload :TalentNetwork, 'spear/plugins/model/talent_network'
+    end
+  end
 
   module Resource
     autoload :User, 'spear/resource/user'
     autoload :Resume, 'spear/resource/resume'
+    autoload :Application, 'spear/resource/application'
+    autoload :Job, 'spear/resource/job'
+    autoload :TalentNetwork, 'spear/resource/talent_network'
   end
+
+  extend Configuration
 end

data/lib/spear/configuration.rb

@@ -0,0 +1,62 @@
+module Spear
+  module Configuration
+    include Resources
+
+    @@options = {}
+
+    def test?
+      @@options[:use_test] || false
+    end
+
+    # use https or http
+    def ssh?
+      @@options[:use_ssh] || true
+    end
+
+    def hostname
+      @@options[:hostname] || 'api.careerbuilder.com'
+    end
+
+    def port
+      @@options[:port] || 443
+    end
+
+    def version
+      @@options[:version] || "v2"
+    end
+
+    def dev_key
+      @@options[:dev_key]
+    end
+
+    # need save api info
+    def save_api?
+      @@options[:saving_api] || false
+    end
+
+    def use_model?
+      @@options[:using_model] || false
+    end
+
+    def project
+      @@options[:project]
+    end
+
+    def config(options)
+      raise Spear::ParametersRequired.new('DeveloperKey') if options[:dev_key].nil?
+      raise Spear::ParametersRequired.new('ProjectName') if options[:project].nil?
+
+      @@options = options
+
+      # add plugins to request
+      include_plugins
+    end
+
+    private
+      def include_plugins
+        Request.include Plugins::SaveApis if save_api?
+        Spear.extend Plugins::Models if use_model?
+      end
+
+  end
+end

data/lib/spear/exceptions.rb

@@ -1,3 +1,21 @@
 module Spear
-  class InvalidClientOptionsException < Exception; end
+  class Error < StandardError; end
+
+  class ParametersRequired < Error
+    attr_reader :parameter
+
+    def initialize(parameter)
+      if parameter.kind_of?(Array)
+        @parameter = parameter.join(', ')
+      else
+        @parameter = parameter
+      end
+
+      super("#{@parameter} is required.")
+    end
+  end
+
+  class ParametersNotValid < Error; end
+  class NetworkError < Error; end
+  class ObjectTypeError < Error; end
 end

data/lib/spear/plugins/model/application.rb

@@ -0,0 +1,8 @@
+module Spear
+  module Plugins
+    module Model
+      module Application
+      end
+    end
+  end
+end

data/lib/spear/plugins/model/job.rb

@@ -0,0 +1,8 @@
+module Spear
+  module Plugins
+    module Model
+      module Job
+      end
+    end
+  end
+end

data/lib/spear/plugins/model/resume.rb

@@ -0,0 +1,38 @@
+module Spear
+  module Plugins
+    module Model
+      module Resume
+        def parse_file(file)
+          response = super(file)
+          response = Structure::Resume::Parse.new(response)
+        end
+
+        def create_resume(data={})
+          response = super(data)
+          response = Structure::Resume::Create.new(response)
+        end
+
+        def edit_resume(data={})
+          response = super(data)
+          response = Structure::Resume::Edit.new(response)
+        end
+
+        def upload_file(file, resume_external_id, user_external_id)
+          response = super(file, resume_external_id, user_external_id)
+          response = Structure::Resume::Upload.new(response)
+        end
+
+        def own_all(user_external_id, host_site)
+          response = super(user_external_id, host_site)
+          response = Structure::Resume::Ownall.new(response)
+        end
+
+        def retrieve_resume(resume_external_id, user_external_id)
+          response = super(user_external_id, host_site)
+          response = Structure::Resume::Retrieve.new(response)
+        end
+
+      end
+    end
+  end
+end

data/lib/spear/plugins/model/talent_network.rb

@@ -0,0 +1,8 @@
+module Spear
+  module Plugins
+    module Model
+      module TalentNetwork
+      end
+    end
+  end
+end

data/lib/spear/plugins/model/user.rb

@@ -0,0 +1,23 @@
+module Spear
+  module Plugins
+    module Model
+      module User
+        def check_existing(email, password='')
+          response = super(email, password)
+          Structure::User::CheckExisting.new(response)
+        end
+
+        def create_user(data={})
+          response = super(data)
+          Structure::User::Create.new(response)
+        end
+
+        def retrieve_user(user_external_id, password)
+          response = super(user_external_id, password)
+          Structure::User::Retrieve.new(response)
+        end
+
+      end
+    end
+  end
+end

data/lib/spear/plugins/models.rb

@@ -0,0 +1,11 @@
+module Spear
+  module Plugins
+    module Models
+      include Model::User
+      include Model::Resume
+      include Model::Application
+      include Model::Job
+      include Model::TalentNetwork
+    end
+  end
+end

data/lib/spear/plugins/save_apis.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module Spear
+  module Plugins
+    module SaveApis
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :api_response, :api_started_at, :save_api_instance
+
+        before_execute :record_started_time
+        after_execute :save_infos
+      end
+
+      def record_started_time
+        self.api_started_at = Time.now
+      end
+
+      def save_infos
+        self.save_api_instance ||= AsyncSaveApi.new
+
+        params = {
+          project: Spear.project,
+          request: nil,
+          response: self.api_response.body,
+          method: self.api_response.request.http_method.to_s.split('::').last,
+          url: self.api_response.request.path.to_s,
+          duration: ((Time.now - self.api_started_at).to_f * 1000.0).to_i
+        }
+
+        params[:request] = self.api_response.request.options[:body]
+        if params[:request].kind_of?(String)
+          # parse file api
+          params[:request].gsub!(/<FileBytes>(.*?)<\/FileBytes>/m, '<FileBytes>...</FileBytes>')
+        elsif params[:request].kind_of?(Hash)
+          # upload file api
+          params[:request][:FileBytes] = '...'
+        end
+
+        self.save_api_instance.async.perform(params)
+      end
+
+      class AsyncSaveApi
+        include SuckerPunch::Job
+
+        def perform(options={})
+          HTTParty.post(
+            %q{http://ciws.hilotus.com/api/v1/api-info},
+            :body => {
+              :project => options[:project],
+              :url => options[:url],
+              :method => options[:method],
+              :request => options[:request],
+              :response => options[:response],
+              :duration => options[:duration]
+            }.to_json,
+            :options => {:headers => {'Content-Type' => 'application/json'}}
+          ) rescue options
+        end
+      end
+
+    end
+  end
+end

data/lib/spear/request.rb

@@ -1,75 +1,87 @@
+require 'active_model'
+require 'active_model/callbacks'
+
 module Spear
   class Request
-    attr_reader :client, :resource
+    extend ActiveModel::Callbacks
+    define_model_callbacks :execute, :only => [:before, :after]
+
+    attr_reader :resource
 
-    def initialize(options={})
-      @client = options[:client]
-      @resource = resource
-      @async_job = Spear::AsyncJob.new
+    # params: {:body => {}, :query => {}, :api_options => {}}
+    #   exp: api_options: {:path => "/v1"}
+    def execute(method, endpoint, params={})
+      run_callbacks(:execute) {
+        response = exec(method, endpoint, params)
+        begin
+          self.api_response = response
+        rescue NoMethodError => e  # if we don't use save api info plugin, it'll throw NoMethodError.
+          response
+        end
+      }
     end
 
-    # TODO: custom reqeust headers support.
-    # payload: {:body => {}, :query => {}}
-    def execute(http_method, endpoint, payload={})
-      start_time = Time.now;
-      url = @resource + endpoint;
+    private
+      def exec(method, endpoint, params={})
+        query = params[:query] || {}
+        body = params[:body] || {}
+        api_options = params[:api_options] || {}
+        url = generate_resource(api_options) + endpoint
 
-      case http_method
-      when :get
-        req = splice(payload)
-        resp = HTTParty.get(url, req)
-      when :post
-        req = {:body => to_xml(payload)}
-        resp = HTTParty.post(url, req)
-      when :upload_file
-        req = splice(payload)
-        req[:body] = "file base64 content..."
-        resp = HTTParty.post(url, splice(payload))
-      when :parse_file
-        req = {:body => payload}
-        req[:body][:FileBytes] = nil
-        resp = HTTParty.post(url, :body => to_xml(payload))
-      else
-        resp = {"Errors" => {"Error" => "%q{#{http_method} http method is not support.}"}}
+        begin
+          case method
+          when :get
+            HTTParty.get(url, query: splice_query(query))
+          when :post
+            HTTParty.post(url, body: splice_body(body), query: query)
+          when :upload_file
+            HTTParty.post(url, body: body, query: splice_query(query))
+          when :parse_file
+            HTTParty.post(url, body: splice_body(body))
+          when :apply
+            HTTParty.post(url, body: to_xml(body), query: splice_query(query))
+          else
+            raise Spear::ParametersNotValid.new("#{method} is not support.")
+          end
+        rescue SocketError => e  # if the network is disconnected, it'll throw SocketError.
+          raise Spear::NetworkError.new(e.message)
+        end
       end
 
-      if @client.save_api?
-        options = {
-          project: @client.project,
-          request: req,
-          response: resp.to_h,
-          method: http_method.to_s,
-          url: url,
-          duration: ((Time.now - start_time).to_f * 1000.0).to_i
-        }
-        @async_job.async.perform(options)
-      end
+      # generate cb api host and version
+      def generate_resource(api_options)
+        uri = URI("")
+        uri.scheme = Spear.ssh? ? 'https' : 'http'
+        uri.host = Spear.hostname
+        uri.port = Spear.port
 
-      resp
-    end
+        # Some api endpoint have no version and fixed pattern.
+        if api_options[:path].nil?
+          uri.path = "/#{Spear.version}"
+        else
+          uri.path = "/#{api_options[:path]}"
+        end
 
-    private
-      def resource
-        uri = URI("")
-        uri.scheme = @client.ssh? ? 'https' : 'http'
-        uri.host = @client.hostname
-        uri.port = @client.port
-        uri.path = "/#{@client.version}"
         uri.to_s
       end
 
-      # parse payload to xml format
-      def to_xml(payload)
-        payload[:DeveloperKey] = @client.dev_key
-        payload[:Test] = @client.test?
-        payload = payload.to_xml(root: 'Request', skip_instruct: true, skip_types: true)
+      # splice request body
+      def splice_body(body, xml=true)
+        body[:DeveloperKey] = Spear.dev_key
+        body[:Test] = Spear.test?
+        xml ? to_xml(body) : body
+      end
+
+      # parse body from hash to xml format
+      def to_xml(body)
+        body.to_xml(root: 'Request', skip_instruct: true, skip_types: true)
       end
 
-      # splice payload {:body => {}, :query => {}} with DeveloperKey and Test
-      def splice(payload)
-        payload[:query][:DeveloperKey] = @client.dev_key
-        payload[:query][:Test] = @client.test?
-        payload
+      # splice query(url params) {:query => {}} with DeveloperKey and Test
+      def splice_query(query)
+        query[:DeveloperKey] = Spear.dev_key
+        query[:Test] = Spear.test?
+        query
       end
 
   end