mxhero-api 0.1.11 → 0.1.12

data/VERSION

@@ -1 +1 @@
-0.1.11
+0.1.12

data/lib/communication.rb

@@ -0,0 +1,35 @@
+module MxHero
+  module API
+    module Communication
+      
+      # Make a HTTP call 
+      # @param method [Symbol] indicate the HTTP verb (:get, :post, :put, etc)
+      # @param url [String]
+      # @param body [String] (default: nil)
+      # @param [Hash] more_options
+      # @option more_options [Boolean] :throw_exception (default: true) throw exception if the response status are between 500 and 600
+      def call(method, url, body = nil, more_options = {})
+        unless @client
+          @client ||= HTTPClient.new
+        end
+        @client.set_auth(url, @username, @password)
+        response = @client.request(method, url, nil, body, headers)
+        unless more_options[:throw_exception] == false
+          raise "An error ocurred when try to communicate with the API\nError: #{response.inspect}" if (500..600).include?(response.status)
+        end
+        response
+      end
+
+      # Default headers
+      def headers
+        @headers ||= { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
+      end
+      
+      # @return [Hash]
+      def json_parse(json)
+        JSON.parse(json, symbolize_names: true)
+      end
+
+    end
+  end
+end

data/lib/groups.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+require_relative 'communication'
+require_relative 'urls'
+
+require 'delegate'
+
+module MxHero::API
+
+  # A group instance
+  #
+  class Group < Struct.new(:name, :domain, :description)
+    def initialize(elements)
+      elements.each { |prop, value| send("#{prop}=", value) if respond_to?("#{prop}") }
+    end
+
+    def to_json
+      { name: name, domain: domain, description: description }.to_json
+    end
+  end
+
+
+  class Account < Struct.new(:account, :domain, :created_date, :updated_date, :group)
+    def initialize(elements)
+      elements.each { |prop, value| send("#{prop}=", value) if respond_to?("#{prop}") }
+    end
+
+    def to_json
+      { account: account, domain: domain, createdDate: created_date, updatedDate: updated_date, group: group }.to_json
+    end
+
+    def to_s
+      "account: #{account}, domain: #{domain}, group: #{group}" 
+    end
+  end
+
+
+  class PaginatedElements < SimpleDelegator
+    attr_reader :total_elements, :total_pages, :actual_page
+    def initialize(paginable, total_elements, total_pages, actual_page)
+      super(paginable)
+      @total_elements = total_elements
+      @total_pages = total_pages
+      @actual_page = actual_page
+    end
+  end
+
+  class Groups
+    include Communication
+    include Urls
+
+    attr_reader :domain
+
+    def initialize(domain, config = {})
+      @domain = domain
+      @service_url = config[:api_url]
+      @username = config[:username]
+      @password = config[:password]
+      @verbose = config[:verbose] || false
+    end
+
+    # Retrieve all the groups
+    #
+    # @return [PaginatedElement] that contains an array of Group elements
+    #   Basically its an Array with instances of [MxHero::API::Group] with the methods total_elements, total_pages and actual_page  
+    def all(limit = nil, offset = nil)
+      response = call(:get, groups_url)
+      paginate_wrap(response) do |hash|
+        hash[:elements].map { |e| Group.new(e) }
+      end
+    end
+
+    # Save a new group
+    #
+    # @param group [MxHero::API::Group]
+    #
+    # @return [MxHero::API::Response]
+    def save(group)
+      group.domain = domain
+      wrap_response_from call(:post, groups_url, group.to_json)
+    end
+
+    # Delete the group
+    #
+    # @param group_name [String]
+    #
+    # @return [MxHero::API::Response] with content empty. 
+    #   In case on error, may be one of the following: 
+    #     + domain.group.not.found : Inexistent group
+    def delete(group_name)
+      response = call(:delete, group_url(group_name), nil, throw_exception: false)
+      wrap_response_from response
+    end
+
+    # Retrieve all the accounts for one group
+    #
+    # @param group_name [String]
+    #
+    # @return [MxHero::API::PaginatedElements] the list of accounts [MxHero::API::Account]
+    def accounts(group_name)
+      response = call(:get, group_accounts_url(group_name))
+      paginate_wrap response do |hash|
+        hash[:elements].map { |e| Account.new(e) }
+      end
+    end
+
+    # Add an account to a group
+    #
+    # @param group_name [String]
+    # @param account_name [String]
+    #
+    # @return [MxHero::API::Response] with content empty. 
+    #   In case on error, may be one of the following: 
+    #     + domain.account.not.found                : Inexistent account
+    #     + domain.group.account.already.has.group  : Try to add an account to a group when already is in that
+    def add_account(group_name, account_name)
+      response = call(:post, group_add_accounts_url(group_name, account_name), nil, throw_exception: false)
+      wrap_response_from response
+    end
+
+    # @param group_name [String]
+    # @param account_name [String]
+    #
+    # @return [MxHero::API::Response] with content empty. 
+    #   In case on error, may be one of the following: 
+    #     + domain.account.not.found            : Inexistent account
+    #     + domain.group.account.not.in.group   : Try to remove an account that is not in the group
+    #     
+    def remove_account(group_name, account_name)
+      response = call(:delete, group_remove_accounts_url(group_name, account_name), nil, throw_exception: false)
+      wrap_response_from response
+    end
+
+    private 
+
+    def paginate_wrap(response, &block)
+      raise 'an error ocurred when try to communicate with the API' if response.status != 200
+      hash = json_parse(response.content)
+      PaginatedElements.new(block ? block.call(hash) : hash[:elements], hash[:totalElements], hash[:totalPages], hash[:actualPage])
+    end
+
+    def wrap_response_from(response)
+      content = (200..299).include?(response.code) ? group_from(response) : json_parse(response.content)
+      Response.new(response.status, content) 
+    end
+
+    def group_from(response)
+      return nil if response.content.nil? || response.content.empty?
+      hash = json_parse response.content
+      Group.new hash
+    end
+
+    def parse_elements(hash)
+      hash[:elements].map { |e| Group.new(e) }
+    end
+
+    def groups_url
+      domain_by_id_url(domain) + 'groups'
+    end
+    
+    def group_url(group_name)
+      groups_url + "/#{group_name}"
+    end
+
+    def group_accounts_url(group_name)
+      group_url(group_name) + "/accounts"
+    end
+
+    def group_add_accounts_url(group_name, account_name)
+      group_accounts_url(group_name) + "/#{account_name}/add"
+    end
+    
+    def group_remove_accounts_url(group_name, account_name)
+      group_accounts_url(group_name) + "/#{account_name}/remove"
+    end
+  end
+
+
+end

data/lib/mxhero-api.rb

@@ -1,347 +1,323 @@
+# encoding: utf-8
 require 'httpclient'
 require 'json'
 
-module MxHero
-  
-  module API
-    
-    # The class that contains the response information
-    #
-    # The *code* represent the HTTP code of the response.
-    #
-    # The *msg* represent a hash with the response information. Example: 
-    #     
-    #     { status: 500, code: 500, developerMessage: "rules.already.exists.for.component", moreInfoUrl: "mailto:support@mxhero.com" }
-    #
-    class Response < Struct.new(:code, :msg)
-
-      # Response is successful? Based in HTTP status code
-      def success?
-        code.to_i == 200 || code.to_i == 201      
-      end
+require_relative 'communication'
+require_relative 'urls'
+
+module MxHero::API
+  # The class that contains the response information
+  #
+  # The *code* represent the HTTP code of the response.
+  #
+  # The *msg* represent a hash with the response information. Example:
+  #
+  #     { status: 500, code: 500,
+  #       developerMessage: "rules.already.exists.for.component",
+  #       moreInfoUrl: "mailto:support@mxhero.com" }
+  #
+  class Response < Struct.new(:code, :msg)
+
+    # Response is successful? Based in HTTP status code
+    def success?
+      code.to_i == 200 || code.to_i == 201
     end
-    
-    
-    # A client to interact with mxhero engine API
-    class Client
-
-      # @param [Hash] config the options of configuration
-      # @option config [String] :api_url The URL to consume the API
-      # @option config [String] :username The username for access the API
-      # @option config [String] :password The password for the user that access the API
-      # @option config [Boolean] :verbose (false) If true puts information about http operations
-      def initialize(config = {})
-        @service_url = config[:api_url]
-        @username = config[:username]
-        @password = config[:password]
-        @verbose = config[:verbose] || false
-      end
 
-      # Find a rule by domain and ID
-      #
-      # @param domain [String]
-      # @param id [Integer] the rule id
-      #
-      # @return [Hash, nil] the Rule information or nil if not exist
-      #
-      # @raise an exception when the status code isn't 200
-      def domain_rule(domain, id)
-        url = domain_rule_url(domain, id)
-        response = call(:get, url)
-        raise 'an error ocurred when try to communicate with the API' if response.status != 200
-        json_parse(response.content)
-      end
-
-      # Update a rule
-      # @return [MxHero::API::Response] When the rule is update correctly then return MxHero::API::Response object without msg (msg nil)
-      #   In case of error, the message is completed with the cause of error
-      def update_rule(rule)
-        url = domain_rule_url(rule[:domain], rule[:id])
-        response = call(:put, url, rule.to_json)
-        parse_response(response)
-      end
-
-      # Retrive all the domains
-      #
-      # TODO: Improve the response. We really need manage pagination here?
-      #
-      # @return [Hash] with the list of domains
-      #   * :elements [Array<Hash>] the list of domains as a Hash, when any element contains:
-      #     * :domain [String]
-      #     * :server [String]
-      #     * :creationDate [Fixnum]
-      #     * :updateDate [Fixnum]
-      #     * :aliases 
-      #     * :ldap
-      #   * :totalElements
-      #   * :totalPages
-      #   * :actualPage
-      #
-      # @raise an exception when the status code isn't 200
-      def domains
-        response = call(:get, domains_url)
-        raise 'an error ocurred when try to communicate with the API' if response.status != 200
-        response_as_a_hash = json_parse(response.content)
-        response_as_a_hash 
-      end
-
-      # Retrive the domain by id according to the parameter if exist
-      #
-      # @param id The domain name or id. For example: 'mydomain.com'
-      # @return [Hash] with the domain attributes if exist
-      #   * :domain [String]
-      #   * :server [String]
-      #   * :creationDate [Fixnum]
-      #   * :updateDate [Fixnum]
-      #   * :aliases 
-      #   * :ldap
-      # @raise an exception when the status code is one of the 5xx status error
-      # @raise an exception if @param id is nil
-      def domain_by_id(id = nil)
-        raise 'Id domain could not be nil' if id.nil?
-        response = call(:get, domain_by_id_url(id))
-        response_as_a_hash = json_parse(response.content)
-        response_as_a_hash 
-      end
+    alias_method :content, :msg
+    alias_method :content=, :msg=
+  end
 
-     
-      def verbose?
-        @verbose
-      end
+  # A client to interact with mxhero engine API
+  class Client
+    include Communication
+    include Urls
+
+    # @param [Hash] config the options of configuration
+    # @option config [String] :api_url The URL to consume the API
+    # @option config [String] :username The username for access the API
+    # @option config [String] :password The password for the user that access the API
+    # @option config [Boolean] :verbose (false) If true puts information about http operations
+    def initialize(config = {})
+      @service_url = config[:api_url]
+      @username = config[:username]
+      @password = config[:password]
+      @verbose = config[:verbose] || false
+    end
 
-      def verbose=(verbose)
-        @verbose = verbose
-      end
+    # Find a rule by domain and ID
+    #
+    # @param domain [String]
+    # @param id [Integer] the rule id
+    #
+    # @return [Hash, nil] the Rule information or nil if not exist
+    #
+    # @raise an exception when the status code isn't 200
+    def domain_rule(domain, id)
+      url = domain_rule_url(domain, id)
+      response = call(:get, url)
+      raise 'an error ocurred when try to communicate with the API' if response.status != 200
+      json_parse(response.content)
+    end
 
-      # @param domain [String]
-      # @param [Hash] msg 
-      # @option msg [String]      :domain
-      # @option msg [Boolean]     :twoWays
-      # @option msg [Boolean]     :enabled
-      # @option msg [String]      :name
-      # @option msg [Integer]     :created in epoch format
-      # @option msg [Hash]        :fromDirection
-      # @option msg [Hash]        :toDirection
-      # @option msg [Array<Hash>] :properties
-      # @option msg [String]      :component
-      #
-      # @return [MxHero::API::Response]
-      def create_rule_for_domain(domain, msg)
-        url = rules_for_domain_url(domain)
-        response = call(:post, url, msg.to_json, throw_exception: false)
-        parse_response(response)
-      end
-    
-      # Create a rule
-      #
-      # @param [Hash] msg 
-      # @option msg [String]      :domain
-      # @option msg [Boolean]     :twoWays
-      # @option msg [Boolean]     :enabled
-      # @option msg [String]      :name
-      # @option msg [Integer]     :created in epoch format
-      # @option msg [Hash]        :fromDirection
-      # @option msg [Hash]        :toDirection
-      # @option msg [Array<Hash>] :properties
-      # @option msg [String]      :component
-      #
-      # @return [MxHero::API::Response]
-      def create_rule(msg)
-        response = call(:post, rules_url, msg.to_json, throw_exception: false)
-        parse_response(response)
-      end
+    # Update a rule
+    # @return [MxHero::API::Response] When the rule is update correctly then return MxHero::API::Response object without msg (msg nil)
+    #   In case of error, the message is completed with the cause of error
+    def update_rule(rule)
+      url = domain_rule_url(rule[:domain], rule[:id])
+      response = call(:put, url, rule.to_json)
+      parse_response(response)
+    end
 
-      # Retrieve all the rules for one domain
-      #
-      # @param [String] domain
-      # @param [String] component Filter the list of rules by this component [optional]
-      #
-      # @return [MxHero::API::Response] reponse
-      #   the key :msg contains an array of rules for the domain.
-      def rules_for_domain(domain, component = nil)
-        url = rules_for_domain_url(domain)
-        url << "?component=#{component}" if component
-        response = call(:get, url)
-        parse_response(response, on_empty: [])
-      end
+    # Retrive all the domains
+    #
+    # TODO: Improve the response. We really need manage pagination here?
+    #
+    # @return [Hash] with the list of domains
+    #   * :elements [Array<Hash>] the list of domains as a Hash, when any element contains:
+    #     * :domain [String]
+    #     * :server [String]
+    #     * :creationDate [Fixnum]
+    #     * :updateDate [Fixnum]
+    #     * :aliases 
+    #     * :ldap
+    #   * :totalElements
+    #   * :totalPages
+    #   * :actualPage
+    #
+    # @raise an exception when the status code isn't 200
+    def domains
+      response = call(:get, domains_url)
+      raise 'an error ocurred when try to communicate with the API' if response.status != 200
+      response_as_a_hash = json_parse(response.content)
+      response_as_a_hash 
+    end
 
-      #
-      # Retrive all the account from one domain
-      #
-      # @params [String] domain
-      # @params [String] filter_account the account to filter in the list. This can be a part of an account. 
-      # @param [Hash] refinement 
-      # @option refinement [Fixnum] :limit of elements per page
-      # @option refinement [Fixnum] :offset number of page (start in 1)
-      # @option refinement [String] :account filter accounts that start with this value
-      #
-      #
-      # @return [Hash] with the following elements:
-      #   * :elements [Array<Hash>] the list of accounts as a Hash, when any element contains:
-      #     * :account [String] example: alex
-      #     * :domain [String] example: mxhero.com
-      #     * :createdDate [Fixnum] example: 1375909565000 (epoch format)
-      #     * :updatedDate [Fixnum]
-      #     * :group [String]
-      #     * :aliases [Array<Hash>] the list of aliases of one account
-      #       * :name [String]
-      #       * :domain [String]
-      #       * :dataSource [String]
-      #     * :dataSource [String]
-      #   * :totalElements [Fixnum]
-      #   * :totalPages [Fixnum]
-      #   * :actualPage [Fixnum]
-      #
-      # @raise an exception when the status code isn't 200
-      def accounts_by_domain(domain, refinement = {}) #filter_account = nil, pagination = {})
-        params = refinement.dup
-        filter_account = params.delete(:account)
-        limit, offset = params.values_at(:limit, :offset)
+    # Retrive the domain by id according to the parameter if exist
+    #
+    # @param id The domain name or id. For example: 'mydomain.com'
+    # @return [Hash] with the domain attributes if exist
+    #   * :domain [String]
+    #   * :server [String]
+    #   * :creationDate [Fixnum]
+    #   * :updateDate [Fixnum]
+    #   * :aliases 
+    #   * :ldap
+    # @raise an exception when the status code is one of the 5xx status error
+    # @raise an exception if @param id is nil
+    def domain_by_id(id = nil)
+      raise 'Id domain could not be nil' if id.nil?
+      response = call(:get, domain_by_id_url(id))
+      response_as_a_hash = json_parse(response.content)
+      response_as_a_hash 
+    end
 
+    #
+    # Retrive all the account from one domain
+    #
+    # @params [String] domain
+    # @params [String] filter_account the account to filter in the list. This can be a part of an account. 
+    # @param [Hash] refinement 
+    # @option refinement [Fixnum]  :limit of elements per page
+    # @option refinement [Fixnum]  :offset number of page (start in 1)
+    # @option refinement [String]  :account filter accounts that start with this value
+    # @option refinement [Boolean] :without_group filter accounts without group
+    #
+    #
+    # @return [Hash] with the following elements:
+    #   * :elements [Array<Hash>] the list of accounts as a Hash, when any element contains:
+    #     * :account [String] example: alex
+    #     * :domain [String] example: mxhero.com
+    #     * :createdDate [Fixnum] example: 1375909565000 (epoch format)
+    #     * :updatedDate [Fixnum]
+    #     * :group [String]
+    #     * :aliases [Array<Hash>] the list of aliases of one account
+    #       * :name [String]
+    #       * :domain [String]
+    #       * :dataSource [String]
+    #     * :dataSource [String]
+    #   * :totalElements [Fixnum]
+    #   * :totalPages [Fixnum]
+    #   * :actualPage [Fixnum]
+    #
+    # @raise an exception when the status code isn't 200
+    def accounts_by_domain(domain, refinement = {}) #filter_account = nil, pagination = {})
+      params = refinement.dup
+      filter_account = params.delete(:account)
+      without_group = params.delete(:without_group) || false
+      limit, offset = params.values_at(:limit, :offset)
+
+      if without_group 
+        url = accounts_without_group_url(domain, filter_account)
+      else
         url = paginate accounts_by_domain_url(domain, filter_account), { limit: limit, offset: offset }
-        response = call(:get, url)
-        json_parse(response.content)
-      end
-
-      
-      # @return [Boolean] true when operation it's ok
-      def delete_rule(domain, id)
-        url = domain_rule_url(domain, id)
-        response = call(:delete, url)
-        return true if response.status == 200
-        return false
       end
+      response = call(:get, url)
+      json_parse(response.content)
+    end
 
-      # @param [String] domain
-      # @param [String] account  Ex.: test or mxhero (the user name)
-      # @return [MxHero::API::Response] reponse
-      #   the key :msg contains a Hash with the key, value of any property.
-      #   Example:
-      #       
-      #       { 'email': 'test@mxhero.com', 'name': 'John', 'lastname': 'Doe', ... }
-      #
-      def account_properties(domain, account)
-        url = account_properties_url(domain, account)
-        response = call(:get, url)
-        if response.status == 200
-          props = {}
-          json_parse(response.content).each { |property| props[property[:name]] = property[:value] }
-          return Response.new(response.code, props)
-        end
-        parse_response(response)
-      end
+    def accounts_without_group_url(domain, filter_account)
+      domain_by_id_url(domain) + "/groups/accounts/available?account=#{filter_account}"  
+    end
+ 
+    def verbose?
+      @verbose
+    end
 
-      # @param [String] domain
-      # @param [String] account
-      # @param [Hash] properties The properties of the account. Ex.: { 'email': 'test@mxhero.com', 'name': 'John', 'lastname': 'Doe', ... }
-      #
-      # @return [MxHero::API::Response]. On success not return msg.
-      def update_account_properties(domain, account, properties)
-        url = account_properties_url(domain, account)
-        response = call(:put, url, account_properties_to_json(properties))
-        parse_response(response)
-      end
+    def verbose=(verbose)
+      @verbose = verbose
+    end
 
-      private
-      
+    # @param domain [String]
+    # @param [Hash] msg 
+    # @option msg [String]      :domain
+    # @option msg [Boolean]     :twoWays
+    # @option msg [Boolean]     :enabled
+    # @option msg [String]      :name
+    # @option msg [Integer]     :created in epoch format
+    # @option msg [Hash]        :fromDirection
+    # @option msg [Hash]        :toDirection
+    # @option msg [Array<Hash>] :properties
+    # @option msg [String]      :component
+    #
+    # @return [MxHero::API::Response]
+    def create_rule_for_domain(domain, msg)
+      url = rules_for_domain_url(domain)
+      response = call(:post, url, msg.to_json, throw_exception: false)
+      parse_response(response)
+    end
+  
+    ## Create a rule
+    ##
+    ## @param [Hash] msg 
+    ## @option msg [String]      :domain
+    ## @option msg [Boolean]     :twoWays
+    ## @option msg [Boolean]     :enabled
+    ## @option msg [String]      :name
+    ## @option msg [Integer]     :created in epoch format
+    ## @option msg [Hash]        :fromDirection
+    ## @option msg [Hash]        :toDirection
+    ## @option msg [Array<Hash>] :properties
+    ## @option msg [String]      :component
+    ##
+    ##  [MxHero::API::Response]
+    #def create_rule(msg)
+    #  response = call(:post, rules_url, msg.to_json, throw_exception: false)
+    #  parse_response(response)
+    #end
+
+    # Retrieve all the rules for one domain
+    #
+    # @param [String] domain
+    # @param [String] component Filter the list of rules by this component [optional]
+    #
+    # @return [MxHero::API::Response] reponse
+    #   the key :msg contains an array of rules for the domain.
+    def rules_for_domain(domain, component = nil)
+      url = rules_for_domain_url(domain)
+      url << "?component=#{component}" if component
+      response = call(:get, url)
+      parse_response(response, on_empty: [])
+    end
 
-      # Complete the URL with the pagination info (:limit and :offset)
-      # @param [String] original URL. Ex.: http://www.example.com/api/accounts
-      # @param [Hash] pagination 
-      # @option pagination [Fixnum] :limit of elements per page
-      # @option pagination [Fixnum] :offset number of page (start in 1)
-      #
-      # @return [String] the URL with the pagination parameters.
-      #   Ex.: url: http://www.example.com/api/accounts
-      #        pagination: { limit: 4, offset: 2 }
-      #        return > http://www.example.com/api/accounts?limit=4&offset=2
-      def paginate(url, pagination)
-        paginated = url.dup
-        connector = url.include?('?') ? '&' : '?'
-        [ :limit, :offset ].map do |elem|
-          if pagination[elem]
-            paginated << "#{connector}#{elem.to_s}=#{pagination[elem]}"
-            connector = '&'
-          end
-        end
-        paginated
-      end
+    # @return [Boolean] true when operation it's ok
+    def delete_rule(domain, id)
+      url = domain_rule_url(domain, id)
+      response = call(:delete, url)
+      return true if response.status == 200
+      return false
+    end
 
-      def account_properties_to_json(properties)
-        out = []
-        properties.each do |key, value|
-          out << { name: key, value: value }
-        end
-        out.to_json
+    # @param [String] domain
+    # @param [String] account  Ex.: test or mxhero (the user name)
+    # @return [MxHero::API::Response] reponse
+    #   the key :msg contains a Hash with the key, value of any property.
+    #   Example:
+    #       
+    #       { 'email': 'test@mxhero.com', 'name': 'John', 'lastname': 'Doe', ... }
+    #
+    def account_properties(domain, account)
+      url = account_properties_url(domain, account)
+      response = call(:get, url)
+      if response.status == 200
+        props = {}
+        json_parse(response.content).each { |property| props[property[:name]] = property[:value] }
+        return Response.new(response.code, props)
       end
+      parse_response(response)
+    end
 
-      # @return [MxHero::API::Response] a response object
-      def parse_response(response, opts = { on_empty: nil })
-        json = response.content
-        hash = json.nil? || json.empty? ? opts[:on_empty] : json_parse(json)
-        Response.new(response.code, hash)
-      end
+    # @param [String] domain
+    # @param [String] account
+    # @param [Hash] properties The properties of the account. Ex.: { 'email': 'test@mxhero.com', 'name': 'John', 'lastname': 'Doe', ... }
+    #
+    # @return [MxHero::API::Response]. On success not return msg.
+    def update_account_properties(domain, account, properties)
+      url = account_properties_url(domain, account)
+      response = call(:put, url, account_properties_to_json(properties))
+      parse_response(response)
+    end
 
-      # @return [Hash]
-      def json_parse(json)
-        JSON.parse(json, symbolize_names: true)
-      end
+    private
+    
 
-      # Make a HTTP call 
-      # @param method [Symbol] indicate the HTTP verb (:get, :post, :put, etc)
-      # @param url [String]
-      # @param body [String] (default: nil)
-      # @param [Hash] more_options
-      # @option more_options [Boolean] :throw_exception (default: true) throw exception if the response status are between 500 and 600
-      def call(method, url, body = nil, more_options = {})
-        client = HTTPClient.new
-        client.set_auth(url, @username, @password)
-        response = client.request(method, url, nil, body, headers)
-        unless more_options[:throw_exception] == false
-          raise "An error ocurred when try to communicate with the API\nError: #{response}" if (500..600).include?(response.status)
+    # Complete the URL with the pagination info (:limit and :offset)
+    # @param [String] original URL. Ex.: http://www.example.com/api/accounts
+    # @param [Hash] pagination 
+    # @option pagination [Fixnum] :limit of elements per page
+    # @option pagination [Fixnum] :offset number of page (start in 1)
+    #
+    # @return [String] the URL with the pagination parameters.
+    #   Ex.: url: http://www.example.com/api/accounts
+    #        pagination: { limit: 4, offset: 2 }
+    #        return > http://www.example.com/api/accounts?limit=4&offset=2
+    def paginate(url, pagination)
+      paginated = url.dup
+      connector = url.include?('?') ? '&' : '?'
+      [ :limit, :offset ].map do |elem|
+        if pagination.key? elem
+          paginated << "#{connector}#{elem.to_s}=#{pagination[elem]}"
+          connector = '&'
         end
-        
-        response
-      end
-
-      # Default headers
-      def headers
-        @headers ||= { 'Accept' => 'application/json', 'Content-Type' => 'application/json' }
-      end
-
-      def rules_for_domain_url(domain)
-        service_url + "/domains/#{domain}/rules"
-      end
-
-      def rules_url
-        service_url + '/rules'
       end
+      paginated
+    end
 
-      def domains_url
-        service_url + '/domains'
+    def account_properties_to_json(properties)
+      out = []
+      properties.each do |key, value|
+        out << { name: key, value: value }
       end
+      out.to_json
+    end
 
-      def accounts_by_domain_url(domain, filter_account = nil)
-        filter = filter_account ? "?account=#{filter_account}" : ''
-        domain_by_id_url(domain) + 'accounts' + filter
-      end
+    # @return [MxHero::API::Response] a response object
+    def parse_response(response, opts = { on_empty: nil })
+      json = response.content
+      hash = json.nil? || json.empty? ? opts[:on_empty] : json_parse(json)
+      Response.new(response.code, hash)
+    end
+   
+    def rules_for_domain_url(domain)
+      service_url + "/domains/#{domain}/rules"
+    end
 
-      def domain_by_id_url(domain)
-        domains_url + "/#{domain}/"
-      end
+    def rules_url
+      service_url + '/rules'
+    end
 
-      def domain_rule_url(domain, id)
-        rules_for_domain_url(domain) + "/#{id}"
-      end
+    def accounts_by_domain_url(domain, filter_account = nil)
+      filter = filter_account ? "?account=#{filter_account}" : ''
+      domain_by_id_url(domain) + 'accounts' + filter
+    end
 
-      def account_properties_url(domain, account)
-        accounts_by_domain_url(domain) + "/#{account}/properties"
-      end
+    def domain_rule_url(domain, id)
+      rules_for_domain_url(domain) + "/#{id}"
+    end
 
-      def service_url
-        @service_url
-      end
+    def account_properties_url(domain, account)
+      accounts_by_domain_url(domain) + "/#{account}/properties"
     end
 
   end
+
 end