kaze_client 0.1.1

data/lib/kaze_client/client.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Execute a KazeClient::Request, stores the server's base URL, the request and the response.
+  # @see KazeClient::Request
+  # @see KazeClient::Response
+  # @since 0.1.0
+  class Client
+    # @return [String] The server's base URL (e.g. https://app.kaze.so)
+    attr_reader :base_url
+    # @return [String,nil] The last authentication token
+    # @see KazeClient::Client#login
+    attr_reader :token
+
+    # @param base_url [String] The server's base URL (e.g. https://app.kaze.som)
+    def initialize(base_url)
+      @base_url = base_url
+      @token    = nil
+      @login    = nil
+      @password = nil
+    end
+
+    # Execute a request
+    #
+    # If the request needs authentication (meaning it includes KazeClient::Utils::AuthentifiedRequest)
+    # it sets the authentication token.
+    #
+    # @see KazeClient::Client#login
+    # @param request [KazeClient::Request] The request to execute
+    # @return [KazeClient::Response] The response from the server
+    # @raise [KazeClient::Error::NoEndpoint] if the base URL is blank
+    # @raise [KazeClient::Error::Generic] if the response is not a success: not a 2xx HTTP status
+    def execute(request)
+      if request.is_a?(Utils::AuthentifiedRequest) && request.token.nil?
+        login if @token.nil?
+
+        request.with_token(@token)
+      end
+
+      do_execute(request)
+    end
+
+    # Stores the given login and password, stores the token received from authentication.
+    #
+    # @param login [String] The user login.
+    # @param password [String] The user password.
+    # @return [KazeClient::Response] The response from the server
+    # @raise [KazeClient::Error::NoEndpoint] if the base URL is blank
+    # @raise [KazeClient::Error::Generic] if the response is not a success: not a 2xx HTTP status
+    # @see KazeClient::Client#do_execute
+    def login(login = @login, password = @password)
+      # Impossible to login using nil login or password.
+      # The first call to #login must be given a login and a password.
+      raise KazeClient::Error::InvalidCredentials, "Please set login and password" if login.nil? || password.nil?
+
+      request = KazeClient::LoginRequest.new(login: login, password: password)
+
+      response = do_execute(request)
+
+      # Store the token for next request and the login/password for next call
+      @token    = response["token"]
+      @login    = login
+      @password = password
+
+      response
+    end
+
+    private
+
+    # @param request [KazeClient::Request] The request which was executed
+    # @return [true] if the response is a success: 2xx HTTP status
+    # @raise [KazeClient::Error::Generic] if the response is not a success: not a 2xx HTTP status
+    def handle_errors(request)
+      return true if @response.success?
+
+      raise request.error_for(@response)
+    end
+
+    # @param request [KazeClient::Request] The request to execute
+    # @return [KazeClient::Response] The response from the server
+    # @raise [KazeClient::Error::NoEndpoint] if the base URL is blank
+    # @raise [KazeClient::Error::Generic] if the response is not a success: not a 2xx HTTP status
+    def do_execute(request)
+      raise Error::NoEndpoint, @base_url if @base_url.blank?
+
+      @request = request
+
+      request_url = "#{@base_url}/#{request.url}"
+      @response   = HTTParty.send(request.method, request_url, **@request.parameters)
+
+      # This will raise if the response is not a success: not a 2xx HTTP status
+      handle_errors(request)
+
+      # Build the response object from the HTTParty response
+      Response.new(@response)
+    end
+  end
+end

data/lib/kaze_client/error/disabled_account.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # 403 error sent by Kaze server when trying to log in with a disabled account
+    class DisabledAccount < Forbidden
+      def initialize(msg = "User account was disabled by administrator")
+        super(msg)
+      end
+    end
+  end
+end

data/lib/kaze_client/error/forbidden.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # Generic 403 error sent by Kaze server
+    class Forbidden < Generic
+      def initialize(msg = "403 Forbidden")
+        super(status: :forbidden, message: msg)
+      end
+    end
+  end
+end

