redbooth-ruby 0.0.3 → 0.0.4

data/lib/redbooth-ruby/operations/base.rb

@@ -0,0 +1,47 @@
+module RedboothRuby
+  module Operations
+    module Base
+      module ClassMethods
+        # Options for request
+        # overwrite this in the model to set security
+        #
+        # @return [Hash]
+        def options_for_request(attributes)
+          fail AuthenticationError unless attributes[:session]
+          {
+            session: attributes[:session]
+          }
+        end
+
+        protected
+
+        # URl for the member endpoints
+        # overwrite this in the model if the api is not well named
+        #
+        def api_member_url(id = nil, method = nil)
+          url = api_resource_name(method)
+          url += "/#{id}" if id
+          url
+        end
+
+        # URl for the collection endpoints
+        # overwrite this in the model if the api is not well named
+        #
+        def api_collection_url(attrs = {})
+          api_resource_name
+        end
+
+        # resource name
+        # overwrite this in the model if the api is not well named
+        #
+        def api_resource_name(method = nil)
+          "#{name.split('::').last.downcase}s"
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/operations/create.rb

@@ -0,0 +1,25 @@
+module RedboothRuby
+  module Operations
+    module Create
+      module ClassMethods
+        # Creates a new object
+        #
+        # @param [Hash] attributes The attributes of the created object
+        def create(attributes)
+          session = attributes.delete(:session)
+          response = RedboothRuby.request(:post,
+                                          nil,
+                                          api_collection_url(attributes),
+                                          attributes,
+                                          options_for_request(session: session)
+                                         )
+          new(response.data)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/operations/delete.rb

@@ -0,0 +1,26 @@
+module RedboothRuby
+  module Operations
+    module Delete
+      module ClassMethods
+        # Deletes the given object
+        #
+        # @param attributes [Hash] hash of given attributes passed to the delete method
+        # @return [Boolean]
+        def delete(attributes = {})
+          id = attributes.delete(:id)
+          response = RedboothRuby.request(:delete,
+                                          nil,
+                                          api_member_url(id, :delete),
+                                          {},
+                                          options_for_request(attributes)
+                                         )
+          true
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/operations/index.rb

@@ -0,0 +1,49 @@
+module RedboothRuby
+  module Operations
+    module Index
+      module ClassMethods
+        # Retrieves all available objects from the Copy API
+        #
+        # @param [Hash] options Options to pass to the API
+        # @return [Array] The available objects
+        def index(attributes = {})
+          session = attributes.delete(:session)
+          response = RedboothRuby.request(:get, nil, api_collection_url , attributes, options_for_request(session: session))
+          collection_from attributes, response, session
+        end
+
+        private
+
+        # Creates a collection object from the request and response params
+        #
+        # @param params [Hash] given request params
+        # @param response [RedboothRuby::Request::Response] response object
+        # @param session [RedboothRuby::Session] session Object
+        # @return [RedboothRuby::Request::Collection]
+        def collection_from(params, response, session)
+          RedboothRuby::Request::Collection.new(response: response,
+                                            resource: self,
+                                            session: session,
+                                            params: params,
+                                            method: :index)
+        end
+
+        # Returns the collection object build from the received response
+        #
+        # @param response [Array || Hash] parsed json response
+        # @return [RedboothRuby::Collection]
+        def results_from(response)
+          results = []
+          response.data.each do |obj|
+            results << self.new(obj)
+          end
+          results
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/operations/meta.rb

@@ -0,0 +1,15 @@
+module RedboothRuby
+  module Operations
+    module Meta
+      # Returns a hash with the object metadata
+      #
+      # @return [Hash] the object metadata
+      def metadata
+        response = RedboothRuby.request(:get, nil, 'metadata',
+                                        { target_id: id, target_type: self.class.to_s },
+                                        options_for_request({}))
+        response.data
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/operations/show.rb

