clx_api 0.1.0

data/lib/clx_api/api.rb

@@ -0,0 +1,132 @@
+module CLX
+
+  # Library class for CLX Networks REST API
+  class API
+
+    # @!attribute [r]
+    # Mostly for testing
+    attr_accessor :http_client
+    
+    # Initialize a new API client
+    # @param [String] username
+    # @param [String] password
+    # @param [HTTPAdapter] http_adapter
+    #   Used for testing
+    # @return [CLX::API]
+    # @example
+    #   CLX::API.new 'my_username', 'my_password'
+    def initialize(username, password, http_adapter = nil)
+      http_adapter = http_adapter.nil? ? HTTPAdapter.new : http_adapter
+      http_adapter.set_auth(username, password)
+
+      @http_client = HTTPClient.new(CLX::base_url, http_adapter)
+    end
+
+    # Enables change of credentials after initialization
+    # @param [String] username
+    # @param [String] password
+    def set_auth(username, password)
+      @http_client.http_adapter.set_auth(username, password)
+    end
+
+    # Enables change of base URL after initialization
+    # @param [String] url
+    def set_base_url(url)
+      @http_client.base_url = url
+    end
+
+    # Get all operators from the API
+    # @return [hash] operators
+    #   list of operators as hash.
+    # @example
+    #   clx_api = CLX::API.new 'my_username', 'my_password'
+    #   operators = clx_api.get_operators
+    def get_operators
+      url = CLX.paths[:operator]
+      @http_client.get(url)
+    end
+
+    # Get one operator based on it's operator id
+    # @param [Integer] operator_id Operator ID
+    # @return [hash] operator
+    #   One operator as hash.
+    # @example
+    #   clx_api = CLX::API.new 'my_username', 'my_password'
+    #   operator = clx_api.get_operator(1)
+    def get_operator_by_id(operator_id)
+      valid_id?(operator_id)
+      url = CLX.paths[:operator] + '/' + operator_id.to_s
+      @http_client.get(url)
+    end
+
+    # Get all gateways
+    # @return [hash] gateways
+    #   list of gateways as hash.
+    def get_gateways
+      url = CLX.paths[:gateway]
+      @http_client.get(url)
+    end
+    
+    # Get one gateway based on it's gateway id
+    # @param [Integer] gateway_id Gateway ID
+    # @return [hash] gateway
+    #   One operators as hash.
+    def get_gateway_by_id(gateway_id)
+      valid_id?(gateway_id)
+      url = CLX.paths[:gateway] + '/' + gateway_id.to_s
+      @http_client.get(url)
+    end
+    
+    # Get price entires based on gateway id
+    # @param [Integer] gateway_id Gateway ID
+    # @return [hash] price_entires
+    #   list of price entries as hash.
+    def get_price_entires_by_gateway_id(gateway_id)
+      valid_id?(gateway_id)
+      url = CLX.paths[:gateway] + '/' + gateway_id.to_s + '/price'
+      @http_client.get(url)
+    end
+
+    # Get price entiry based on gateway id and operator id
+    # @param [Integer] gateway_id Gateway ID
+    # @param [Integer] operator_id Operator ID
+    # @return [hash] price_entry
+    #   one price entry as hash.
+    def get_price_entries_by_gateway_id_and_operator_id(gateway_id, operator_id)
+      valid_id?(gateway_id)
+      valid_id?(operator_id)
+      url = CLX.paths[:gateway] + '/' + gateway_id.to_s + '/price/' + operator_id.to_s
+      @http_client.get(url)
+    end
+
+    # Get price entiry based on gateway id, operator id and a date
+    # @param [Integer] gateway_id Gateway ID
+    # @param [Integer] operator_id Operator ID
+    # @param [DateTime] date DateTime
+    # @return [hash] price_entry
+    #   one price entry as hash.
+    def get_price_entries_by_gateway_id_and_operator_id_and_date(gateway_id, operator_id, date)
+      valid_id?(gateway_id)
+      valid_id?(operator_id)
+      valid_date?(date)
+      date_query = "?date=#{date.year}-#{date.month}-#{date.day}"
+      url = CLX.paths[:gateway] + '/' + gateway_id.to_s + '/price/' + operator_id.to_s + '/' + date_query
+      @http_client.get(url)
+    end
+
+    private
+
+      # Validates that in is of type integer and is grater than zero
+      def valid_id?(id)
+        raise CLXException, 'Id must be integer' unless id.is_a? Integer
+        raise CLXException, 'Id must be greater than zero' unless id > 0
+      end
+
+      #Validates that date is of type DateTime
+      def valid_date?(date)
+        raise CLXException, 'Date must be of type DateTime' unless date.is_a? DateTime
+      end
+
+  end
+
+end

data/lib/clx_api/exceptions/clx_api_exception.rb

