KayakoClient 0.0.1b

data/lib/kayako_client/http/http_response.rb

@@ -0,0 +1,61 @@
+module KayakoClient
+
+    class HTTPResponse
+        attr_accessor :status, :body
+
+        def initialize(status, body = '')
+            @status = status
+            @body = body
+        end
+
+    end
+
+    class HTTPOK < HTTPResponse
+
+        def initialize(body = '')
+            super(200, body)
+        end
+
+    end
+
+    class HTTPBadRequest < HTTPResponse
+
+        def initialize(body = '')
+            super(400, body)
+        end
+
+    end
+
+    class HTTPUnauthorized < HTTPResponse
+
+        def initialize(body = '')
+            super(401, body)
+        end
+
+    end
+
+    class HTTPForbidden < HTTPResponse
+
+        def initialize(body = '')
+            super(403, body)
+        end
+
+    end
+
+    class HTTPNotFound < HTTPResponse
+
+        def initialize(body = '')
+            super(404, body)
+        end
+
+    end
+
+    class HTTPNotAllowed < HTTPResponse
+
+        def initialize(body = '')
+            super(405, body)
+        end
+
+    end
+
+end

data/lib/kayako_client/http/net_http.rb

@@ -0,0 +1,109 @@
+require 'net/http'
+
+module KayakoClient
+    class NetHTTP
+        include KayakoClient::Logger
+        include KayakoClient::HTTPBackend
+
+        def initialize(options = {})
+            @client = Net::HTTP::Proxy(options[:host], options[:port], options[:user], options[:pass])
+            @logger = options[:logger] if options[:logger]
+        end
+
+        def get(base, params = {})
+            uri = URI.parse(base)
+            log = params.delete(:logger) || logger
+            @client.use_ssl = true if uri.is_a?(URI::HTTPS)
+            resp = @client.start(uri.host, uri.port) do |request|
+                query = url(uri.path, params)
+                log.debug ":get => #{query}" if log
+                request.get(query)
+            end
+            response(resp)
+        end
+
+        def put(base, params = {})
+            uri = URI.parse(base)
+            e = params.delete(:e)
+            log = params.delete(:logger) || logger
+            @client.use_ssl = true if uri.is_a?(URI::HTTPS)
+            resp = @client.start(uri.host, uri.port) do |request|
+                query = url(uri.path, { :e => e })
+                data = form_data(params)
+                if log
+                    log.debug ":put => #{query}"
+                    log.debug "PUT Data: #{data}"
+                end
+                request.put(query, data, 'Content-Type' => 'application/x-www-form-urlencoded')
+            end
+            response(resp)
+        end
+
+        def post(base, params = {})
+            uri = URI.parse(base)
+            e = params.delete(:e)
+            log = params.delete(:logger) || logger
+            @client.use_ssl = true if uri.is_a?(URI::HTTPS)
+            resp = @client.start(uri.host, uri.port) do |request|
+                query = url(uri.path, { :e => e })
+                data = form_data(params)
+                if log
+                    log.debug ":post => #{query}"
+                    log.debug "POST Data: #{data}"
+                end
+                request.post(query, data, 'Content-Type' => 'application/x-www-form-urlencoded')
+            end
+            response(resp)
+        end
+
+        def delete(base, params = {})
+            uri = URI.parse(base)
+            log = params.delete(:logger) || logger
+            @client.use_ssl = true if uri.is_a?(URI::HTTPS)
+            resp = @client.start(uri.host, uri.port) do |request|
+                query = url(uri.path, params)
+                log.debug ":delete => #{query}" if log
+                request.delete(query)
+            end
+            response(resp)
+        end
+
+        def response(resp)
+            case resp
+            when Net::HTTPOK
+                KayakoClient::HTTPOK.new(resp.body)
+            when Net::HTTPBadRequest
+                KayakoClient::HTTPBadRequest.new(resp.body)
+            when Net::HTTPUnauthorized
+                KayakoClient::HTTPUnauthorized.new(resp.body)
+            when Net::HTTPForbidden
+                KayakoClient::HTTPForbidden.new(resp.body)
+            when Net::HTTPNotFound
+                KayakoClient::HTTPNotFound.new(resp.body)
+            when Net::HTTPMethodNotAllowed
+                KayakoClient::HTTPNotAllowed.new(resp.body)
+            else
+                KayakoClient::HTTPResponse.new(resp.code, resp.body)
+            end
+        end
+
+    private
+
+        def urlencode(string)
+            URI.escape(string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+        end
+
+        def url(base, params = {})
+            base + '?' + params.collect { |name, value| urlencode(name.to_s) + '=' + urlencode(value.to_s) }.join('&')
+        end
+
+        def form_data(params = {})
+            params.collect { |name, value|
+                value.is_a?(Array) ?
+                    value.collect { |item| urlencode(name.to_s) + '[]=' + urlencode(item.to_s) } :
+                    urlencode(name.to_s) + '=' + urlencode(value.to_s)
+            }.join('&')
+        end
+
+    end
+end

data/lib/kayako_client/mixins/api.rb

@@ -0,0 +1,299 @@
+module KayakoClient
+    module API
+
+        def self.included(base)
+            base.extend(ClassMethods)
+        end
+
+        def api_url=(url)
+            @api_url = url
+        end
+
+        def api_url
+            @api_url ||= self.class.api_url
+        end
+
+        def api_key=(key)
+            @api_key = key
+        end
+
+        def api_key
+            @api_key ||= self.class.api_key
+        end
+
+        def secret_key=(secret)
+            @secret_key = secret
+        end
+
+        def secret_key
+            @secret_key ||= self.class.secret_key
+        end
+
+        def put
+            raise NotImplementedError, "method not supported" unless self.class.support?(:put)
+            raise RuntimeError, "client not configured" unless configured?
+            if changed?
+                params = changes.inject({}) do |hash, property|
+                    hash[property] = instance_variable_get("@#{property}")
+                    hash
+                end
+                require_properties(:put, params)
+                validate(:put, params)
+                check_conditions(params)
+                response = put_request(params)
+                if response.is_a?(KayakoClient::HTTPOK)
+                    if logger
+                        logger.debug "Response:"
+                        logger.debug response.body
+                    end
+                    payload = xml_backend.new(response.body, { :logger => logger })
+                    clean
+                    import(payload.to_hash)
+                    loaded!
+                    logger.info ":put successful for object##{id}" if logger
+                    true
+                else
+                    unless response.is_a?(Hash)
+                        logger.error "Response: #{response.status} #{response.body}" if logger
+                        raise StandardError, "server returned #{response.status}: #{response.body}"
+                    end
+                    false
+                end
+            else
+                logger.warn "nothing to :put" if logger
+                true
+            end
+        end
+
+        alias_method :update, :put
+
+        def post
+            raise NotImplementedError, "method not supported" unless self.class.support?(:post)
+            raise RuntimeError, "client not configured" unless configured?
+            if id
+                logger.warn "Object has :id - calling :put instead" if logger
+                return put
+            end
+            raise RuntimeError, "object cannot be saved" unless new?
+            params = changes.inject({}) do |hash, property|
+                hash[property] = instance_variable_get("@#{property}")
+                hash
+            end
+            require_properties(:post, params)
+            validate(:post, params)
+            check_conditions(params)
+            response = post_request(params)
+            if response.is_a?(KayakoClient::HTTPOK)
+                if logger
+                    logger.debug "Response:"
+                    logger.debug response.body
+                end
+                payload = xml_backend.new(response.body, { :logger => logger })
+                clean
+                import(payload.to_hash)
+                loaded!
+                logger.info ":post successful" if logger
+                true
+            else
+                unless response.is_a?(Hash)
+                    logger.error "Response: #{response.status} #{response.body}" if logger
+                    raise StandardError, "server returned #{response.status}: #{response.body}"
+                end
+                false
+            end
+        end
+
+        alias_method :save, :post
+
+        def delete
+            raise NotImplementedError, "method not supported" unless self.class.support?(:delete)
+            raise RuntimeError, "client not configured" unless configured?
+            unless new?
+                response = delete_request
+                if response.is_a?(KayakoClient::HTTPOK)
+                    logger.info ":delete successful for object##{id}" if logger
+                else
+                    logger.error "Response: #{response.status} #{response.body}" if logger
+                    raise StandardError, "server returned #{response.status}: #{response.body}"
+                end
+            else
+                logger.warn "cannot delete new object" if logger
+                raise StandardError, "cannot delete new object"
+            end
+        end
+
+        alias_method :destroy, :delete
+
+        module ClassMethods
+
+            def api_url=(url)
+                @@api_url = url
+            end
+
+            def api_url
+                @@api_url ||= ''
+            end
+
+            def api_key=(key)
+                @@api_key = key
+            end
+
+            def api_key
+                @@api_key ||= ''
+            end
+
+            def secret_key=(secret)
+                @@secret_key = secret
+            end
+
+            def secret_key
+                @@secret_key ||= ''
+            end
+
+            def all(options = {})
+                raise NotImplementedError, "method not supported" unless support?(:all)
+                unless configured? || (options[:api_url] && options[:api_key] && options[:secret_key])
+                    raise RuntimeError, "client not configured"
+                end
+                response = get_request(options)
+                log = options[:logger] || logger
+                if response.is_a?(KayakoClient::HTTPOK)
+                    objects = []
+                    if log
+                        log.debug "Response:"
+                        log.debug response.body
+                    end
+                    payload = xml_backend.new(response.body, { :logger => log })
+                    payload.each do |element|
+                        object = new(payload.to_hash(element).merge(inherited_options(options)))
+                        object.loaded!
+                        objects << object
+                    end
+                    log.info ":get(:all) successful (#{objects.size} objects)" if log
+                    objects
+                else
+                    log.error "Response: #{response.status} #{response.body}" if log
+                    raise StandardError, "server returned #{response.status}: #{response.body}"
+                end
+            end
+
+            def get(*args)
+                options = args.last.is_a?(Hash) ? args.pop : {}
+                id = args[0]
+                id = :all unless id || options[:id]
+                raise NotImplementedError, "method not supported" unless support?(:get)
+                unless configured? || (options[:api_url] && options[:api_key] && options[:secret_key])
+                    raise RuntimeError, "client not configured"
+                end
+                log = options[:logger] || logger
+                if id == :all
+                    return all(options)
+                elsif id && id.to_i > 0
+                    id = id.to_i
+                elsif options[:id]
+                    id = options[:id]
+                else
+                    if id
+                        log.error "invalid :id - #{id}" if log
+                        raise ArgumentError, "invalid ID"
+                    else
+                        log.error "missing :id" if log
+                        raise ArgumentError, "missing ID"
+                    end
+                end
+                response = get_request(options.merge(:id => id))
+                if response.is_a?(KayakoClient::HTTPOK)
+                    if log
+                        log.debug "Response:"
+                        log.debug response.body
+                    end
+                    payload = xml_backend.new(response.body, { :logger => log })
+                    params = payload.to_hash
+                    unless params.nil?
+                        object = new(params.merge(inherited_options(options)))
+                        object.loaded!
+                        log.info ":get(#{id}) successful" if log
+                        object
+                    else
+                        log.info ":get(#{id}) successful (not found)" if log
+                        nil
+                    end
+                else
+                    log.error "Response: #{response.status} #{response.body}" if log
+                    raise StandardError, "server returned #{response.status}: #{response.body}"
+                end
+            end
+
+            alias_method :find, :get
+
+            def post(options = {})
+                raise NotImplementedError, "method not supported" unless support?(:post)
+                object = new(options)
+                if object.post
+                    object
+                else
+                    object.has_errors? ? object.errors : nil
+                end
+            end
+
+            alias_method :create, :post
+
+            def delete(id, options = {})
+                raise NotImplementedError, "method not supported" unless support?(:delete)
+                unless configured? || (options[:api_url] && options[:api_key] && options[:secret_key])
+                    raise RuntimeError, "client not configured"
+                end
+                response = delete_request(options.merge(:id => id))
+                log = options[:logger] || logger
+                if response.is_a?(KayakoClient::HTTPOK)
+                    log.info ":delete successful for object##{id}" if log
+                    true
+                else
+                    log.error "Response: #{response.status} #{response.body}" if log
+                    raise StandardError, "server returned #{response.status}: #{response.body}"
+                    false
+                end
+            end
+
+            alias_method :destroy, :delete
+
+        private
+
+            def configured?
+                !api_url.empty? && !api_key.empty? && !secret_key.empty?
+            end
+
+        end
+
+    private
+
+        def configured?
+            !api_url.empty? && !api_key.empty? && !secret_key.empty?
+        end
+
+        def reload!(options = {})
+            raise NotImplementedError, "method not supported" unless self.class.support?(:get)
+            raise RuntimeError, "client not configured" unless configured?
+            raise RuntimeError, "cannot reload modified object" if changed?
+            raise RuntimeError, "object not saved yet" unless id && !new?
+            response = self.class.get_request(options.merge(:id => id))
+            if response.is_a?(KayakoClient::HTTPOK)
+                if logger
+                    logger.debug "Response:"
+                    logger.debug response.body
+                end
+                payload = xml_backend.new(response.body, { :logger => logger })
+                clean
+                import(payload.to_hash)
+                loaded!
+                logger.info ":get(#{id}) successful" if logger
+                true
+            else
+                logger.error "Response: #{response.status} #{response.body}" if logger
+                raise StandardError, "server returned #{response.status}: #{response.body}"
+                false
+            end
+        end
+
+    end
+end