@@ -0,0 +1,25 @@
+module RedboothRuby
+  module Operations
+    module Show
+      module ClassMethods
+        # Shows a given object
+        #
+        # @param [Integer] id The id of the object that should be shown
+        # @return [Copy::Base] The found object
+        def show(attributes={})
+          response = RedboothRuby.request(:get,
+                                          nil,
+                                          api_member_url(attributes[:id], :show),
+                                          {},
+                                          options_for_request(attributes)
+                                         )
+          new(response.data)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/operations/update.rb

@@ -0,0 +1,26 @@
+module RedboothRuby
+  module Operations
+    module Update
+      module ClassMethods
+        # Updates a object
+        # @param [Integer] id The id of the object that should be updated
+        # @param [Hash] attributes The attributes that should be updated
+        def update(attributes = {})
+          id = attributes.delete(:id)
+          session = attributes.delete(:session)
+          response = RedboothRuby.request(:put,
+                                          nil,
+                                          api_member_url(id, :updated),
+                                          attributes,
+                                          options_for_request(session: session)
+                                         )
+          new(response.data)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/organization.rb

@@ -0,0 +1,34 @@
+module RedboothRuby
+  class Organization < Base
+    include RedboothRuby::Operations::Index
+    include RedboothRuby::Operations::Create
+    include RedboothRuby::Operations::Update
+    include RedboothRuby::Operations::Show
+    include RedboothRuby::Operations::Delete
+
+    attr_accessor :id,
+                  :name,
+                  :permalink,
+                  :domain,
+                  :settings,
+                  :omit_email_processing,
+                  :product,
+                  :product_name,
+                  :feature_level,
+                  :subscription_id,
+                  :seats,
+                  :remaining_users,
+                  :available_users,
+                  :used_users,
+                  :remaining_projects,
+                  :available_projects,
+                  :used_projects,
+                  :has_logo,
+                  :square_logo_url,
+                  :top_logo_url,
+                  :is_pro,
+                  :created_at,
+                  :updated_at
+
+  end
+end

data/lib/redbooth-ruby/person.rb

@@ -0,0 +1,23 @@
+module RedboothRuby
+  class Person < Base
+    include RedboothRuby::Operations::Index
+    include RedboothRuby::Operations::Create
+    include RedboothRuby::Operations::Update
+    include RedboothRuby::Operations::Show
+    include RedboothRuby::Operations::Delete
+
+    attr_accessor :id,
+                  :user_id,
+                  :project_id,
+                  :role,
+                  :created_at,
+                  :updated_at
+
+    # resource name
+    # overwrite this in the model if the api is not well named
+    #
+    def self.api_resource_name(method = nil)
+      'people'
+    end
+  end
+end

data/lib/redbooth-ruby/project.rb

@@ -0,0 +1,26 @@
+module RedboothRuby
+  class Project < Base
+    include RedboothRuby::Operations::Index
+    include RedboothRuby::Operations::Create
+    include RedboothRuby::Operations::Update
+    include RedboothRuby::Operations::Show
+    include RedboothRuby::Operations::Delete
+
+    attr_accessor :id,
+                  :permalink,
+                  :organization_id,
+                  :archived,
+                  :name,
+                  :description,
+                  :start_date,
+                  :end_date,
+                  :tracks_time,
+                  :public,
+                  :publish_pages,
+                  :settings,
+                  :deleted,
+                  :created_at,
+                  :updated_at
+
+  end
+end

data/lib/redbooth-ruby/request/base.rb

@@ -0,0 +1,41 @@
+module RedboothRuby
+  module Request
+    class Base
+      attr_reader :info
+      attr_accessor :response
+
+      def initialize(info)
+        @info = info
+      end
+
+      def perform
+        fail RedboothRuby::AuthenticationError unless valid?
+        connection.set_request_data
+        send_request
+
+        validator.validated_response_for(response)
+      end
+
+      def valid?
+        return false unless info
+        return false unless info.session
+        return false unless info.session.valid?
+        true
+      end
+
+      protected
+
+      def send_request
+        self.response = connection.request
+      end
+
+      def connection
+        @connection ||= Connection.new(info)
+      end
+
+      def validator
+        @validator ||= Validator.new(info)
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/request/collection.rb

