KayakoClient 0.0.1b

data/lib/kayako_client.rb

@@ -0,0 +1,36 @@
+require 'kayako_client/http/http_response'
+require 'kayako_client/http/http_backend'
+require 'kayako_client/http/http'
+
+require 'kayako_client/xml/xml_backend'
+require 'kayako_client/xml/xml'
+
+require 'kayako_client/mixins/api'
+require 'kayako_client/mixins/object'
+require 'kayako_client/mixins/client'
+require 'kayako_client/mixins/ticket_client'
+require 'kayako_client/mixins/post_client'
+require 'kayako_client/mixins/logger'
+require 'kayako_client/mixins/authentication'
+require 'kayako_client/mixins/attachment'
+require 'kayako_client/mixins/ticket_api'
+require 'kayako_client/mixins/user_visibility_api'
+require 'kayako_client/mixins/staff_visibility_api'
+
+require 'kayako_client/base'
+require 'kayako_client/department'
+require 'kayako_client/staff'
+require 'kayako_client/staff_group'
+require 'kayako_client/ticket'
+require 'kayako_client/ticket_attachment'
+require 'kayako_client/ticket_custom_field'
+require 'kayako_client/ticket_note'
+require 'kayako_client/ticket_post'
+require 'kayako_client/ticket_priority'
+require 'kayako_client/ticket_status'
+require 'kayako_client/ticket_time_track'
+require 'kayako_client/ticket_type'
+require 'kayako_client/ticket_count'
+require 'kayako_client/user'
+require 'kayako_client/user_group'
+require 'kayako_client/user_organization'

data/lib/kayako_client/base.rb

@@ -0,0 +1,98 @@
+module KayakoClient
+
+    class Base
+        include KayakoClient::API
+        include KayakoClient::Logger
+        include KayakoClient::Object
+        include KayakoClient::Authentication
+        include KayakoClient::HTTP
+        include KayakoClient::XML
+
+        def initialize(*args)
+            options = args.last.is_a?(Hash) ? args.pop : {}
+
+            if args[0]
+                @api_url = args[0]
+            elsif options.has_key?(:api_url)
+                @api_url = options.delete(:api_url)
+            else
+                @api_url = Base.api_url
+            end
+
+            if args[1]
+                @api_key = args[1]
+            elsif options.has_key?(:api_key)
+                @api_key = options.delete(:api_key)
+            else
+                @api_key = Base.api_key
+            end
+
+            if args[2]
+                @secret_key = args[2]
+            elsif options.has_key?(:secret_key)
+                @secret_key = options.delete(:secret_key)
+            else
+                @secret_key = Base.secret_key
+            end
+
+            if options.has_key?(:client)
+                http = options.delete(:client)
+                if http
+                    if http.class.included_modules.include?(KayakoClient::HTTPBackend)
+                        @http_backend = http.class
+                        @client = http
+                    else
+                        raise ArgumentError, "invalid HTTP client: #{http.class.name}"
+                    end
+                end
+            end
+
+            if options.has_key?(:logger)
+                @logger = options.delete(:logger)
+            end
+
+            if self.instance_of?(KayakoClient::Base)
+                unless defined?(@client) && @client
+                    @client = http_backend.new(proxy.merge(:logger => logger))
+                end
+                self.extend(KayakoClient::Client)
+            end
+
+            @associated = {}
+            import(options)
+        end
+
+        def inherited_options
+            inherited = {}
+            inherited[:api_url]    = @api_url    if defined?(@api_url)
+            inherited[:api_key]    = @api_key    if defined?(@api_key)
+            inherited[:secret_key] = @secret_key if defined?(@secret_key)
+            inherited[:client]     = @client     if defined?(@client)
+            inherited[:logger]     = @logger     if defined?(@logger)
+            inherited
+        end
+
+        class << self
+
+            def configure(&block)
+                instance_eval(&block)
+            end
+
+            def inherited_options(options)
+                inherited = {}
+                inherited[:api_url]    = options[:api_url]    if options.has_key?(:api_url)
+                inherited[:api_key]    = options[:api_key]    if options.has_key?(:api_key)
+                inherited[:secret_key] = options[:secret_key] if options.has_key?(:secret_key)
+                inherited[:client]     = options[:client]     if options.has_key?(:client)
+                inherited[:logger]     = options[:logger]     if options.has_key?(:logger)
+                inherited
+            end
+
+        end
+
+    end
+
+    class Tickets < Base
+    end
+
+end

