ticketevolution-ruby 0.5.0

data/lib/ticket_evolution/clients/credit_cards.rb

@@ -0,0 +1,8 @@
+module TicketEvolution
+  class Clients
+    class CreditCards < TicketEvolution::Endpoint
+      include TicketEvolution::Modules::Create
+      include TicketEvolution::Modules::List
+    end
+  end
+end

data/lib/ticket_evolution/clients/email_addresses.rb

@@ -0,0 +1,10 @@
+module TicketEvolution
+  class Clients
+    class EmailAddresses < TicketEvolution::Endpoint
+      include TicketEvolution::Modules::Create
+      include TicketEvolution::Modules::List
+      include TicketEvolution::Modules::Show
+      include TicketEvolution::Modules::Update
+    end
+  end
+end

data/lib/ticket_evolution/clients/phone_numbers.rb

@@ -0,0 +1,10 @@
+module TicketEvolution
+  class Clients
+    class PhoneNumbers < TicketEvolution::Endpoint
+      include TicketEvolution::Modules::Create
+      include TicketEvolution::Modules::List
+      include TicketEvolution::Modules::Show
+      include TicketEvolution::Modules::Update
+    end
+  end
+end

data/lib/ticket_evolution/clients.rb

@@ -0,0 +1,8 @@
+module TicketEvolution
+  class Clients < Endpoint
+    include TicketEvolution::Modules::Create
+    include TicketEvolution::Modules::List
+    include TicketEvolution::Modules::Show
+    include TicketEvolution::Modules::Update
+  end
+end

data/lib/ticket_evolution/configuration.rb

@@ -0,0 +1,4 @@
+module TicketEvolution
+  class Configuration < Model
+  end
+end

data/lib/ticket_evolution/configurations.rb

@@ -0,0 +1,6 @@
+module TicketEvolution
+  class Configurations < Endpoint
+    include TicketEvolution::Modules::List
+    include TicketEvolution::Modules::Show
+  end
+end

data/lib/ticket_evolution/core/api_error.rb

@@ -0,0 +1,11 @@
+module TicketEvolution
+  class ApiError
+    attr_reader :error, :message, :code
+
+    def initialize(response)
+      @code = response.response_code
+      @message = response.server_message
+      @error = response.body['error']
+    end
+  end
+end

data/lib/ticket_evolution/core/base.rb

@@ -0,0 +1,12 @@
+module TicketEvolution
+  class Base
+    def method_missing(method, *args)
+      seek = method.to_s.camelize.to_sym
+      if TicketEvolution.const_defined?(seek)
+        "TicketEvolution::#{seek}".constantize.new({:parent => self})
+      else
+        super
+      end
+    end
+  end
+end

data/lib/ticket_evolution/core/builder.rb

@@ -0,0 +1,74 @@
+module TicketEvolution
+  class Builder < OpenStruct
+    include SingularClass
+
+    def initialize(*stuff)
+      super
+      @table.each do |k, v|
+        send("#{k}=", process_datum(v))
+      end
+    end
+
+    def to_hash
+      hash = {}
+      @table.each do |k, v|
+        hash[k] = from_ostruct(v)
+      end
+      hash
+    end
+
+    # Ruby 1.8.7 / REE compatibility
+    def id=(id)
+      @table[:id] = id
+    end
+
+    def id
+      @table[:id]
+    end
+
+    private
+
+    def process_datum(v)
+      case v.class.to_s.to_sym
+      when :Hash
+        Datum.new(v)
+      when :Array
+        v.map{|x| process_datum(x)}
+      when :String
+        Time.parse(v)
+      else
+        v
+      end
+    end
+
+    def from_ostruct(v)
+      if v.kind_of? OpenStruct
+        v.to_hash
+      elsif v.class.to_s == "Array"
+        v.map{|x| from_ostruct(v)}
+      else
+        v
+      end
+    end
+
+    def method_missing(meth, *args)
+      if args.size == 1
+        super(meth, process_datum(args.first))
+      elsif args.size == 0
+        super(meth)
+      else
+        super(meth, process_datum(args))
+      end
+    end
+
+    def datum_exists?(name)
+      defined?(name.constantize) and defined?(singular_class(name.constantize))
+    end
+
+    def class_name_from_url(url)
+      url.split('/').reverse.each do |segment|
+        return "TicketEvolution::#{segment.capitalize}" if segment.split('')[-1] == 's'
+      end
+    end
+  end
+end