data/lib/kaze_client/error/generic.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @since 0.1.0
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # Generic error raised when Kaze server send an unknown error. By default, it is considered
+    # to be an internal server error.
+    class Generic < RuntimeError
+      # @return [Symbol] The HTTP status sent by the server
+      attr_reader :status
+
+      # @return [String] if the server sent a custom error code
+      # @return [Symbol] if the server sent no code, it is the HTTP status sent by the server
+      attr_reader :error
+
+      # The default error message
+      DEFAULT_MESSAGE = "An unknown error occured"
+
+      def initialize(status: :internal_server_error, error: nil,
+                     message: DEFAULT_MESSAGE)
+        super(message || DEFAULT_MESSAGE)
+
+        @status = status || :internal_server_error
+        @error  = error || @status
+      end
+    end
+  end
+end

data/lib/kaze_client/error/internal_server_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # Generic 500 error sent by Kaze server
+    class InternalServerError < Generic
+      def initialize(msg = "An unknown error occured")
+        super(message: msg)
+      end
+    end
+  end
+end

data/lib/kaze_client/error/invalid_credentials.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # 401 error sent by Kaze server when trying to log in with invalid credentials
+    class InvalidCredentials < Unauthorized
+      def initialize(msg = "Invalid Login or Password")
+        super(msg)
+      end
+    end
+  end
+end

data/lib/kaze_client/error/no_endpoint.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # An error raised when the base URL given to the +KazeClient::Client+ is nil
+    # @see KazeClient::Client
+    class NoEndpoint < Generic
+      # @return the given base URL
+      attr_reader :base_url
+
+      def initialize(base_url)
+        super(status: nil, message: "Invalid base url +#{base_url}+", error: nil)
+
+        @base_url = base_url
+      end
+    end
+  end
+end

data/lib/kaze_client/error/no_private_token.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # 403 error sent by Kaze server when trying to log in and user has no token
+    class NoPrivateToken < Forbidden
+      def initialize(msg = "User has no private token assigned")
+        super(msg)
+      end
+    end
+  end
+end

data/lib/kaze_client/error/not_found.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # 404 error sent by Kaze server
+    class NotFound < Generic
+      def initialize(msg = "404 Not Found")
+        super(status: :not_found, message: msg)
+      end
+    end
+  end
+end

data/lib/kaze_client/error/unauthorized.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Error
+    # @author ciappa_m@modulotech.fr
+    # Generic 401 error sent by Kaze server
+    class Unauthorized < Generic
+      def initialize(msg = "401 Unauthorized")
+        super(status: :unauthorized, message: msg)
+      end
+    end
+  end
+end

data/lib/kaze_client/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Require the error classes
+require_relative "error/generic"
+require_relative "error/unauthorized"
+require_relative "error/forbidden"
+require_relative "error/not_found"
+require_relative "error/internal_server_error"
+require_relative "error/disabled_account"
+require_relative "error/invalid_credentials"
+require_relative "error/no_endpoint"
+require_relative "error/no_private_token"