@@ -0,0 +1,105 @@
+module RedboothRuby
+  module Request
+    class Collection
+      attr_reader :response, :params, :method, :session, :resource
+
+      def initialize(attributes={})
+        @response = attributes[:response]
+        @params = attributes[:params]
+        @method = attributes[:method]
+        @resource = attributes[:resource]
+        @session = attributes[:session]
+      end
+
+      # Returns an array of resuce objects built from each one of the response items
+      #
+      # @return [Array(resource)]
+      def all
+        results = []
+        response.data.each do |obj|
+          results << resource.new(obj)
+        end
+        results
+      end
+
+      # Returns total pages
+      #
+      # @return [Integer]
+      def total_pages
+        return unless response.headers['PaginationTotalPages']
+        response.headers['PaginationTotalPages'].to_i
+      end
+
+      # Returns elements per page
+      #
+      # @return [Integer]
+      def per_page
+        return unless response.headers['PaginationPerPage']
+        response.headers['PaginationPerPage'].to_i
+      end
+
+      # Returns elements per page
+      #
+      # @return [Integer]
+      def current_page
+        return unless response.headers['PaginationCurrentPage']
+        response.headers['PaginationCurrentPage'].to_i
+      end
+
+      # Return total elements
+      #
+      # @return [Integer]
+      def count
+        return all.size unless paginated?
+        return all.size if total_pages.to_i <= 1
+        total_pages * per_page
+      end
+
+      # Performs the request for the next page if exists
+      #
+      # @return [Redbooth::Request::Collection]
+      def next_page
+        return nil unless paginated?
+        return nil unless (total_pages - current_page) > 0
+        request_with(page: current_page + 1)
+      end
+
+      # Performs the request for the next page if exists
+      #
+      # @return [Redbooth::Request::Collection]
+      def prev_page
+        return nil unless paginated?
+        return nil unless current_page > 1
+        request_with(page: current_page - 1)
+      end
+
+      protected
+
+      # Whenever the response is paginated or not
+      def paginated?
+        return false unless current_page
+        true
+      end
+
+      # Dups the current collection overwriting the given attributes
+      #
+      # @return [Redbooth::Request::Collection]
+      def dup_with(attributes={})
+        dup_params = { response: response,
+                       params: params,
+                       method: method,
+                       resource: resource,
+                       session: session }.merge(attributes)
+        self.class.new(dup_params)
+      end
+
+      # Repeats the request merged with the new params given
+      #
+      # @param new_params [Hash] params to overwrite or add in the new request
+      # @return [Redbooth::Request::Collection]
+      def request_with(new_params={})
+        resource.send(method, params.merge(new_params).merge(session: session))
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/request/connection.rb

