dawanda_client 0.1.6

data/lib/dawanda/model.rb

@@ -0,0 +1,79 @@
+module Dawanda
+  module Model # :nodoc:all
+    
+    module ClassMethods
+      
+      def attribute(name, options = {})
+        from = parse_from(name,options)
+        if from.is_a? Array
+          class_eval <<-CODE
+            def #{name}
+              @result['#{from.first}']['#{from.last}']
+            end
+          CODE
+        else
+          class_eval <<-CODE
+            def #{name}
+              @result['#{from}']
+            end
+          CODE
+        end
+      end
+      
+      def parse_from(name,options)
+        from = options.fetch(:from,name)
+        return from unless from.is_a? Hash
+        key = from.keys.first
+        value = from.fetch(key)
+        [key,value]
+      end
+      
+      def attributes(*names)
+        names.each {|name| attribute(name) }
+      end
+
+      def finder(type, endpoint)
+        parameter = endpoint.scan(/:\w+/).first
+        parameter.sub!(/^:/, '')
+
+        endpoint.sub!(":#{parameter}", '#{' + parameter + '}')
+
+        send("find_#{type}", parameter, endpoint)
+      end
+      
+      def find_all(parameter, endpoint)
+        class_eval <<-CODE
+          def self.find_all_by_#{parameter}(#{parameter}, params = {})
+            response = Request.get("#{endpoint}", params)
+            response.result.map {|listing| new(listing) }
+          end
+        CODE
+      end
+      
+      def find_one(parameter, endpoint)
+        class_eval <<-CODE
+          def self.find_by_#{parameter}(#{parameter}, params = {})
+            response = Request.get("#{endpoint}", params)
+            new response.result
+          end
+        CODE
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      def initialize(result = nil)
+        @result = result
+      end
+      
+    end
+    
+    def self.included(other)
+      other.send(:extend, Dawanda::Model::ClassMethods)
+      other.send(:include, Dawanda::Model::InstanceMethods)
+    end
+    
+    
+  end
+end

data/lib/dawanda/product.rb

@@ -0,0 +1,80 @@
+module Dawanda
+  
+  # = Product
+  #
+  # Represents a single Dawanda product.  Has the following attributes:
+  
+  #
+  # [id] The unique identifier for this product
+  # [name] The title of this product
+  # [description] This product's full description
+  # [view_count] The number of times this product has been viewed
+  # [product_url] The full URL to this product's detail page
+  # [price] The price of this product item
+  # [quantity] The number of items available for sale
+  # [tags] An array of tags that the seller has used for this product
+  # [materials] Any array of materials that was used in the production of this item
+  #
+  class Product
+    
+    include Dawanda::Model
+    
+    finder :all, '/shops/:shop_id/products'
+    finder :all, '/categories/:category_id/products'
+    finder :all, '/shop_categories/:shop_category_id/products'
+    finder :all, '/colors/:hex/products'
+    finder :all, '/colors/:hex_search/products/search'
+    finder :all, '/product/:method'
+    
+    
+    
+    finder :one, '/products/:id'
+    
+    attribute :created, :from => :created_at
+    attribute :category_id, :from => {:category => :id }
+    attribute :user_id, :from => {:user => :id }
+    
+    attributes :id, :name, :description, :created_at, :view_count, :tags,
+               :ending, :quantity, :materials, :price, :restful_path, :product_url, :images
+
+ 
+    # Time that this product was created
+    #
+    def created_at
+      Time.parse(created)
+    end
+    
+    # Time that this product is ending (will be removed from store)
+    #
+    def ending_at
+      Time.parse(ending)
+    end
+    
+    # Search for users with given keyword
+    def self.search(keyword, params = {})
+      params.update(:keyword => keyword)
+      self.find_all_by_method('search', params)
+    end
+    
+    # Search for users with given keyword and color
+    def self.search_by_color(color, keyword, params = {})
+      params.update(:keyword => keyword)
+      self.find_all_by_hex_search(color, params)
+    end
+    
+    # The primary image for this product.  See Dawanda::Image for more
+    # information
+    #
+    def image_25x25
+      images.first['image_25x25']
+    end
+    
+    def category(params = {})
+      Category.find_by_id(category_id)
+    end
+    
+    def shop(params = {})
+      Shop.find_by_user_id(user_id)
+    end
+  end
+end