data/lib/kayako_client/department.rb

@@ -0,0 +1,31 @@
+require 'kayako_client/mixins/user_visibility_api'
+
+require 'kayako_client/user_group'
+
+module KayakoClient
+    class Department < KayakoClient::Base
+        include KayakoClient::UserVisibilityAPI
+
+        DEPARTMENT_TYPES   = [ :public, :private ].freeze
+        DEPARTMENT_MODULES = [ :tickets, :livechat ].freeze
+
+        # NOTE: if :parent_department_id is set :module should have the same value
+
+        property :id,                     :integer, :readonly => true
+        property :title,                  :string, :required => [ :put, :post ]
+        property :type,                   :symbol, :in => DEPARTMENT_TYPES, :required => :post
+        property :module,                 :symbol, :in => DEPARTMENT_MODULES, :required => :post, :new => true
+        property :display_order,          :integer
+        property :parent_department_id,   :integer
+        property :user_visibility_custom, :boolean
+        property :user_group_ids,       [ :integer ], :get => :usergroups, :set => :usergroupid, :condition => { :user_visibility_custom => true }
+
+        associate :parent_department,     :parent_department_id, Department
+        associate :user_groups,           :user_group_ids,       UserGroup
+
+        def has_parent_department?
+            !parent_department_id.nil? && parent_department_id > 0
+        end
+
+    end
+end

data/lib/kayako_client/http/http.rb

