cardmagic-etsy 0.3.2

data/lib/etsy/payment_template.rb

@@ -0,0 +1,33 @@
+module Etsy
+  class PaymentTemplate
+    include Etsy::Model
+
+    attribute :id, :from => :payment_template_id
+    attributes :allow_check, :allow_mo, :allow_other, :allow_paypal, :allow_cc
+    attributes :paypal_email, :name, :first_line, :second_line, :city, :state
+    attributes :zip, :country_id
+
+    def self.create(options = {})
+      options.merge!(:require_secure => true)
+      post("/payments/templates", options)
+    end
+ 
+    def self.find(id, credentials = {})
+      options = {
+        :access_token => credentials[:access_token],
+        :access_secret => credentials[:access_secret],
+        :require_secure => true
+      }
+      get("/payments/templates/#{id}", options)
+    end
+
+    def self.find_by_user(user, credentials = {})
+      options = {
+        :access_token => credentials[:access_token],
+        :access_secret => credentials[:access_secret],
+        :require_secure => true
+      }
+      get("/users/#{user.id}/payments/templates", options)
+    end
+  end
+end

data/lib/etsy/profile.rb

@@ -0,0 +1,49 @@
+module Etsy
+
+  # = Profile
+  #
+  # Represents a profile resource of an Etsy user.
+  #
+  class Profile
+
+    include Etsy::Model
+
+    attribute :id, :from => :user_profile_id
+    attribute :user_id
+    attribute :bio
+    attribute :username, :from => :login_name
+    attribute :gender
+    attribute :birth_day
+    attribute :birth_month
+    attribute :birth_year
+    attribute :joined, :from => :join_tsz
+    attribute :favorite_materials, :from => :materials
+    attribute :country_id
+    attribute :city
+    attribute :location
+    attribute :region
+    attribute :avatar_id
+    attribute :image, :from => :image_url_75x75
+    attribute :lat
+    attribute :lon
+    attribute :transaction_buy_count
+    attribute :transaction_sold_count
+    attribute :is_seller
+    attribute :first_name
+    attribute :last_name
+
+    def materials
+      favorite_materials ? favorite_materials.split(',') : []
+    end
+
+    # Time that this user joined Etsy
+    #
+    def joined_at
+      Time.at(joined)
+    end
+
+    def seller?
+      is_seller
+    end
+  end
+end

data/lib/etsy/receipt.rb

@@ -0,0 +1,37 @@
+module Etsy
+  class Receipt
+    include Model
+
+    attribute :id, :from => :receipt_id
+    attribute :buyer_id, :from => :buyer_user_id
+
+    attributes :quantity, :listing_id, :name, :first_line, :second_line, :city, :state, :zip, :country_id,
+               :payment_email, :buyer_email, :creation_tsz
+
+    def self.find_all_by_shop_id(shop_id, options = {})
+      get_all("/shops/#{shop_id}/receipts", options)
+    end
+
+    def self.find_all_by_shop_id_and_status(shop_id, status, options = {})
+      get_all("/shops/#{shop_id}/receipts/#{status}", options)
+    end
+
+    def created_at
+      Time.at(creation_tsz)
+    end
+
+    def buyer
+      @buyer ||= User.find(buyer_id)
+    end
+
+    def transactions
+      unless @transactions
+        options = {}
+        options = options.merge(:access_token => token, :access_secret => secret) if (token && secret)
+        @transactions = Transaction.find_all_by_receipt_id(id, options)
+      end
+      @transactions
+    end
+
+  end
+end

data/lib/etsy/request.rb