@@ -0,0 +1,25 @@
+module CLX
+
+  # CLX Exception Class for API request errors
+  class CLXAPIException < Exception
+
+    # @!attribute [r]
+    attr_reader :clx_error_code
+
+    # @!attribute [r]
+    attr_reader :clx_error_message
+
+    # Initialize CLX Exception
+    # @param [String] clx_error_message
+    # @param [Integer] clx_error_code
+    # @example
+    #   response = http_adapter.get('operator/99999999') #results in error from api
+    #   raise CLXException(response.error.message, response.error.body), ""
+    def initialize(clx_error_message = nil, clx_error_code = nil)
+      @clx_error_message = clx_error_message
+      @clx_error_code = clx_error_code
+    end
+
+  end
+
+end

data/lib/clx_api/exceptions/clx_exception.rb

@@ -0,0 +1,8 @@
+module CLX
+
+  # CLX Generic Exception Class
+  class CLXException < Exception
+
+  end
+
+end

data/lib/clx_api/http_adapter.rb

@@ -0,0 +1,129 @@
+require 'uri'
+
+module CLX
+  
+  #HTTP Adapter class for making RESTful HTTP-requests
+  class HTTPAdapter
+
+    # Contains the username used for Basic Auth requests
+    # @!attribute [r]
+    attr_reader :username
+    
+    # Contains the password used for Basic Auth requests
+    # @!attribute [r]
+    attr_reader :password
+
+    # Set credentials for basic auth
+    # @param [String] username
+    # @param [String] password
+    def set_auth(username, password)
+      raise CLXException, 'Username must be a string' unless username.is_a? String
+      raise CLXException, 'Password must be a string' unless password.is_a? String
+      raise CLXException, 'Username can not be an empty string' unless username.length > 0
+      raise CLXException, 'Password can not be an empty string' unless password.length > 0
+      
+      @username = username
+      @password = password
+    end
+
+    # GET-request
+    # @param [URI] uri
+    #   Ruby URI object with full API URL
+    # @return [HTTP::Response]
+    def get(uri)
+      return execute('get', uri)
+    end
+
+    # POST-request
+    #   (Not implemented)
+    # @param [URI] uri
+    #   Ruby URI object with full API URL
+    # @param [Hash] data
+    #   POST-data
+    # @return [HTTP::Response]
+    def post(uri, data)
+      return execute('post', uri, data)
+    end
+
+    # PUT-request
+    #   (Not implemented)
+    # @param [URI] uri
+    #   Ruby URI object with full API URL
+    # @param [Hash] data
+    #   PUT-data
+    # @return [HTTP::Response]
+    def put(uri, data)
+      return execute('put', uri, data)
+    end
+
+    # DELETE-request
+    #   (Not implemented)
+    # @param [URI] uri
+    #   Ruby URI object with full API URL
+    # @return [HTTP::Response]
+    def delete(uri)
+      return execute('delete', uri)
+    end
+
+    private
+
+      # Execute request
+      # @param [String] method
+      # @param [String] uri
+      #   Full API-path
+      # @param [Hash] data
+      # @return [HTTP::Response] result
+      # @raise [CLXException] if he request fails
+      def execute(method, uri, data = nil)
+        raise CLXException, 'uri must be instance of URI' unless uri.instance_of?(URI::HTTPS) || uri.instance_of?(URI::HTTP)
+        request = create_request(method, uri, data)
+        request.basic_auth(@username, @password)
+        http = create_http(uri);
+
+        return http.request(request)
+      end
+
+      # Create Request object by method and uri
+      # @param [String] method
+      #   HTTP
+      # @param [URI] uri
+      # @param [Hash] data
+      # @return [Mixed] request
+      #   Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Put, Net::HTTP::Delete
+      # @example
+      #   request = create_request("GET", 'http://some.url')
+      # @raise [CLXException] If an invalid HTTP-method was passed
+      def create_request(method, uri, data = nil)
+        method = method.upcase
+        if(method == 'GET')
+          return Net::HTTP::Get.new(uri)
+        elsif(method == 'POST')
+          request = Net::HTTP::Post.new(uri)
+          request.body = data.to_json
+          return request
+        elsif(method == 'PUT')
+          request = Net::HTTP::Put.new(uri)
+          request.body = data.to_json
+          return request
+        elsif(method == 'DELETE')
+          return Net::HTTP::Delete.new(uri)
+        else
+          raise CLXException, 'Unknown HTTP method'
+        end
+      end
+
+      # Creates a Net:HTTP instance with ssl activated with URI-object
+      # @param [URI] uri
+      # @return [Net::HTTP] http
+      def create_http(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        if uri.instance_of? URI::HTTPS
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        return http
+      end
+      
+  end
+
+end

data/lib/clx_api/http_client.rb

@@ -0,0 +1,163 @@
+module CLX
+  
+  #HTTP Client class for making RESTful HTTP-requests
+  class HTTPClient
+
+    # Gives access to base_url so this can be modified
+    # @!attribute [rw]
+    attr_accessor :base_url
+
+    # Gives access to the adapter so Auth credentials can be monipulated
+    # @!attribute [rw]
+    attr_accessor :http_adapter
+
+    # Initializer
+    # @param [String] base_url
+    # @param [HTTPAdapter] http_adapter
+    def initialize(base_url, http_adapter)
+      @base_url = base_url
+      @http_adapter = http_adapter
+    end
+
+    # Make a GET-request to specified API-path
+    # @param [String] url
+    #   API-path
+    # @return [hash] result
+    def get(url)
+      uri = get_full_url(url)
+      response = @http_adapter.get(uri)
+      return parseResponse(response)
+    end
+
+    # Make a POST-request to specified API-path
+    #   (Not implemented)
+    # @param [String] url
+    #   API-path
+    # @param [Hash] data
+    #   POST data
+    def post(url, data = nil)
+      uri = get_full_url(url)
+      response = @http_adapter.post(uri, data)
+      return parseResponse(response)
+    end
+
+    # Make a PUT-request to specified API-path
+    #   (Not implemented)
+    # @param [String] url
+    #   API-path
+    # @param [Hash] data
+    #   PUT-data
+    def put(url, data = nil)
+      uri = get_full_url(url)
+      response = @http_adapter.put(uri, data)
+      return parseResponse(response)
+    end
+
+    # Make a DELETE-request to specified API-path
+    #   (Not implemented)
+    # @param [String] url
+    #   API-path
+    def delete(url)
+      uri = get_full_url(url)
+      response = @http_adapter.delete(uri)
+      return parseResponse(response)
+    end
+
+    private
+      
+      # Build the full API request URL
+      # @param [string] url
+      #   API-path
+      # @return [Mixed] uri
+      #   URI::HTTP or URI::HTTPS
+      # @example
+      #   uri = get_full_url('/gateway/1/operator/')
+      def get_full_url(url)
+        full_url = @base_url + url
+        return URI(URI.encode(full_url))
+      end
+
+      # Parse response from a request and return body content as JSON
+      # @param [NET::HTTP::response] response
+      # @return [JSON] json
+      def parseResponse(response)
+
+        begin
+          result = JSON.parse(response.body, object_class: OpenStruct)
+        rescue
+          raise CLXException, 'Unable to parse JSON response'
+        end
+
+        if(response.code.to_i > 399)
+          error_message = (result.error && result.error.message) ? result.error.message : 'No error message available'
+          code = (result.error && result.error.code) ? result.error.code : 'No error code available'
+          raise CLXAPIException.new(error_message, code), '400: Bad request' if response.code == 400
+          raise CLXAPIException.new(error_message, code), '401: Unauthorized' if response.code == 401
+          raise CLXAPIException.new(error_message, code), '403: Forbidden' if response.code == 403
+          raise CLXAPIException.new(error_message, code), '404: Not Found' if response.code == 404
+          raise CLXAPIException.new(error_message, code), 'Unknown error'
+        end
+
+        return result
+      end
+
+      #################################
+      # Currently unused helper methods
+      #################################
+
+      # # Method for validating URL's
+      # # @param [String] url
+      # # @return [Boolean]
+      # # @raise [CLXException]
+      # def valid_url?(url)
+      #   raise CLXException, 'url can not be an empty string' if url.to_s.strip.length == 0
+      #   # Seems to accept any string as a valid url, might need some work
+      #   !!URI.parse(url)
+      #   rescue URI::InvalidURIError
+      #     raise CLXException, format('URL: "%s" is not a valid url', url)
+      # end
+
+      # # Encodes passed mixed variable to a URL-encoded query string
+      # # @param [Mixed] params
+      # #   String, Hash or Array
+      # # @return [String] query_string
+      # # @example
+      # #   date = 'date=2014-01-01'
+      # #   encoded_date = url_encode(date)
+      # # @example
+      # #   param_hash = {my_date: '2014-01-01', my_string: 'a string', my_int: 1}
+      # #   encoded_params = url_encode(param_hash)
+      # def url_encode(params)
+      #   return URI.encode(params) if params.instance_of? String
+
+      #   if params.instance_of?(Hash) || params.instance_of?(Array)
+      #     return '' if params.size == 0
+
+      #     ret = ''
+      #     params.each do | key, value |
+      #       ret += format('&%s=%s', key, value)
+      #     end
+
+      #     return ret[1..-1]
+      #   end
+        
+      #   return ''
+      # end
+
+      # # Tries to validate that parameter argument is in the correct format: String, Array or Hash
+      # # @param [Mixed] params
+      # # @return [Boolean]
+      # # @raise [CLXException]
+      # def valid_params?(params)
+      #   if params != nil
+      #     if params.is_a?(String) || params.is_a?(Hash) || params.is_a?(Array)
+      #       return true
+      #     else
+      #       raise CLXException, 'params must be String, Hash or Array'
+      #     end
+      #   end
+      # end
+
+  end
+
+end