geocerts 0.0.11

data/lib/geo_certs/endpoints/products.rb

@@ -0,0 +1,30 @@
+module GeoCerts
+  module Endpoints # :nodoc:
+    
+    module Products # :nodoc:
+      
+      def self.included(base)
+        base.class_eval do
+          endpoint GeoCerts::API::ENDPOINT do
+            
+            action :products, :url => '/products.xml' do
+              parser Parsers::OrderParser do
+                element :products do
+                  elements :product do
+                    element :name
+                    element :sku
+                    element :code
+                    element 'max-years', :as => :max_years, :type => Integer
+                  end
+                end
+              end
+            end
+            
+          end
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/geo_certs/errors.rb

@@ -0,0 +1,30 @@
+module GeoCerts
+  
+  class MessageWithCode # :nodoc:
+    attr_accessor :code, :message
+    
+    def initialize(attributes = {})
+      self.code     = attributes[:code].to_i
+      self.message  = attributes[:message]
+    end
+    
+    def to_s #:nodoc:
+      "#{self.class.name} ##{code}: #{message}"
+    end
+  end
+  
+  ##
+  # Errors are returned when a request to GeoCerts fails.  The exception will be returned 
+  # with a collection of Error objects which detail the error +code+ and +message+.
+  # 
+  class Error < MessageWithCode
+  end
+  
+  ##
+  # Warnings may be returned with either successful or unsuccessful requests to GeoCerts.  
+  # Warnings contain the warning +code+ and +message+.
+  # 
+  class Warning < MessageWithCode
+  end
+  
+end

data/lib/geo_certs/event.rb

@@ -0,0 +1,67 @@
+module GeoCerts
+  
+  ##
+  # GeoCerts tracks events which occur that are related to your Order(s).  This class 
+  # interfaces with those events to provide collections of all of your events or events
+  # against a particular GeoCerts::Order.
+  # 
+  class Event < ApiObject
+    
+    attr_accessor :id,
+                  :order_id,
+                  :name,
+                  :created_at
+    
+    
+    ##
+    # Returns all events which occurred within the requested time window.  The server 
+    # defaults to a 15 minute window.
+    # 
+    # == Options
+    # 
+    # :start_at:: The starting DateTime for the date range
+    # :end_at:: The ending DateTime for the date range
+    # 
+    def self.all(options = {})
+      prep_date_ranges!(options)
+      response = call_api { GeoCerts.api.events(options) }
+      build_collection(response) { |response| response[:events][:event] }
+    end
+    
+    ##
+    # Returns all events which occurred within the requested time window for the requested
+    # GeoCerts::Order.  The server defaults to a 15 minute window.
+    # 
+    # == Options
+    # 
+    # :start_at:: The starting DateTime for the date range
+    # :end_at:: The ending DateTime for the date range
+    # 
+    # === Exceptions
+    # 
+    # This method will raise GeoCerts exceptions if the requested +order_id+ cannot be found.
+    # 
+    def self.find(order_id, options = {})
+      prep_date_ranges!(options)
+      order_id = order_id.id if order_id.kind_of?(GeoCerts::Order)
+      options[:order_id]  = order_id
+      build_collection(call_api { GeoCerts.api.order_events(options) }) { |response|
+        response[:events][:event]
+      }
+    end
+    
+    ##
+    # This method will not raise an exception for a missing +order_id+ in the GeoCerts system.  
+    # Instead, it will return an empty collection.
+    # 
+    # See GeoCerts::Event.find for more information.
+    # 
+    def self.find_by_order_id(order_id, options = {})
+      find(order_id, options)
+    rescue GeoCerts::AllowableExceptionWithResponse
+      []
+    end
+    
+  end
+  
+end

data/lib/geo_certs/exceptions.rb