data/lib/kaze_client/request/request.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Represents request to a Kaze API
+  # @see KazeClient::Client
+  # @see KazeClient::Response
+  # @since 0.1.0
+  class Request
+    # Those headers are added on all requests by default
+    DEFAULT_HEADERS = {
+      "Content-Type" => "application/json",
+      "Accept" => "application/json"
+    }.freeze
+
+    # @return [String, Symbol] The HTTP verb to use for the request
+    # @example Common HTTP verbs
+    #   [:get, :post, :put, :patch, :delete]
+    attr_reader :method
+
+    # @return [String] The API endpoint
+    # @example To get the list of companies
+    #   '/api/companies'
+    attr_reader :url
+
+    # @return [nil, Hash] The query parameters for the request
+    # @example Page parameters from KazeClient::Utils::ListRequest
+    #   { page: 1, per_page: 20 }
+    attr_accessor :query
+
+    # @return [nil, Hash, String] The body for the request
+    # @example Login data from KazeClient::LoginRequest
+    #   { user: { login: 'test', password: 'test' } }
+    #   "{\"user\":{\"login\":\"test\",\"password\":\"test\"}}"
+    attr_accessor :body
+
+    # @return [nil, Hash] The headers for the request
+    # @example Default headers from any KazeClient::Request
+    #   { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+    attr_accessor :headers
+
+    # @param method [Symbol] The HTTP verb to use for the request (e.g. :get)
+    # @param url [String] The API endpoint (e.g. /jobs)
+    def initialize(method, url)
+      @method  = method
+      @url     = url
+      @query   = nil
+      @body    = nil
+      @headers = {}
+    end
+
+    # @return [Hash] The arguments to give to the HTTParty call
+    # @example For instance, when +@body+ is blank
+    #   {
+    #     query: { page: 1, per_page: 20 },
+    #     headers: { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+    #   }
+    def parameters
+      {
+        query: make_query, body: make_body, headers: make_headers
+      }.reject { |_k, v| v.blank? }
+    end
+
+    # @param response [HTTParty::Response] The response object from HTTParty call
+    # @return [KazeClient::Error::Generic] The adequate error object according to the given response
+    def error_for(response)
+      # Not found is handled in a specific way since there is no message key and the error has a
+      # specific format
+      return KazeClient::Error::NotFound.new if response.code == 404
+
+      # Return the adequate error class for the error code in the response
+      "KazeClient::Error::#{response.parsed_response["error"].camelize}"
+        .constantize.new(response.parsed_response["message"])
+    rescue NameError
+      # This means no error class exists for the error code in the response, we fallback to a
+      # generic error
+      Error::Generic.new(status: response.code,
+                         error: response.parsed_response["error"],
+                         message: response.parsed_response["message"])
+    end
+
+    protected
+
+    # @return [Hash] The headers for the request
+    #   If +@headers+ is blank or is not a Hash, it returns the +DEFAULT_HEADERS+. Else it merges
+    #   the +DEFAULT_HEADERS+ with +@headers+ allowing +@headers+ to override +DEFAULT_HEADERS+.
+    def make_headers
+      return DEFAULT_HEADERS if @headers.blank? || !@headers.is_a?(Hash)
+
+      DEFAULT_HEADERS.merge(@headers)
+    end
+
+    # @return [nil, String] The body for the request
+    #   +String+ will be sent as-is while +Hash+ will be transformed to a JSON string.
+    def make_body
+      return nil if @body.blank?
+
+      case @body
+      when String
+        @body
+      when Hash
+        @body.to_json
+      end
+    end
+
+    # @return [nil, Hash] The query parameters for the request
+    def make_query
+      return nil if @query.blank?
+
+      @query
+    end
+  end
+end

data/lib/kaze_client/request/requests/assign_performer_request.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Assign a performer to the given job.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @since 0.1.0
+  class AssignPerformerRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+
+    def initialize(id, performer_user_id)
+      super(:post, "api/jobs/#{id}/performers")
+
+      @body = {
+        job: {
+          performer_user_id: performer_user_id.to_s
+        }
+      }
+    end
+  end
+end

data/lib/kaze_client/request/requests/companies_request.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Request the list of companies.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @see KazeClient::Utils::ListRequest
+  # @since 0.1.0
+  class CompaniesRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+    include Utils::ListRequest
+
+    def initialize
+      super(:get, "api/companies")
+    end
+  end
+end

data/lib/kaze_client/request/requests/create_job_request.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Create a job from the current user to the target company.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @since 0.1.0
+  class CreateJobRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+
+    # @return [String] The id of the target company.
+    attr_reader :target_id
+
+    # @return [Hash] The workflow used to create the job.
+    attr_reader :workflow
+
+    # @param target_id [String] The id of the target company.
+    # @param workflow [Hash] The workflow to use to create the job.
+    def initialize(target_id, workflow)
+      super(:post, "api/jobs")
+
+      @target_id = target_id
+      @workflow  = workflow
+      @body      = {
+        target_id: @target_id,
+        workflow: @workflow
+      }
+    end
+  end
+end