data/lib/ticket_evolution/core/collection.rb

@@ -0,0 +1,32 @@
+module TicketEvolution
+  class Collection
+    attr_accessor :total_entries, :per_page, :current_page, :entries
+
+    include Enumerable
+
+    def initialize(options = {})
+      options.each {|k,v| send("#{k}=", v)}
+      @entries ||= []
+    end
+
+    def self.build_from_response(response, entries_key, singular_class)
+      entries = response.body[entries_key] || []
+      new(
+        :total_entries => response.body['total_entries'],
+        :per_page => response.body['per_page'],
+        :current_page => response.body['current_page'],
+        :entries => entries.collect do |entry|
+          singular_class.new(entry.merge({:connection => response.body[:connection]}))
+        end
+      )
+    end
+
+    def size
+      @entries.size
+    end
+
+    def each(&block)
+      @entries.each(&block)
+    end
+  end
+end

data/lib/ticket_evolution/core/connection.rb

@@ -0,0 +1,99 @@
+module TicketEvolution
+  class Connection < Base
+    cattr_reader :default_options, :expected_options, :oldest_version_in_service
+    cattr_accessor :protocol, :url_base
+
+    @@oldest_version_in_service = 8
+
+    @@default_options = HashWithIndifferentAccess.new({
+      :version => @@oldest_version_in_service,
+      :mode => :sandbox,
+      :ssl_verify => true
+    })
+
+    @@expected_options = [
+      'version',
+      'mode',
+      'token',
+      'secret',
+      'ssl_verify'
+    ]
+
+    @@url_base = "ticketevolution.com"
+    @@protocol = "https"
+
+    def initialize(opts = {})
+      @config = self.class.default_options.merge(opts)
+      @config.delete_if{|k, v| ! TicketEvolution::Connection.expected_options.include?(k)}
+
+      # Error Notification
+      if @config.keys.sort_by{|x|x} == TicketEvolution::Connection.expected_options.sort_by{|x|x}
+        raise InvalidConfiguration.new("Invalid Token Format") unless @config[:token] =~ /^[a-zA-Z0-9]{32}$/
+        raise InvalidConfiguration.new("Invalid Secret Format") unless @config[:secret] =~ /^\S{40}$/
+        raise InvalidConfiguration.new("Please Use API Version #{TicketEvolution::Connection.oldest_version_in_service} or Above") unless @config[:version] >= TicketEvolution::Connection.oldest_version_in_service
+      else
+        raise InvalidConfiguration.new("Missing: #{(self.class.expected_options - @config.keys).join(', ')}")
+      end
+    end
+
+    def url
+      @url ||= [].tap do |parts|
+        parts << TicketEvolution::Connection.protocol
+        parts << "://api."
+        parts << "#{@config[:mode]}." unless @config[:mode] == :production
+        parts << TicketEvolution::Connection.url_base
+      end.join
+    end
+
+    def sign(method, path, content = nil)
+      Base64.encode64(
+        OpenSSL::HMAC.digest(
+          OpenSSL::Digest::Digest.new('sha256'),
+          @config[:secret],
+          "#{method} #{process_params(method, path, content).gsub(TicketEvolution::Connection.protocol+'://', '')}"
+      )).chomp
+    end
+
+    def build_request(method, path, params = nil)
+      uri = URI.join(self.url, path).to_s
+      Curl::Easy.new(generate_url(method, uri, params)) do |request|
+        if @config.has_key?(:ssl_verify)
+          request.ssl_verify_host = @config[:ssl_verify]
+          request.ssl_verify_peer = @config[:ssl_verify]
+        end
+        request.post_body = post_body(params) unless method == :GET
+        request.headers["Accept"] = "application/vnd.ticketevolution.api+json; version=#{@config[:version]}"
+        request.headers["X-Signature"] = sign(method, uri, params)
+        request.headers["X-Token"] = @config[:token]
+      end
+    end
+
+    private
+
+    def post_body(params)
+      MultiJson.encode(params)
+    end
+
+    def generate_url(method, uri, params)
+      case method
+      when :GET
+        process_params(method, uri, params)
+      else
+        uri
+      end
+    end
+
+    def process_params(method, path, params)
+      suffix = if params.present?
+        case method
+        when :GET
+          params.to_query
+        else
+          post_body(params)
+        end
+      end
+
+      "#{URI.join(url, path).to_s}?" + suffix.to_s
+    end
+  end
+end