data/lib/dawanda/request.rb

@@ -0,0 +1,56 @@
+module Dawanda
+  
+  # = Request
+  # 
+  # A basic wrapper around GET requests to the Dawanda JSON API
+  #
+  class Request
+    
+    # The base URL for API requests
+    def self.base_url
+      url = "http://#{Dawanda.country}.dawanda.com/api/v1"
+    end
+    
+    # Perform a GET request for the resource with optional parameters - returns
+    # A Response object with the payload data
+    # 
+    def self.get(resource_path, parameters = {})
+      parameters = {:format => 'json'}.update(parameters)
+      request = Request.new(resource_path, parameters)
+      Response.new(request.get)
+    end
+    
+    # Create a new request for the resource with optional parameters
+    def initialize(resource_path, parameters = {})
+      @resource_path = resource_path
+      @parameters    = parameters
+    end
+
+    # Perform a GET request against the API endpoint and return the raw
+    # response data
+    def get
+      response = Net::HTTP.get_response(endpoint_uri)
+      case response
+      when Net::HTTPSuccess, Net::HTTPRedirection
+        return response.body
+      else 
+        raise response.body
+      end
+    end
+    
+    def parameters # :nodoc:
+      @parameters.merge(:api_key => Dawanda.api_key)
+    end
+    
+    def query # :nodoc:
+      parameters.map {|k,v| "#{k}=#{v}"}.join('&')
+    end
+    
+    def endpoint_uri # :nodoc:
+      uri = URI.parse("#{self.class.base_url}#{@resource_path}")
+      uri.query = query
+      uri
+    end
+    
+  end
+end

data/lib/dawanda/response.rb

@@ -0,0 +1,47 @@
+module Dawanda
+  
+  # = Response
+  # 
+  # Basic wrapper around the Dawanda JSON response data
+  #
+  class Response
+    
+    # Create a new response based on the raw JSON
+    def initialize(data)
+      @data = data
+    end
+    
+    # Convert the raw JSON data to a hash
+    def to_hash
+      @hash ||= JSON.parse(@data)
+      @hash['response']
+    end
+    
+    # Number of records in the response
+    def entries
+      to_hash['entries']
+    end
+    
+    # Number of pages in the response
+    def pages
+      to_hash['pages']
+    end
+    
+    def type
+      to_hash['type']
+    end
+    
+    def pluralized_type
+      type.to_s.pluralize
+    end
+    
+    def params
+      to_hash['params']
+    end
+    # Results of the API request
+    def result
+      entries == 1 ? to_hash['result'][type] : to_hash['result'].values.first
+    end
+    
+  end
+end

data/lib/dawanda/shop.rb