@@ -0,0 +1,217 @@
+module KayakoClient
+    module HTTP
+
+        def self.included(base)
+            base.extend(ClassMethods)
+        end
+
+        def proxy=(options = {})
+            @proxy = {}
+            options.each do |key, value|
+                if [ :host, :port, :user, :pass ].include?(key)
+                    @proxy[key] = value
+                else
+                    raise ArgumentError, "unsupported option: #{key}"
+                end
+            end
+        end
+
+        def proxy
+            @proxy ||= self.class.proxy
+        end
+
+        def http_backend=(backend)
+            if backend.is_a?(String)
+                raise ArgumentError, "invalid HTTP backend: #{backend}" unless backend =~ /^[A-Za-z_]+$/
+                file = backend.gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/([A-Z])([A-Z][a-z])/, '\1_\2').downcase
+                require "kayako_client/http/#{file}"
+                backend = KayakoClient.const_get(backend)
+            end
+            if backend.is_a?(Class)
+                if backend.included_modules.include?(KayakoClient::HTTPBackend)
+                    @http_backend = backend
+                    @client = nil
+                else
+                    raise ArgumentError, "invalid HTTP backend: #{backend.name}"
+                end
+            else
+                if backend.class.included_modules.include?(KayakoClient::HTTPBackend)
+                    @http_backend = backend.class
+                    @client = backend
+                else
+                    raise ArgumentError, "invalid HTTP backend: #{backend.class.name}"
+                end
+            end
+        end
+
+        def http_backend
+            @http_backend ||= self.class.http_backend
+        end
+
+        def client
+            @client ||= nil
+            unless @client
+                if !instance_of?(KayakoClient::Base) && http_backend == self.class.http_backend && self.class.client
+                    @client = self.class.client
+                else
+                    @client = http_backend.new(proxy.merge(:logger => logger))
+                end
+            end
+            @client
+        end
+
+        def put_request(params = {})
+            @errors ||= {}
+            raise RuntimeError, "undefined ID" unless id
+            random = self.class.salt
+            e = params.delete(:e) || "#{self.class.path}/#{id}"
+            data = self.class.validate(params.merge(:errors => @errors))
+            if @errors.empty?
+                client.put(api_url, data.merge(:e         => e,
+                                               :apikey    => api_key,
+                                               :salt      => random,
+                                               :signature => self.class.signature(random, secret_key)))
+            else
+                @errors
+            end
+        end
+
+        def post_request(params = {})
+            @errors ||= {}
+            random = self.class.salt
+            e = params.delete(:e) || self.class.path
+            data = self.class.validate(params.merge(:errors => @errors))
+            if @errors.empty?
+                client.post(api_url, data.merge(:e         => e,
+                                                :apikey    => api_key,
+                                                :salt      => random,
+                                                :signature => self.class.signature(random, secret_key)))
+            else
+                @errors
+            end
+        end
+
+        def delete_request(params = {})
+            raise RuntimeError, "undefined ID" unless id
+            random = self.class.salt
+            e = params.delete(:e) || "#{self.class.path}/#{id}"
+            client.delete(api_url, :e         => e,
+                                   :apikey    => api_key,
+                                   :salt      => random,
+                                   :signature => self.class.signature(random, secret_key))
+        end
+
+        module ClassMethods
+
+            def proxy=(options = {})
+                @@proxy = {}
+                options.each do |key, value|
+                    if [ :host, :port, :user, :pass ].include?(key)
+                        @@proxy[key] = value
+                    else
+                        raise ArgumentError, "unsupported option: #{key}"
+                    end
+                end
+            end
+
+            def proxy
+                @@proxy ||= {}
+            end
+
+            def http_backend=(backend)
+                if backend.is_a?(String)
+                    raise ArgumentError, "invalid HTTP backend: #{backend}" unless backend =~ /^[A-Za-z_]+$/
+                    file = backend.gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/([A-Z])([A-Z][a-z])/, '\1_\2').downcase
+                    require "kayako_client/http/#{file}"
+                    backend = KayakoClient.const_get(backend)
+                end
+                if backend.is_a?(Class)
+                    if backend.included_modules.include?(KayakoClient::HTTPBackend)
+                        @@http_backend = backend
+                        @@client = nil
+                    else
+                        raise ArgumentError, "invalid HTTP backend: #{backend.name}"
+                    end
+                else
+                    if backend.class.included_modules.include?(KayakoClient::HTTPBackend)
+                        @@http_backend = backend.class
+                        @@client = backend
+                    else
+                        raise ArgumentError, "invalid HTTP backend: #{backend.class.name}"
+                    end
+                end
+            end
+
+            def http_backend
+                begin
+                    require 'kayako_client/http/http_client'
+                    @@http_backend ||= KayakoClient::HTTPClient
+                rescue LoadError
+                    require 'kayako_client/http/net_http'
+                    @@http_backend ||= KayakoClient::NetHTTP
+                end
+            end
+
+            def client
+                @@client ||= nil
+                unless @@client
+                    @@client = http_backend.new(proxy.merge(:logger => logger))
+                end
+                @@client
+            end
+
+            def get_request(options = {})
+                random = salt
+                params = options.dup
+
+                id     = params.delete(:id)
+                e      = params.delete(:e) || (id.nil? ? path : "#{path}/#{id}")
+                http   = params.delete(:client) || client
+                url    = params.delete(:api_url) || api_url
+                key    = params.delete(:api_key) || api_key
+                secret = params.delete(:secret_key) || secret_key
+
+                http.get(url, params.merge(:e         => e,
+                                           :apikey    => key,
+                                           :salt      => random,
+                                           :signature => signature(random, secret)))
+            end
+
+            def post_request(options = {})
+                random = salt
+                params = options.dup
+
+                e      = params.delete(:e) || path
+                http   = params.delete(:client) || client
+                url    = params.delete(:api_url) || api_url
+                key    = params.delete(:api_key) || api_key
+                secret = params.delete(:secret_key) || secret_key
+
+                http.post(url, params.merge(:e         => e,
+                                            :apikey    => key,
+                                            :salt      => random,
+                                            :signature => signature(random, secret)))
+            end
+
+            def delete_request(options = {})
+                random = salt
+                params = options.dup
+
+                id     = params.delete(:id)
+                e      = params.delete(:e) || "#{path}/#{id}"
+                http   = params.delete(:client) || client
+                url    = params.delete(:api_url) || api_url
+                key    = params.delete(:api_key) || api_key
+                secret = params.delete(:secret_key) || secret_key
+
+                raise ArgumentError, "missing ID" unless id
+                http.delete(url, :e         => e,
+                                 :apikey    => key,
+                                 :salt      => random,
+                                 :signature => signature(random, secret))
+            end
+
+        end
+
+    end
+end