data/lib/ticket_evolution/core/datum.rb

@@ -0,0 +1,7 @@
+module TicketEvolution
+  class Datum < Builder
+    def [](key)
+      send(key)
+    end
+  end
+end

data/lib/ticket_evolution/core/endpoint/request_handler.rb

@@ -0,0 +1,46 @@
+module TicketEvolution
+  class Endpoint < Base
+    module RequestHandler
+
+      # Response Code Mappings From TicketEvolution API
+      CODES = {
+        200 => ["OK","Generally returned by successful GET requests. "],
+        201 => ["Created","Generally returned by successful POST requests. "],
+        202 => ["Accepted","Generally returned when a request has succeeded, but has been scheduled processing at a later time. "],
+        301 => ["Moved Permanently","Used when a resource's URL has changed."],
+        302 => ["Found","Returned when there's a redirect that should be followed."],
+        400 => ["Bad Request","Generally returned on POST and PUT requests when validation fails for the given input. "],
+        401 => ["Unauthorized","Returned when the authentication credentials are invalid."],
+        404 => ["Not Found","The requested resource could not be located."],
+        406 => ["Not Acceptable","The requested content type or version is invalid."],
+        500 => ["Internal Server Error","Used a general error response for processing errors or other issues with the web service. "],
+        503 => ["Service Unavailable","Returned when the API service is temporarily unavailable. This could also indicate that the rate limit for the given token has been reached. If this status is received, the request should be retried."]
+      }
+
+      def request(method, path, params = nil, &response_handler)
+        response = self.build_request(method, path, params)
+        response.http(method)
+        response = self.naturalize_response(response)
+        if response.response_code >= 400
+          TicketEvolution::ApiError.new(response)
+        else
+          response_handler.call(response)
+        end
+      end
+
+      def build_request(method, path, params = nil)
+        raise EndpointConfigurationError, "#{self.class.to_s}#request requires it's first parameter to be a valid HTTP method" unless [:GET, :POST, :PUT, :DELETE].include? method.to_sym
+        self.connection.build_request(method, "#{self.base_path}#{path}", params)
+      end
+
+      def naturalize_response(response)
+        OpenStruct.new.tap do |resp|
+          resp.header = response.header_str
+          resp.response_code = response.response_code
+          resp.body = MultiJson.decode(response.body_str).merge({:connection => self.connection})
+          resp.server_message = CODES[response.response_code].last
+        end
+      end
+    end
+  end
+end

data/lib/ticket_evolution/core/endpoint.rb

@@ -0,0 +1,51 @@
+module TicketEvolution
+  class Endpoint < Base
+    include RequestHandler
+    include SingularClass
+
+    def initialize(options = nil)
+      raise EndpointConfigurationError, "#{self.class.to_s} instances require a hash as their first parameter" unless options.is_a? Hash
+      raise EndpointConfigurationError, "The options hash must include a parent key / value pair" unless options[:parent].present?
+      raise EndpointConfigurationError, "#{self.class.to_s} instances require a parent which inherits from TicketEvolution::Base" unless options[:parent].kind_of? TicketEvolution::Base
+      options.each do |k, v|
+        self.singleton_class.send(:attr_accessor, k)
+        send("#{k}=", v)
+      end
+      raise EndpointConfigurationError, "The parent passed in the options hash must be a TicketEvolution::Connection object or have one in it's parent chain" unless has_connection?
+    end
+
+    def base_path
+      [].tap do |parts|
+        parts << parent.base_path if parent.kind_of? TicketEvolution::Endpoint
+        parts << "/"+endpoint_name
+        parts << "/#{self.id}" if self.respond_to?("id=") and self.id.present?
+      end.join
+    end
+
+    def connection
+      if self.parent.is_a? TicketEvolution::Connection
+        self.parent
+      elsif self.parent.respond_to? :parent
+        self.parent.connection
+      else
+        nil
+      end
+    end
+
+    def has_connection?
+      connection.present?
+    end
+
+    def endpoint_name
+      self.class.name.demodulize.underscore
+    end
+
+    private
+
+    def ensure_id
+      raise TicketEvolution::MethodUnavailableError.new \
+        "#{self.class.to_s}##{caller.first.split('`').last.split("'").first} can only be called if there is an id present on this #{self.class.to_s} instance" \
+        unless self.respond_to?("id=") and self.id.present?
+    end
+  end
+end