@@ -0,0 +1,124 @@
+require 'zlib'
+require 'geo_certs/errors'
+
+module GeoCerts
+  
+  HTTP_ERRORS = [ Timeout::Error,
+                  Errno::EINVAL,
+                  Errno::ECONNRESET,
+                  Errno::ECONNREFUSED,
+                  EOFError,
+                  Net::HTTPBadResponse,
+                  Net::HTTPHeaderSyntaxError,
+                  Net::ProtocolError ]
+  
+  ##
+  # The lowest-level GeoCerts exception.  All exceptions raised from within this library 
+  # should be inherited from this exception.
+  # 
+  class Exception < RuntimeError
+    
+    ##
+    # Wraps the given exception, keeping the message and backtrace.
+    # 
+    def self.from(exception)
+      new("%s: %s" % [exception.class.name, exception.message]).tap do |me|
+        me.set_backtrace(exception.backtrace)
+      end
+    end
+    
+  end
+  
+  ##
+  # An exception that is raised which contains an HTTP response, and additionally, errors
+  # and warnings received from GeoCerts.
+  # 
+  class ExceptionWithResponse < Exception
+    
+    attr_reader :response
+    
+    def initialize(response = nil)
+      if response.respond_to?(:response)
+        self.response = response.response
+      elsif response
+        self.response = response
+      end
+      
+      self.set_backtrace(response.backtrace) if response.respond_to?(:backtrace)
+    end
+    
+    def http_code
+      response && response.respond_to?(:code) ? response.code.to_i : nil
+    end
+    
+    def errors
+      @errors ||= []
+    end
+    
+    def warnings
+      @warnings ||= []
+    end
+    
+    def response=(response) # :nodoc:
+      @response = response
+      
+      if !response.respond_to?(:body)
+        return @response
+      elsif Hash.respond_to?(:from_xml)
+        build_objects_for(Hash.from_xml(decode(response['content-encoding'], response.body)))
+      else
+        build_objects_for(parse_errors(decode(response['content-encoding'], response.body)))
+      end
+      
+      @response
+    end
+    
+    def to_s # :nodoc:
+      "HTTP #{http_code}: A #{self.class.name} exception has occurred"
+    end
+    
+    private
+    
+    
+    def parse_errors(input)
+      require 'geo_certs/hash_extension'
+      Hash.from_libxml(input)
+    end
+    
+    def build_objects_for(errors_and_warnings)
+      [errors_and_warnings['errors']['error']].compact.flatten.each do |error|
+        self.errors << GeoCerts::Error.new(:code => error['code'], :message => error['message'])
+      end
+      [errors_and_warnings['errors']['warning']].compact.flatten.each do |error|
+        self.warnings << GeoCerts::Warning.new(:code => error['code'], :message => error['message'])
+      end
+    end
+    
+    def decode(content_encoding, body)
+			if content_encoding == 'gzip' and not body.empty?
+				Zlib::GzipReader.new(StringIO.new(body)).read
+			elsif content_encoding == 'deflate'
+				Zlib::Inflate.new.inflate(body)
+			else
+				body
+			end
+		end
+    
+  end
+  
+  # :stopdoc:
+  
+  class AllowableExceptionWithResponse < ExceptionWithResponse; end
+  class Unauthorized        < ExceptionWithResponse; end
+  class BadRequest          < ExceptionWithResponse; end
+  class UnprocessableEntity < AllowableExceptionWithResponse; end
+  class ResourceNotFound    < AllowableExceptionWithResponse; end
+  class ResourceNotCreated  < Exception; end
+  class ResourceInvalid     < Exception; end
+  class RequestFailed       < AllowableExceptionWithResponse; end
+  class RequestTimeout      < Exception; end
+  class ConnectionError     < Exception; end
+  
+  # :startdoc:
+  
+end

data/lib/geo_certs/hash_extension.rb