data/lib/kayako_client/http/http_backend.rb

@@ -0,0 +1,31 @@
+require 'uri'
+
+module KayakoClient
+    module HTTPBackend
+
+        def initialize(options = {})
+            raise NotImplementedError, "not implemented"
+        end
+
+        def get(base, params = {})
+            raise NotImplementedError, "not implemented"
+        end
+
+        def put(base, params = {})
+            raise NotImplementedError, "not implemented"
+        end
+
+        def post(base, params = {})
+            raise NotImplementedError, "not implemented"
+        end
+
+        def delete(base, params = {})
+            raise NotImplementedError, "not implemented"
+        end
+
+        def response(resp)
+            raise NotImplementedError, "not implemented"
+        end
+
+    end
+end

data/lib/kayako_client/http/http_client.rb

@@ -0,0 +1,87 @@
+require 'httpclient'
+
+module KayakoClient
+    class HTTPClient
+        include KayakoClient::Logger
+        include KayakoClient::HTTPBackend
+
+        def initialize(options = {})
+            @client = ::HTTPClient.new
+            if options[:host]
+                @client.proxy = "http://#{options[:host]}:#{options[:port] || 80}"
+                @client.set_proxy_auth(options[:user], options[:pass])
+            end
+            @logger = options[:logger] if options[:logger]
+        end
+
+        def get(base, params = {})
+            log = params.delete(:logger) || logger
+            log.debug ":get => #{base} + #{params.inspect}" if log
+            resp = @client.request(:get, base, params)
+            response(resp)
+        end
+
+        def put(base, params = {})
+            query = { :e => params.delete(:e) }
+            data = form_data(params)
+            log = params.delete(:logger) || logger
+            if log
+                log.debug ":put => #{base} + #{query.inspect}"
+                log.debug "PUT Data: #{data.inspect}"
+            end
+            resp = @client.request(:put, base, query, data, { 'Content-Type' => 'application/x-www-form-urlencoded' })
+            response(resp)
+        end
+
+        def post(base, params = {})
+            query = { :e => params.delete(:e) }
+            data = form_data(params)
+            log = params.delete(:logger) || logger
+            if log
+                log.debug ":post => #{base} + #{query.inspect}"
+                log.debug "POST Data: #{data.inspect}"
+            end
+            resp = @client.request(:post, base, query, data, { 'Content-Type' => 'application/x-www-form-urlencoded' })
+            response(resp)
+        end
+
+        def delete(base, params = {})
+            log = params.delete(:logger) || logger
+            log.debug ":delete => #{base} + #{params.inspect}" if log
+            resp = @client.request(:delete, base, params)
+            response(resp)
+        end
+
+        def response(resp)
+            case resp.status
+            when 200
+                KayakoClient::HTTPOK.new(resp.content)
+            when 400
+                KayakoClient::HTTPBadRequest.new(resp.content)
+            when 401
+                KayakoClient::HTTPUnauthorized.new(resp.content)
+            when 403
+                KayakoClient::HTTPForbidden.new(resp.content)
+            when 404
+                KayakoClient::HTTPNotFound.new(resp.content)
+            when 405
+                KayakoClient::HTTPNotAllowed.new(resp.content)
+            else
+                KayakoClient::HTTPResponse.new(resp.status, resp.content)
+            end
+        end
+
+    private
+
+        def form_data(params = {})
+            params.inject([]) do |array, (name, value)|
+                if value.is_a?(Array)
+                    array.concat(value.collect { |item| [ name.to_s + '[]', item.to_s ] })
+                else
+                    array.push([ name.to_s, value.to_s ])
+                end
+            end
+        end
+
+    end
+end