@@ -0,0 +1,64 @@
+module Dawanda
+  
+  # = Shop
+  #
+  # Represents a single Dawanda shop.  Users may or may not have an associated shop - 
+  # check the result of User#seller? to find out.
+  #
+  # A shop has the following attributes:
+  #
+  # [name] The shop's name
+  # [created_at] An announcement to buyers (displays on the shop's home page)
+  # [updated_at] The message sent to users who buy from this shop
+  # [banner_image_url] The full URL to the shops's banner image
+  #
+  class Shop
+    
+    include Dawanda::Model
+
+    finder :one, '/shops/:user_id'
+    finder :all, '/shops/:method'
+    
+    attribute :updated,           :from => :updated_at
+    attribute :created,           :from => :created_at
+    attribute :user_id,           :from => { :user => :id }
+    attribute :banner_image_url,  :from => { :images => :banner }
+
+    attributes :name
+   
+    # Time that this shop was created
+    #
+    def created_at
+      Time.parse(created)
+    end
+    
+    # Time that this shop was last updated
+    #
+    def updated_at
+      Time.parse(updated)
+    end
+    
+    # Search for shops with given keyword
+    def self.search(keyword, params = {})
+      params.update(:keyword => keyword)
+      self.find_all_by_method('search', params)
+    end
+    
+    # A collection of products in this user's shop. See Dawanda::Product for
+    # more information
+    #
+    def products(params = {})
+      @products ||= Product.find_all_by_shop_id(user_id.to_s, params)
+    end
+    
+    # The user who runs this shop. See Dawanda::User for more information
+    def user(params = {})
+      @user ||= User.find_by_user_id(user_id, params)
+    end
+    
+    # All shop categories in this shop. See Dawanda::ShopCategory for more information
+    def shop_categories(params = {})
+      @shop_categories ||= ShopCategory.find_all_by_shop_id(user_id.to_s, params)
+    end
+  end
+end

data/lib/dawanda/shop_category.rb

@@ -0,0 +1,28 @@
+module Dawanda
+  
+  # = ShopCategory
+  #
+  # Represents a single Dawanda::ShopCategory - has the following attributes:
+  #
+  # [id] The unique identifier for this shop category
+  # [name] This shop category's name 
+  # [product_count] The amount of products in this shop category
+  # [restful_path] The path to the shop category
+  #
+  class ShopCategory
+    
+    include Dawanda::Model
+    
+    finder :all, '/shops/:shop_id/shop_categories'
+    finder :one, '/shop_categories/:id'
+    
+    attributes :id, :name, :position, :restful_path, :product_count
+    
+    
+    # All products in this shop category. See Dawanda::Product for more information
+    def products(params = {})
+      Product.find_all_by_shop_category_id(id, params)
+    end
+    
+  end
+end

data/lib/dawanda/user.rb

@@ -0,0 +1,60 @@
+module Dawanda
+  
+  # = User
+  #
+  # Represents a single Dawanda user - has the following attributes:
+  #
+  # [id] The unique identifier for this user
+  # [name] This user's username
+  # [city] The user's city / state (optional)
+  # [sex] The user's gender
+  # [transaction_sold_count] How many products have been sold by this user
+  # [is_seller] Is this user a seller?
+  # [bio] User's biography
+  # [restful_path]
+  # [url] The full URL to this user's profile page / shop (if seller)
+  #
+  class User
+    
+    include Dawanda::Model
+    
+    finder :one, '/users/:user_id'
+    finder :all, '/users/:method'
+    
+    # attribute :last_login, :from => :last_login_epoch
+
+    attributes :id, :name, :url, :city, :sex, :bio, :transaction_sold_count, :is_seller, :images
+    
+    # This user's shop, returns nil if user is not a seller. See Dawanda::Shop
+    # for more information.
+    #
+    def shop(params = {})
+      @shop ||= Shop.find_by_user_id(id, params) if seller?
+    end
+
+    # Search for users with given keyword
+    def self.search(keyword, params = {})
+      params.update(:keyword => keyword)
+      self.find_all_by_method('search', params)
+    end
+    
+    # Is this user a seller?
+    #
+    def seller?
+      is_seller
+    end
+    
+    def image_40x40
+      images.first['image_40x40']
+    end
+    
+    def image_80x80
+      images.first['image_80x80']
+    end
+    
+    def image_170x
+      images.first['image_170x']
+    end
+    
+  end
+end

data/test/fixtures/getCategoryDetails.json

@@ -0,0 +1,21 @@
+{
+  "response":{
+    "type":"category",
+    "pages":1,
+    "entries":1,
+    "result":{
+      "category":{
+        "name":"1003",
+        "product_count":754,
+        "id":418,
+        "parent_id":406,
+        "restful_path":"\/categories\/418"
+      }
+    },
+    "params":{
+      "format":"json",
+      "api_key":"foobar",
+      "id":"418"
+    }
+  }
+}