@@ -0,0 +1,50 @@
+require 'libxml'
+
+class Hash # :nodoc:
+  class << self
+        def from_libxml(xml, strict=true)
+          begin
+            LibXML::XML.default_load_external_dtd = false
+            LibXML::XML.default_pedantic_parser = strict
+            result = LibXML::XML::Parser.string(xml).parse 
+            return { result.root.name.to_s => xml_node_to_hash(result.root)} 
+          rescue
+            raise $!
+            # raise your custom exception here
+          end
+        end 
+
+        def xml_node_to_hash(node) 
+          # If we are at the root of the document, start the hash 
+          if node.element? 
+           if node.children? 
+              result_hash = {} 
+
+              node.each_child do |child| 
+                result = xml_node_to_hash(child) 
+
+                if child.name == "text"
+                  if !child.next? and !child.prev?
+                    return result
+                  end
+                elsif result_hash[child.name]
+                    if result_hash[child.name].is_a?(Object::Array)
+                      result_hash[child.name] << result
+                    else
+                      result_hash[child.name] = [result_hash[child.name]] << result
+                    end
+                  else 
+                    result_hash[child.name] = result
+                  end
+                end
+
+              return result_hash 
+            else 
+              return nil 
+           end 
+           else 
+            return node.content.to_s 
+          end 
+        end          
+    end
+end

data/lib/geo_certs/order.rb