@@ -0,0 +1,140 @@
+require 'net/http/post/multipart'
+
+module RedboothRuby
+  module Request
+    class Connection
+      include Helpers
+      attr_reader :access_token, :request_data
+
+      def initialize(request_info)
+        @info = request_info
+        @session = @info.session if @info
+        @access_token = @info.session.access_token if @session
+      end
+
+      def request
+        return unless access_token
+        if use_body_file?
+          ::File.open(body_file_attrs[:local_path]) do |file|
+            req = Net::HTTP::Post::Multipart.new(
+                api_url,
+               'file' => UploadIO.new(file,
+                                      'application/octet-stream',
+                                      body_file_attrs[:name]
+                                     )
+            )
+            access_token.sign! req
+            if RedboothRuby.configuration[:use_ssl]
+              http = Net::HTTP.new('redbooth.com' , Net::HTTP.https_default_port)
+              http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+              http.use_ssl = RedboothRuby.configuration[:use_ssl]
+            end
+            http.start do |inner_http|
+              inner_http.request(req)
+            end
+          end
+        else
+          access_token.send(*request_data)
+        end
+      end
+
+      def set_request_data
+        @request_data = []
+        @request_data << @info.http_method if @info
+        @request_data << api_url
+        unless use_url_params?
+          @request_data << { body: body_hash }
+        end
+      end
+
+      protected
+
+      # Body params hash
+      #
+      # @return [Hash]
+      def body_hash
+        return {} unless @info
+        @info.data
+      end
+
+      # Json encoded body
+      #
+      # @return [String]
+      def body_json
+        return '' unless body_hash
+        JSON.generate(body_hash)
+      end
+
+      def body_file_attrs
+        body_hash[:file_attrs] || {}
+      end
+
+      # Body params url encoded
+      #
+      # @return [String]
+      def encoded_www_body
+        return '' unless body_hash
+        URI.encode_www_form(body_hash)
+      end
+
+      def use_body_file?
+        return false if use_url_params?
+        body_hash.key?(:file)
+      end
+
+      def use_url_params?
+        return false unless @info
+        case @info.http_method
+        when :post, :put
+          false
+        else
+          true
+        end
+      end
+
+      # Returns the api url foir this request or default
+      def api_url
+        url =  "#{api_url_method}#{api_url_domain}"
+        url += "#{RedboothRuby.configuration[:api_base]}"
+        url += "#{api_url_path}"
+        url += "#{api_url_version}"
+        if @info
+          url += @info.url
+          if use_url_params? && !body_hash.empty?
+            url += '?' + encoded_www_body
+          end
+        end
+        url
+      end
+
+      def api_url_method
+        if RedboothRuby.configuration[:use_ssl]
+          'https://'
+        else
+          'http://'
+        end
+      end
+
+      def api_url_domain
+        return '' unless domain
+        "#{domain}."
+      end
+
+      def api_url_path
+        return '' unless RedboothRuby.configuration[:api_base_path]
+        "/#{RedboothRuby.configuration[:api_base_path]}"
+      end
+
+      def api_url_version
+        return '' unless RedboothRuby.configuration[:api_version]
+        "/#{RedboothRuby.configuration[:api_version]}"
+      end
+
+      # Returns the domain for the current request or the default one
+      def domain
+        return @info.subdomain if @info
+        RedboothRuby.configuration[:domain_base]
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/request/helpers.rb

@@ -0,0 +1,36 @@
+module RedboothRuby
+  module Request
+    module Helpers
+      def flatten_hash_keys(old_hash, new_hash = {}, keys = nil)
+        old_hash.each do |key, value|
+          key = key.to_s
+          if value.is_a?(Hash)
+            all_keys_formatted = keys + "[#{key}]"
+            flatten_hash_keys(value, new_hash, all_keys_formatted)
+          else
+            new_hash[key] = value
+          end
+        end
+        new_hash
+      end
+
+      def normalize_params(params, key = nil)
+        params = flatten_hash_keys(params) if params.is_a?(Hash)
+        result = {}
+        params.each do |name, value|
+          case value
+          when Hash
+            result[name.to_s] = normalize_params(value)
+          when Array
+            value.each_with_index do |item_value, index|
+              result["#{name.to_s}[#{index}]"] = item_value.to_s
+            end
+          else
+            result[name.to_s] = value.to_s
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/redbooth-ruby/request/info.rb

@@ -0,0 +1,41 @@
+module RedboothRuby
+  module Request
+    class Info
+      attr_accessor :http_method, :api_url, :data, :subdomain, :session, :base_path
+
+      def initialize(http_method, subdomain, api_url, data, options = {})
+        @http_method = http_method
+        @subdomain   = subdomain || DOMAIN_BASE
+        @api_url     = api_url
+        @data        = data
+        @base_path   = RedboothRuby.configuration[:api_base_path]
+        @session     = options[:session]
+      end
+
+      def url
+        url = "/#{api_url}"
+        if has_id?
+          url += "/#{data[:id]}"
+          data.delete(:id)
+        end
+
+        url
+      end
+
+      def path_with_params(path, params)
+        unless params.empty?
+          encoded_params = URI.encode_www_form(params)
+          [path, encoded_params].join("?")
+        else
+          path
+        end
+      end
+
+      protected
+
+      def has_id?
+        !data[:id].nil?
+      end
+    end
+  end
+end