data/lib/ticket_evolution/core/model.rb

@@ -0,0 +1,64 @@
+module TicketEvolution
+  class Model < Builder
+    def initialize(params = {})
+      @connection = params.delete(:connection)
+      raise TicketEvolution::ConnectionNotFound.new \
+        "#{self.class.name} must receive a TicketEvolution::Connection object on initialize" \
+        unless @connection.is_a? TicketEvolution::Connection
+      @scope = params['url'].split('/')[0..2].join('/') if params['url'] =~ /^(\/[a-z_]+s\/\d){2}$/
+      super(params)
+    end
+
+    def plural_class_name
+      parts = ["TicketEvolution", self.class.name.demodulize.pluralize.camelize]
+      parts[0] = self.scope[:class] if @scope.present?
+      parts.join('::')
+    end
+
+    def plural_class
+      self.plural_class_name.constantize
+    end
+
+    def attributes
+      HashWithIndifferentAccess.new(to_hash)
+    end
+
+    def attributes=(params)
+      params.each do |k, v|
+        send("#{k}=", v)
+      end
+    end
+
+    def scope
+      if @scope.present?
+        {}.tap do |scope|
+          parts = @scope.split('/')
+          scope[:class] = "TicketEvolution::#{parts[1].camelize}"
+          scope[:id] = parts[2].to_i
+        end
+      else
+        nil
+      end
+    end
+
+    private
+
+    def process_datum(v)
+      if v.is_a? Hash and v['url'].present?
+        name = class_name_from_url(v['url'])
+        datum_exists?(name) ? singular_class(class_name_from_url(name)).new(v.merge({:connection => @connection})) : Datum.new(v)
+      else
+        super
+      end
+    end
+
+    def method_missing(method, *args)
+      seek = method.to_s.camelize
+      if seek !~ /=/ and plural_class.const_defined?(seek.to_sym)
+        "#{plural_class_name}::#{seek}".constantize.new(:parent => plural_class.new(:connection => @connection, :id => self.id))
+      else
+        super
+      end
+    end
+  end
+end

data/lib/ticket_evolution/core/models/samples.rb

@@ -0,0 +1,8 @@
+module TicketEvolution
+  class Models < TicketEvolution::Endpoint
+    class Samples < TicketEvolution::Base
+      # This class exists to decouple tests of Model from actual functionality
+      # There must be a better way
+    end
+  end
+end

data/lib/ticket_evolution/core/samples.rb

@@ -0,0 +1,6 @@
+module TicketEvolution
+  class Samples < Base
+    # This class exists to decouple tests of Base from actual functionality
+    def initialize(*attrs); end
+  end
+end

data/lib/ticket_evolution/core/singular_class.rb

@@ -0,0 +1,7 @@
+module TicketEvolution
+  module SingularClass
+    def singular_class(klass = self.class)
+      "TicketEvolution::#{(klass.is_a?(String) ? klass : klass.name).demodulize.singularize.camelize}".constantize
+    end
+  end
+end

data/lib/ticket_evolution/core/time.rb

@@ -0,0 +1,19 @@
+module TicketEvolution
+  class Time < ::Time
+    def self.parse(str)
+      if str =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/
+        parts = str.split(/[-T:Z]/).collect(&:to_i)
+        Time.gm(
+          parts[0],
+          parts[1],
+          parts[2],
+          parts[3],
+          parts[4],
+          parts[5]
+        )
+      else
+        str
+      end
+    end
+  end
+end

data/lib/ticket_evolution/credit_card.rb

@@ -0,0 +1,4 @@
+module TicketEvolution
+  class CreditCard < Model
+  end
+end

data/lib/ticket_evolution/email_address.rb

@@ -0,0 +1,4 @@
+module TicketEvolution
+  class EmailAddress < Model
+  end
+end

data/lib/ticket_evolution/errors/connection_not_found.rb

@@ -0,0 +1,4 @@
+module TicketEvolution
+  class ConnectionNotFound < Exception
+  end
+end