data/lib/kaze_client/request/requests/job_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Fetch the details for the given job id.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @since 0.1.0
+  class JobRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+
+    def initialize(id)
+      super(:get, "api/jobs/#{id}")
+    end
+  end
+end

data/lib/kaze_client/request/requests/job_workflow_request.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Request the details about a specific workflow.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @since 0.1.0
+  class JobWorkflowRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+
+    # @return [String] The id of the workflow to request
+    attr_reader :id
+
+    # @param id [String] Set the id of the workflow to request
+    def initialize(id)
+      super(:get, "api/job_workflows/#{id}")
+
+      @id      = id
+      @query   = {}
+      @filters = {}
+    end
+  end
+end

data/lib/kaze_client/request/requests/job_workflows_request.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Request the list of job workflows for the current user.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @see KazeClient::Utils::ListRequest
+  # @since 0.1.0
+  class JobWorkflowsRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+    include Utils::ListRequest
+
+    def initialize
+      super(:get, "api/job_workflows")
+    end
+  end
+end

data/lib/kaze_client/request/requests/jobs_request.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # List the jobs assigned to the current user's company.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @since 0.1.0
+  class JobsRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+    include Utils::ListRequest
+
+    def initialize
+      super(:get, "api/jobs")
+    end
+  end
+end

data/lib/kaze_client/request/requests/login_request.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Authenticate a user on the server.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @since 0.1.0
+  class LoginRequest < Utils::FinalRequest
+    # @return [String] The user login.
+    attr_reader :login
+
+    # @param login [String] The user login.
+    # @param password [String] The user password.
+    def initialize(login:, password:)
+      super(:post, "api/login")
+
+      @login    = login
+      @password = password
+      @body     = {
+        user: {
+          login: @login,
+          password: @password
+        }
+      }
+    end
+  end
+end

data/lib/kaze_client/request/requests/profile_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Request data about the current user.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @since 0.1.0
+  class ProfileRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+
+    def initialize
+      super(:get, "api/profile")
+    end
+  end
+end

data/lib/kaze_client/request/requests/update_template_request.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @author ciappa_m@modulotech.fr
+  # Update data of the given template on the given job.
+  # @see KazeClient::Request
+  # @see KazeClient::Utils::FinalRequest
+  # @see KazeClient::Utils::AuthentifiedRequest
+  # @since 0.1.0
+  class UpdateTemplateRequest < Utils::FinalRequest
+    include Utils::AuthentifiedRequest
+
+    def initialize(id, template_id, body)
+      super(:put, "api/performer/jobs/#{id}/templates/#{template_id}")
+
+      @body = body
+    end
+  end
+end

data/lib/kaze_client/request/requests/utils/authentified_request.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module KazeClient
+  # @since 0.1.0
+  module Utils
+    # @author ciappa_m@modulotech.fr
+    # Included by the request where an authentication token is required.
+    # @see KazeClient::Request
+    module AuthentifiedRequest
+      # @return [String] The authentication token
+      attr_reader :token
+
+      # Store the given authentication token and use it to set the +Authorization+ header of the
+      # request.
+      # @param token [String] The authentication token
+      # @return [KazeClient::Utils::AuthentifiedRequest] self (to chain methods)
+      def with_token(token)
+        @token                    = token
+        @headers["Authorization"] = token
+
+        self
+      end
+    end
+  end
+end

data/lib/kaze_client/request/requests/utils/final_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module KazeClient
+  module Utils
+    # @author ciappa_m@modulotech.fr
+    # Set the request as final, disabling the edition of query parameters, headers and request body.
+    # @see KazeClient::Request
+    class FinalRequest < Request
+      # Remove write access inherited from Request
+      undef_method :query=, :body=, :headers=
+    end
+  end
+end