@@ -0,0 +1,150 @@
+module Etsy
+
+  # = Request
+  #
+  # A basic wrapper around GET requests to the Etsy JSON API
+  #
+  class Request
+
+    # Perform a GET request for the resource with optional parameters - returns
+    # A Response object with the payload data
+    def self.get(resource_path, parameters = {})
+      request = Request.new(resource_path, parameters)
+      Response.new(request.get)
+    end
+
+    def self.post(resource_path, parameters = {})
+      request = Request.new(resource_path, parameters)
+      Response.new(request.post)
+    end
+
+    def self.put(resource_path, parameters = {})
+      request = Request.new(resource_path, parameters)
+      Response.new(request.put)
+    end
+    
+    def self.delete(resource_path, parameters = {})
+      request = Request.new(resource_path, parameters)
+      Response.new(request.delete)
+    end
+    
+    
+
+    # Create a new request for the resource with optional parameters
+    def initialize(resource_path, parameters = {})
+      parameters = parameters.dup
+      @token = parameters.delete(:access_token) || Etsy.credentials[:access_token]
+      @secret = parameters.delete(:access_secret) || Etsy.credentials[:access_secret]
+      raise("Secure connection required. Please provide your OAuth credentials via :access_token and :access_secret in the parameters") if parameters.delete(:require_secure) && !secure?
+      @multipart_request = parameters.delete(:multipart)
+      @resource_path = resource_path
+      @resources = parameters.delete(:includes)
+      if @resources.class == String
+        @resources = @resources.split(',').map {|r| {:resource => r}}
+      elsif @resources.class == Array
+        @resources = @resources.map do |r|
+          if r.class == String
+            {:resource => r}
+          else
+            r
+          end
+        end
+      end
+      parameters = parameters.merge(:api_key => Etsy.api_key) unless secure?
+      @parameters = parameters
+    end
+
+    def base_path # :nodoc:
+      "/v2"
+    end
+
+    # Perform a GET request against the API endpoint and return the raw
+    # response data
+    def get
+      client.get(endpoint_url)
+    end
+
+    def post
+      if multipart?
+        client.post_multipart(endpoint_url(:include_query => false), @parameters)
+      else
+        client.post(endpoint_url)
+      end
+    end
+
+    def put
+      client.put(endpoint_url)
+    end
+    
+    def delete
+      client.delete(endpoint_url)
+    end
+
+    def client # :nodoc:
+      @client ||= secure? ? secure_client : basic_client
+    end
+
+    def parameters # :nodoc:
+      @parameters
+    end
+
+    def resources # :nodoc:
+      @resources
+    end
+
+    def query # :nodoc:
+      to_url(parameters.merge(:includes => resources.to_a.map { |r| association(r) }))
+    end
+
+    def to_url(val)
+      if val.is_a? Array
+        to_url(val.join(','))
+      elsif val.is_a? Hash
+        val.reject { |k, v|
+          k.nil? || v.nil? || (k.respond_to?(:empty?) && k.empty?) || (v.respond_to?(:empty?) && v.empty?)
+        }.map { |k, v| "#{to_url(k.to_s)}=#{to_url(v)}" }.join('&')
+      else
+        URI.escape(val.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      end
+    end
+
+    def association(options={}) # :nodoc:
+      s = options[:resource].dup
+
+      if options.include? :fields
+        s << "(#{[options[:fields]].flatten.join(',')})"
+      end
+
+      if options.include?(:limit) || options.include?(:offset)
+        s << ":#{options.fetch(:limit, 25)}:#{options.fetch(:offset, 0)}"
+      end
+
+      s
+    end
+
+    def endpoint_url(options = {}) # :nodoc:
+      url = "#{base_path}#{@resource_path}"
+      url += "?#{query}" if options.fetch(:include_query, true)
+      url
+    end
+
+    def multipart?
+      !!@multipart_request
+    end
+
+    private
+
+    def secure_client
+      SecureClient.new(:access_token => @token, :access_secret => @secret)
+    end
+
+    def basic_client
+      BasicClient.new
+    end
+
+    def secure?
+      !@token.nil? && !@secret.nil?
+    end
+
+  end
+end

data/lib/etsy/response.rb

@@ -0,0 +1,128 @@
+module Etsy
+
+  class OAuthTokenRevoked < StandardError; end
+  class MissingShopID < StandardError; end
+  class TemporaryIssue < StandardError; end
+  class ResourceUnavailable < TemporaryIssue; end
+  class ExceededRateLimit < TemporaryIssue; end
+  class InvalidUserID < StandardError; end
+  class EtsyJSONInvalid < StandardError
+    attr_reader :code, :data
+    def initialize(args)
+      @code = args[:code]
+      @data = args[:data]
+    end  
+  end
+
+
+  # = Response
+  #
+  # Basic wrapper around the Etsy JSON response data
+  #
+  class Response
+
+    # Create a new response based on the raw HTTP response
+    def initialize(raw_response)
+      @raw_response = raw_response
+    end
+
+    # Convert the raw JSON data to a hash
+    def to_hash
+      validate!
+      @hash ||= json
+    end
+
+    def body
+      @raw_response.body
+    end
+
+    def code
+      @raw_response.code
+    end
+
+    # Number of records in the response results
+    def count
+      if paginated?
+        to_hash['results'].nil? ? 0 : to_hash['results'].size
+      else
+        to_hash['count']
+      end
+    end
+
+    # Results of the API request
+    def result
+      if success?
+        results = to_hash['results'] || []
+        count == 1 ? results.first : results
+      else
+        Etsy.silent_errors ? [] : validate!
+      end
+    end
+    
+    # Total number of results of the request
+    def total
+      @total ||= to_hash['count']
+    end
+
+    def success?
+      !!(code =~ /2\d\d/)
+    end
+
+    def paginated?
+      !!to_hash['pagination']
+    end
+
+    private
+
+    def data
+      @raw_response.body
+    end
+
+    def json
+      @hash ||= JSON.parse(data)
+    end
+
+    def validate!
+      raise OAuthTokenRevoked         if token_revoked?
+      raise MissingShopID             if missing_shop_id?
+      raise InvalidUserID             if invalid_user_id?
+      raise TemporaryIssue            if temporary_etsy_issue?
+      raise ResourceUnavailable       if resource_unavailable?
+      raise ExceededRateLimit         if exceeded_rate_limit?
+      raise EtsyJSONInvalid.new({:code => code, :data => data}) unless valid_json?
+      true
+    end
+
+    def valid_json?
+      json
+      return true
+    rescue JSON::ParserError
+      return false
+    end
+
+    def token_revoked?
+      data == "oauth_problem=token_revoked"
+    end
+
+    def missing_shop_id?
+      data =~ /Shop with PK shop_id/
+    end
+
+    def invalid_user_id?
+      data =~ /is not a valid user_id/
+    end
+
+    def temporary_etsy_issue?
+      data =~ /Temporary Etsy issue/
+    end
+
+    def resource_unavailable?
+      data =~ /Resource temporarily unavailable/
+    end
+
+    def exceeded_rate_limit?
+      data =~ /You have exceeded/
+    end
+
+  end
+end

data/lib/etsy/section.rb

@@ -0,0 +1,16 @@
+module Etsy
+  class Section
+    include Etsy::Model
+
+    attributes :title, :rank, :user_id, :active_listing_count
+    attribute :id, :from => :shop_section_id
+
+    def self.find_by_shop(shop)
+      get("/shops/#{shop.id}/sections")
+    end
+
+    def self.find(shop, id)
+      get("/shops/#{shop.id}/sections/#{id}")
+    end
+  end
+end

data/lib/etsy/secure_client.rb

@@ -0,0 +1,131 @@
+module Etsy
+
+  # = SecureClient
+  #
+  # Used for generating tokens and calling API methods that require authentication.
+  #
+  class SecureClient
+
+    # Create a new client with the necessary parameters.  Accepts the following
+    # key/value pairs:
+    #
+    #   :request_token
+    #   :request_secret
+    #   :access_token
+    #   :access_secret
+    #
+    # The request token / secret is useful for generating the access token.  Pass
+    # the access token / secret when initializing from stored credentials.
+    #
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+
+    def consumer # :nodoc:
+      path = '/v2/oauth/'
+      @consumer ||= OAuth::Consumer.new(Etsy.api_key, Etsy.api_secret, {
+        :site               => "#{Etsy.protocol}://#{Etsy.host}",
+        :request_token_path => "#{path}request_token?scope=#{Etsy.permission_scopes.join('+')}",
+        :access_token_path  => "#{path}access_token"
+      })
+    end
+
+    # Generate a request token.
+    #
+    def request_token
+      consumer.get_request_token(:oauth_callback => Etsy.callback_url)
+    end
+
+    # Access token for this request, either generated from the request token or taken
+    # from the :access_token parameter.
+    #
+    def access_token
+      @attributes[:access_token] || client.token
+    end
+
+    # Access secret for this request, either generated from the request token or taken
+    # from the :access_secret parameter.
+    #
+    def access_secret
+      @attributes[:access_secret] || client.secret
+    end
+
+    def client_from_request_data # :nodoc:
+      request_token = OAuth::RequestToken.new(consumer, @attributes[:request_token], @attributes[:request_secret])
+      request_token.get_access_token(:oauth_verifier => @attributes[:verifier])
+    end
+
+    def client_from_access_data # :nodoc:
+      OAuth::AccessToken.new(consumer, @attributes[:access_token], @attributes[:access_secret])
+    end
+
+    def client # :nodoc:
+      @client ||= has_access_data? ? client_from_access_data : client_from_request_data
+    end
+
+    # Fetch a raw response from the specified endpoint.
+    #
+    def get(endpoint)
+      client.get(endpoint)
+    end
+
+    def post(endpoint)
+      client.post(endpoint)
+    end
+
+    def put(endpoint)
+      client.put(endpoint)
+    end
+    
+    def delete(endpoint)
+      client.delete(endpoint)
+    end
+
+    def post_multipart(endpoint, params = {})      
+      client = Net::HTTP.new(Etsy.host, Etsy.protocol == "http" ? 80 : 443)
+      client.use_ssl = true if Etsy.protocol == "https"
+      
+      client.start do |http|
+        req = Net::HTTP::Post.new(endpoint)
+        add_multipart_data(req, params)
+        add_oauth(req)
+        res = http.request(req)
+      end
+    end
+
+    private
+
+    # Encodes the request as multipart
+    def add_multipart_data(req, params)
+      crlf = "\r\n"
+      boundary = Time.now.to_i.to_s(16)
+      req["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+      body = ""
+      params.each do |key,value|
+        esc_key = CGI.escape(key.to_s)
+        body << "--#{boundary}#{crlf}"
+        if value.respond_to?(:read)
+          body << "Content-Disposition: form-data; name=\"#{esc_key}\"; filename=\"#{File.basename(value.path)}\"#{crlf}"
+          body << "Content-Type: image/jpeg#{crlf*2}"
+          body << open(value.path, "rb") {|io| io.read}
+        else
+          body << "Content-Disposition: form-data; name=\"#{esc_key}\"#{crlf*2}#{value}"
+        end
+        body << crlf
+      end
+      body << "--#{boundary}--#{crlf*2}"
+      req.body = body
+      req["Content-Length"] = req.body.size
+    end
+
+    # Uses the OAuth gem to add the signed Authorization header
+    def add_oauth(req)
+      client.sign!(req)
+    end
+
+    def has_access_data?
+      !@attributes[:access_token].nil? && !@attributes[:access_secret].nil?
+    end
+
+  end
+end