data/lib/ticket_evolution/errors/endpoint_configuration_error.rb

@@ -0,0 +1,5 @@
+module TicketEvolution
+  class EndpointConfigurationError < Exception
+  end
+end
+

data/lib/ticket_evolution/errors/invalid_configuration.rb

@@ -0,0 +1,4 @@
+module TicketEvolution
+  class InvalidConfiguration < Exception
+  end
+end

data/lib/ticket_evolution/errors/method_unavailable_error.rb

@@ -0,0 +1,4 @@
+module TicketEvolution
+  class MethodUnavailableError < Exception
+  end
+end

data/lib/ticket_evolution/event.rb

@@ -0,0 +1,4 @@
+module TicketEvolution
+  class Event < Model
+  end
+end

data/lib/ticket_evolution/events.rb

@@ -0,0 +1,7 @@
+module TicketEvolution
+  class Events < Endpoint
+    include TicketEvolution::Modules::Deleted
+    include TicketEvolution::Modules::List
+    include TicketEvolution::Modules::Show
+  end
+end

data/lib/ticket_evolution/modules/create.rb

@@ -0,0 +1,18 @@
+module TicketEvolution
+  module Modules
+    module Create
+      def create(params = nil)
+        params = { endpoint_name.to_sym => [params] } if params.present?
+        request(:POST, nil, params, &method(:build_for_create))
+      end
+
+      def build_for_create(response)
+        singular_class.new(response.body[endpoint_name].first.merge({
+          :status_code => response.response_code,
+          :server_message => response.server_message,
+          :connection => response.body[:connection]
+        }))
+      end
+    end
+  end
+end

data/lib/ticket_evolution/modules/deleted.rb

@@ -0,0 +1,13 @@
+module TicketEvolution
+  module Modules
+    module Deleted
+      def deleted(params = nil)
+        request(:GET, '/deleted', params, &method(:build_for_deleted))
+      end
+
+      def build_for_deleted(response)
+        TicketEvolution::Collection.build_from_response(response, self.class.name.demodulize.underscore, singular_class)
+      end
+    end
+  end
+end

data/lib/ticket_evolution/modules/list.rb

@@ -0,0 +1,15 @@
+module TicketEvolution
+  module Modules
+    module List
+      def list(params = nil)
+        request(:GET, nil, params, &method(:build_for_list))
+      end
+
+      alias :all :list
+
+      def build_for_list(response)
+        TicketEvolution::Collection.build_from_response(response, self.class.name.demodulize.underscore, singular_class)
+      end
+    end
+  end
+end

data/lib/ticket_evolution/modules/search.rb

@@ -0,0 +1,13 @@
+module TicketEvolution
+  module Modules
+    module Search
+      def search(params = nil)
+        request(:GET, '/search', params, &method(:build_for_search))
+      end
+
+      def build_for_search(response)
+        TicketEvolution::Collection.build_from_response(response, self.class.name.demodulize.underscore, singular_class)
+      end
+    end
+  end
+end

data/lib/ticket_evolution/modules/show.rb

@@ -0,0 +1,20 @@
+module TicketEvolution
+  module Modules
+    module Show
+      def show(id)
+        request(:GET, "/#{id}", &method(:build_for_show))
+      end
+
+      alias :find :show
+
+      def build_for_show(response)
+        singular_class.new(
+          response.body.merge({
+          :status_code => response.response_code,
+          :server_message => response.server_message
+        })
+        )
+      end
+    end
+  end
+end

data/lib/ticket_evolution/modules/update.rb

@@ -0,0 +1,24 @@
+module TicketEvolution
+  module Modules
+    module Update
+      def self.included(klass)
+        Class.new{extend SingularClass}.singular_class(klass.name).send(:include, Module.new{
+          def update_attributes(params)
+            params.each{|k, v| send("#{k}=", process_datum(v))}
+            plural_class.new({:parent => @connection, :id => params.delete(:id)}).update(params)
+          end
+
+          def save
+            atts = self.attributes
+            plural_class.new({:parent => @connection, :id => atts.delete(:id)}).update(atts)
+          end
+        })
+      end
+
+      def update(params = nil)
+        ensure_id
+        request(:PUT, "/#{self.id}", params)
+      end
+    end
+  end
+end