@@ -0,0 +1,369 @@
+require 'cgi'
+require 'geo_certs/api_object'
+require 'geo_certs/order/administrator'
+require 'geo_certs/order/extended_validation_approver'
+require 'geo_certs/order/organization'
+require 'geo_certs/order/renewal_information'
+
+module GeoCerts
+
+  ##
+  # Contains the details, attributes, and methods to interact with a GeoCerts order.
+  #
+  class Order < ApiObject
+
+    attr_accessor :approver_email,
+                  :completed_at,
+                  :created_at,
+                  :domain,
+                  :geotrust_order_id,
+                  :id,
+                  :licenses,
+                  :sans,
+                  :state,
+                  :status_major,
+                  :status_minor,
+                  :total_price,
+                  :years
+    attr_reader   :administrator,
+                  :csr,
+                  :ev_approver,
+                  :organization,
+                  :pending_audit,
+                  :product,
+                  :renewal,
+                  :renewal_information,
+                  :trial
+
+    alias         :approver= :approver_email=
+
+    force_boolean :pending_audit,
+                  :renewal,
+                  :trial
+
+    ##
+    # Returns all orders within the requested date range.  By default the server will
+    # return orders within the past month (30 days).
+    #
+    # === Options
+    #
+    # :start_at:: The starting DateTime for the date range
+    # :end_at:: The ending DateTime for the date range
+    #
+    def self.all(options = {})
+      prep_date_ranges!(options)
+      response = call_api { GeoCerts.api.orders(options) }
+      build_collection(response) { |response| response[:orders][:order] }
+    end
+
+    ##
+    # Returns a GeoCerts order by the order +id+ given.
+    #
+    # === Exceptions
+    #
+    # If the +id+ cannot be found on the GeoCerts system, a GeoCerts::ResourceNotFound exception
+    # will be raised.
+    #
+    def self.find(id)
+      new(call_api { GeoCerts.api.find_order(:id => id)[:order] })
+    end
+
+    ##
+    # Similar to GeoCerts::Product.find, but instead of raising an exception when an order cannot
+    # be located, instead it will return +nil+.
+    #
+    # See GeoCerts::Product.find for more information.
+    #
+    def self.find_by_id(id)
+      find(id)
+    rescue GeoCerts::AllowableExceptionWithResponse
+      nil
+    end
+
+    def self.approvers(domain)
+      response = call_api { GeoCerts.api.domain_approvers(:domain => domain) }
+      collection = Collection.new
+      response[:emails][:email].each { |email| collection << Email.new(email) }
+      collection
+    end
+
+    ##
+    # Creates a new order on GeoCerts with the attributes given.
+    #
+    # This method will return an Order regardless of whether or not it was saved.
+    # You should check new_record? to determine whether or not there was a failure.
+    # Also, errors should not be empty if there was a failure.
+    #
+    def self.create(attributes = {}, &block)
+      object = new(attributes, &block)
+      object.save
+      object
+    end
+
+    ##
+    # Creates a new order on GeoCerts with the attributes given.
+    #
+    # === Exceptions
+    #
+    # This method will raise a GeoCerts::ResourceNotCreated exception if the order
+    # cannot be created.
+    #
+    def self.create!(attributes = {}, &block)
+      instance = create(attributes, &block)
+      raise(ResourceNotCreated, instance.errors.collect { |e| e.message }.join(', ')) if instance.new_record?
+      instance
+    end
+
+    ##
+    # Validates an order with the attributes provided.  This method will also parse a given CSR
+    # body and populate the returned Order's CSR object with the parsed data.
+    #
+    # An Order will be returned whether or not validation was successful.  To
+    # determine if validation was unsuccessful, you should check for errors
+    # (i.e. order.errors.empty? should be true).
+    #
+    def self.validate(attributes = {}, &block)
+      object = new(attributes, &block)
+      object.validate
+      object
+    end
+
+    ##
+    # See GeoCerts::Order.validate for more information.
+    #
+    # === Exceptions
+    #
+    # This method will raise GeoCerts::ResourceInvalid if the order is invalid.
+    #
+    def self.validate!(attributes = {}, &block)
+      instance = validate(attributes, &block)
+      raise(ResourceInvalid, instance.errors.collect { |e| e.message }.join(', ')) unless instance.errors.empty?
+      instance
+    end
+
+
+    ##
+    # Modifies the order state by setting it to the +action+ requested.
+    #
+    # Acceptable actions are: 'APPROVE' and 'CANCEL'
+    #
+    def modify!(action)
+      update_attributes(self.class.call_api {
+        GeoCerts.api.modify_order(:id => self.id, :state => action)
+      })
+    end
+
+    ##
+    # Instructs GeoCerts to resend the SSL certificate approval email to the
+    # approval address on the order.
+    #
+    def resend_approval_email!
+      update_attributes(self.class.call_api {
+        GeoCerts.api.resend_approval_email(:id => self.id)
+      })
+    end
+
+    ##
+    # Updates the approver email for the SSL certificate in the order.
+    #
+    def change_approver_email!(email)
+      update_attributes(self.class.call_api {
+        GeoCerts.api.change_order_approval_email(:id => self.id, :approver_email => email)
+      })
+    end
+
+    ##
+    # Validates the order attributes provided.  You must, at least, provide a
+    # CSR and Product:
+    #
+    #   GeoCerts::Order.new({
+    #     :csr => "-----BEGIN CERTIFICATE REQUEST-----\n....",
+    #     :product => 'QP'
+    #   }).validate
+    #
+    # This method will return +false+ if the order is invalid.  Details of the
+    # validation errors can be found in +errors+.
+    #
+    def validate
+      parameters = {}
+      parameters[:years]        = self.years
+      parameters[:licenses]     = self.licenses
+      parameters[:sans]         = GeoCerts.escape(self.sans) if self.sans
+      parameters.merge!(self.csr.to_geocerts_hash)      if self.csr
+      parameters.merge!(self.product.to_geocerts_hash)  if self.product
+
+      update_attributes(self.class.call_api {GeoCerts.api.validate_order(parameters)[:order]})
+    rescue GeoCerts::AllowableExceptionWithResponse
+      store_exception_errors_and_warnings($!)
+      false
+    end
+
+    ##
+    # Acts similarly to +validate+, but will raise a GeoCerts::ResourceInvalid
+    # exception if validation fails.
+    #
+    def validate!
+      validate
+      raise(GeoCerts::ResourceInvalid) unless self.errors.empty?
+      self
+    end
+
+    ##
+    # Creates the order in the GeoCerts system.  This will also deduct the cost of
+    # the order from your available balance.
+    #
+    # If the order cannot be created, this method will return +false+.
+    #
+    def save
+      new_record? ? create : raise("Cannot update an existing Order")
+      self.errors.empty? ? self : false
+    end
+
+    ##
+    # Acts similarly to +save+, but raises a GeoCerts::ResourceNotCreated exception
+    # if the order cannot be saved.
+    #
+    def save!
+      save ? self : raise(GeoCerts::ResourceNotCreated)
+    end
+
+    ##
+    # Returns +true+ if the Order has not been saved.
+    #
+    def new_record?
+      self.id.nil?
+    end
+
+    ##
+    # Sets the CSR for the order.  You can either pass a GeoCerts::CSR object, or
+    # the body of a CSR.
+    #
+    #   order.csr = GeoCerts::CSR.new(:body => "-----BEGIN CERTIFICATE REQUEST-----\n....")
+    #   order.csr = "-----BEGIN CERTIFICATE REQUEST-----\n...."
+    #
+    def csr=(input)
+      @csr = case input
+        when CSR
+          input
+        when Hash
+          CSR.new(input)
+        when String
+          if input =~ /CERTIFICATE REQUEST-----/
+            CSR.new({:body => input})
+          else
+            raise ArgumentError.new("Unrecognized CSR given.  Expected a CSR, Hash, or CSR body string, got: \"#{input.inspect}\"")
+          end
+        else
+          raise ArgumentError.new("Unrecognized CSR given.  Expected a CSR, Hash, or CSR body string, got: \"#{input.inspect}\"")
+        end
+    end
+
+    ##
+    # Sets the renewal information for the order.  This method accepts either
+    # a GeoCerts::RenewalInformation instance or a hash of attributes.
+    # 
+    def renewal_information=(input)
+      case input
+      when RenewalInformation
+        @renewal_information = input
+      when Hash
+        @renewal_information = RenewalInformation.new(input)
+      end
+    end
+
+    ##
+    # Sets the product for the order.  You can either pass a GeoCerts::Product
+    # object or the SKU for a GeoCerts product.
+    #
+    #   order.product = GeoCerts::Product.new(:sku => 'QP')
+    #   order.product = 'QP'
+    #
+    def product=(input)
+      @product = case input
+        when Product
+          input
+        when String
+          Product.find(input)
+        end
+    end
+
+    ##
+    # Sets the extended validation approver for the order.  This method 
+    # accepts either a GeoCerts::ExtendedValidationApprover instance or a 
+    # hash of attributes.
+    # 
+    def ev_approver=(input)
+      case input
+      when ExtendedValidationApprover
+        @ev_approver = input
+      when Hash
+        @ev_approver = ExtendedValidationApprover.new(input)
+      end
+    end
+
+    ##
+    # Sets the administrator for the order.  This method accepts either a
+    # GeoCerts::Administrator instance or a hash of administrator attributes.
+    # 
+    def administrator=(input)
+      case input
+      when Administrator
+        @administrator = input
+      when Hash
+        @administrator = Administrator.new(input)
+      end
+    end
+    
+    ##
+    # Sets the organization for the order.  This method accepts either a
+    # GeoCerts::Organization instance or a hash of organization attributes.
+    # 
+    def organization=(input)
+      case input
+      when Organization
+        @organization = input
+      when Hash
+        @organization = Organization.new(input)
+      end
+    end
+
+    ##
+    # Returns a collection of events for the order.
+    #
+    def events
+      GeoCerts::Event.find_by_order_id(self.id)
+    end
+
+    ##
+    # Returns a GeoCerts::Certificate associated with this order.
+    #
+    def certificate
+      GeoCerts::Certificate.find_by_order_id(self.id)
+    end
+
+
+    private
+
+
+    def create
+      parameters = {}
+      parameters[:approver_email]   = GeoCerts.escape(self.approver_email)
+      parameters[:years]            = GeoCerts.escape(self.years)
+      parameters[:licenses]         = GeoCerts.escape(self.licenses)
+      parameters[:sans]             = GeoCerts.escape(self.sans)
+      parameters.merge!(self.csr.to_geocerts_hash)            if self.csr
+      parameters.merge!(self.product.to_geocerts_hash)        if self.product
+      parameters.merge!(self.ev_approver.to_geocerts_hash)    if self.ev_approver
+      parameters.merge!(self.administrator.to_geocerts_hash)  if self.administrator
+      parameters.merge!(self.organization.to_geocerts_hash)   if self.organization
+
+      update_attributes(self.class.call_api {GeoCerts.api.create_order(parameters)[:order]})
+      self
+    rescue GeoCerts::AllowableExceptionWithResponse
+      store_exception_errors_and_warnings($!)
+      self
+    end
+
+  end
+
+end