ecwid_api 0.0.2 → 0.2.3

data/lib/ecwid_api/order_item.rb

@@ -0,0 +1,17 @@
+module EcwidApi
+  class OrderItem < Entity
+    ecwid_reader :id, :productId, :categoryId, :price, :productPrice, :weight,
+                 :sku, :quantity, :shortDescription, :tax, :shipping,
+                 :quantityInStock, :name, :tangible, :trackQuantity,
+                 :fixedShippingRateOnly, :imageId, :fixedShippingRate,
+                 :digital, :productAvailable, :couponApplied, :selectedOptions,
+                 :taxes, :files
+
+    # Public: Returns the default `Category` that the product belongs to
+    def category
+      client.categories.find(data["categoryId"])
+    end
+
+    # TODO: get the product
+  end
+end

data/lib/ecwid_api/paged_ecwid_response.rb

@@ -0,0 +1,57 @@
+require_relative 'paged_enumerator'
+
+# Public: Presents a paged Ecwid response as an Enumerator with a
+# PagedEnumerator
+#
+# Example
+#
+#   response = PagedEcwidResponse.new(client, "products", priceFrom: 10) do |product_hash|
+#     Product.new(product_hash, click: client)
+#   end
+#
+#   response.each do |product|
+#     # do stuff the the product
+#   end
+#
+module EcwidApi
+  class PagedEcwidResponse
+    include Enumerable
+    extend  Forwardable
+
+    def_delegator :@paged_enumerator, :each
+
+    # Public: Initialize a new PagedEcwidResponse
+    #
+    # client - an EcwidApi::Client
+    # path   - a String that is the path to retrieve from the client
+    # params - a Hash of parameters to pass along with the request
+    # &block - a Block that processes each item returned in the Response
+    #
+    def initialize(client, path, params = {}, &block)
+      params[:limit] = 100
+      params.delete(:offset)
+
+      block ||= proc { |item| item }
+
+      response = client.get(path, params)
+
+      @paged_enumerator = PagedEnumerator.new(response) do |enum_response, yielder|
+        count, offset, total = %w[count offset total].map do |i|
+          enum_response.body[i].to_i
+        end
+
+        if count > 0
+          enum_response.body['items'].each do |item|
+            yielder << block.call(item)
+          end
+        end
+
+        if count.zero? || count + offset >= total
+          false
+        else
+          client.get(path, params.merge(offset: offset + count))
+        end
+      end
+    end
+  end
+end

data/lib/ecwid_api/paged_enumerator.rb

@@ -0,0 +1,66 @@
+module EcwidApi
+  # Public: Abstracts pagination into an Enumerator so all of the objects for
+  # a given response can be retreived without having to know that they were
+  # split into pages from the server
+  #
+  # Examples
+  #
+  #   client.get("orders", limit: 10)
+  #
+  #   paged = PagedEnumerator.new(orders) do |response, yielder|
+  #     response.body["orders"].each do |obj|
+  #       yielder << obj
+  #     end
+  #
+  #     next_url = response.body["nextUrl"]
+  #     next_url ? client.get(next_url) : false
+  #   end
+  #
+  #   paged.each do |item|
+  #     puts item.inspect
+  #   end
+  #
+  class PagedEnumerator
+    include Enumerable
+
+    # Private: A response that we are evaluating
+    attr_reader :response
+    private     :response
+
+    # Private: Gets the next response
+    attr_reader :next_block
+    private     :next_block
+
+    # Public: Initializes a new PagedEnumerator
+    #
+    # response   - the response that contains a collection of objects
+    # next_block - The block will receive the response and a yielder Proc.
+    #              The block should use `yielder << item` to yield all of
+    #              the items in the collection.
+    #
+    #              Then the block should return the next response. If no
+    #              response is given (eg: the last page), the block should
+    #              return a falsey value.
+    #
+    def initialize(response, &next_block)
+      @response, @next_block = response, next_block
+    end
+
+    # Public: Iterates over each "page" yielding each "item" in every collection
+    def each(&block)
+      unless @next_enumerator
+        @yielder ||= []
+        @next_response ||= next_block.call(response, @yielder)
+
+        if @next_response
+          @next_enumerator ||= PagedEnumerator.new(@next_response, &@next_block)
+        else
+          @next_enumerator = []
+        end
+      end
+
+      @yielder.each(&block)
+      @next_enumerator.each(&block)
+    end
+  end
+end

data/lib/ecwid_api/person.rb

@@ -0,0 +1,7 @@
+module EcwidApi
+  class Person < Entity
+    ecwid_reader :name, :companyName, :street, :city, :countryCode,
+                 :countryName, :postalCode, :stateOrProvinceCode,
+                 :stateOrProvinceName, :phone
+  end
+end

data/lib/ecwid_api/product.rb

@@ -0,0 +1,65 @@
+module EcwidApi
+	class Product < Entity
+    self.url_root = "products"
+
+    ecwid_reader :id, :sku, :quantity, :unlimited, :inStock, :name, :price,
+                 :priceInProductList, :wholesalePrices, :compareToPrice,
+                 :weight, :url, :created, :updated, :productClassId,
+                 :enabled, :options, :warningLimit, :fixedShippingRateOnly,
+                 :fixedShippingRate, :defaultCombinationId, :thumbnailUrl,
+                 :imageUrl, :smallThumbnailUrl, :originalImageUrl, :description,
+                 :galleryImages, :categoryIds, :defaultCategoryId, :favorites,
+                 :attributes, :files, :relatedProducts, :combinations
+
+    ecwid_writer :sku, :name, :quantity, :price, :wholesalePrices,
+                 :compareToPrice, :weight, :productClassId, :enabled, :options,
+                 :warningLimit, :fixedShippingRateOnly, :fixedShippingRate,
+                 :description, :categoryIds, :defaultCategoryId, :attributes,
+                 :relatedProducts
+
+    # Public: Uploads a primary image for a Product
+    #
+    # filename - a String that is either a local file name or URL
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns a Faraday::Response object
+    def upload_image!(filename)
+      client.post_image("#{url}/image", filename)
+    end
+
+    # Public: Uploads gallery images for a Product
+    #
+    # *filenames - Strings that are either a local file name or URL
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns an Array of Faraday::Response object
+    def upload_gallery_images!(*filenames)
+      filenames.map do |filename|
+        client.post_image("#{url}/gallery", filename)
+      end
+    end
+
+    # Public: Deletes all of the gallery images for a Product
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns a Faraday::Response object
+    def delete_gallery_images!
+      client.delete("#{url}/gallery")
+    end
+
+    def combinations
+      @combinations ||= Api::ProductCombinations.new(self, client)
+    end
+
+    def created
+      @created ||= Time.parse(super)
+    end
+
+    def updated
+      @updated ||= Time.parse(super)
+    end
+	end
+end

data/lib/ecwid_api/product_combination.rb

@@ -0,0 +1,30 @@
+module EcwidApi
+  class ProductCombination < Entity
+    attr_reader :product
+
+    self.url_root = -> { "products/#{product.id}/combinations" }
+
+    ecwid_reader :id, :combinationNumber, :options, :sku, :smallThumbnailUrl,
+                 :thumbnailUrl, :imageUrl, :originalImageUrl, :quantity,
+                 :unlimited, :price, :wholesalePrices, :weight, :warningLimit
+
+    ecwid_writer :options, :sku, :quantity, :unlimited, :price,
+                 :wholesalePrices, :weight, :warningLimit, :inventoryDelta
+
+    def initialize(data, opts={})
+      super(data, opts)
+      @product = opts[:product]
+    end
+
+    # Public: Uploads a primary image for a ProductCombination
+    #
+    # filename - a String that is either a local file name or URL
+    #
+    # Raises ResponseError if the API returns an error
+    #
+    # Returns a Faraday::Response object
+    def upload_image!(filename)
+      client.post_image("#{url}/image", filename)
+    end
+  end
+end

data/lib/ecwid_api/product_type.rb

@@ -0,0 +1,18 @@
+module EcwidApi
+  class ProductType < Entity
+
+     self.url_root = "classes"
+
+     ecwid_reader :id, :name, :googleTaxonomy, :attributes
+
+     ecwid_writer :name, :attributes
+
+
+     # Public: Returns a Array of `ProductTypeAttribute` objects
+    def attributes
+      @attributes ||= data["attributes"].map { |attribute| ProductTypeAttribute.new(attribute) }
+    end
+
+
+   end
+end

data/lib/ecwid_api/product_type_attribute.rb

@@ -0,0 +1,27 @@
+module EcwidApi
+  class ProductTypeAttribute < Entity
+
+    ecwid_reader :id, :name, :type, :show
+
+    VALID_TYPES = %w(CUSTOM UPC BRAND GENDER AGE_GROUP COLOR SIZE PRICE_PER_UNIT UNITS_IN_PRODUCT)
+    VALID_SHOWS = %w(NOTSHOW DESCR PRICE)
+
+
+    def type=(type_type)
+      type_type = type_type.to_s.upcase
+      unless VALID_TYPES.include?(type_type)
+        raise ::StandardError.new("#{type_type} is an invalid 'type'")
+      end
+      super(type_type)
+    end
+
+
+     def show=(show_type)
+      show_type = show_type.to_s.upcase
+      unless VALID_SHOWS.include?(show_type)
+        raise ::StandardError.new("#{show_type} is an invalid 'show'")
+      end
+      super(show_type)
+    end
+  end
+end

data/lib/ecwid_api/unpaged_ecwid_response.rb

@@ -0,0 +1,38 @@
+
+ # Public: Presents an Ecwid response as an Array
+#
+# Example
+#
+#   response = UnpagedEcwidResponse.new(client, "products", priceFrom: 10) do |product_hash|
+#     Product.new(product_hash, click: client)
+#   end
+#
+#   response.each do |product|
+#     # do stuff the the product
+#   end
+#
+module EcwidApi
+  class UnpagedEcwidResponse
+    include Enumerable
+    extend  Forwardable
+
+     def_delegators :@records, *Enumerable.instance_methods
+
+     # Public: Initialize a new UnpagedEcwidResponse
+    #
+    # client - an EcwidApi::Client
+    # path   - a String that is the path to retrieve from the client
+    # params - a Hash of parameters to pass along with the request
+    # &block - a Block that processes each item returned in the Response
+    #
+    def initialize(client, path, params = {}, &block)
+      block ||= Proc.new { |item| item }
+      @records = []
+
+       response = client.get(path, params)
+      response.body.each do |item|
+        @records << block.call(item)
+      end
+    end
+  end
+end

data/lib/ecwid_api/version.rb

@@ -1,3 +1,3 @@
 module EcwidApi
-  VERSION = "0.0.2"
+  VERSION = "0.2.3"
 end

data/lib/ext/string.rb

@@ -1,5 +1,13 @@
 class String
   def camel_case
     split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
-  end
+  end unless method_defined?(:camel_case)
+
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end unless method_defined?(:underscore)
 end

data/spec/api/categories_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe EcwidApi::Api::Categories, faraday: true do
+  subject { client.categories }
+
+  describe "#all" do
+    it "gets all of the categories from the client" do
+      expect(client).to receive(:get).with("categories", hash_including({})).and_call_original
+      subject.all
+    end
+
+    it "gets sub categories" do
+      expect(client).to receive(:get).with("categories", hash_including(parent: 5)).and_call_original
+      subject.all(parent: 5)
+    end
+  end
+
+  describe "#root" do
+    it "gets the root level categories" do
+      expect(subject).to receive(:all).with(hash_including(parent: 0)).and_call_original
+      subject.root
+    end
+  end
+
+  describe "#find" do
+    it "finds a single category" do
+      expect(client).to receive(:get).with("categories/#{5}").and_call_original
+      subject.find(5)
+    end
+  end
+end

data/spec/api/customers_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+ describe EcwidApi::Api::Customers, faraday: true do
+  subject { client.customers }
+
+   describe "#all" do
+    it "passes any other parameters through" do
+      expect(client).to receive(:get).with("customers", hash_including(from_date: '1982-05-17'))
+      subject.all(from_date: '1982-05-17')
+    end
+
+     it "gets the proper response count (see fixture)" do
+      expect(subject.all.count).to eq 5
+    end
+
+     it "gets the proper customer (see fixture)" do
+      expect(subject.all.first.name).to eq "Abe Doe"
+    end
+  end
+end

data/spec/api/orders_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe EcwidApi::Api::Orders, faraday: true do
+  subject { client.orders }
+
+  describe "#all" do
+    it "passes the parameters to the client" do
+      expect(client).to receive(:get).with("orders", hash_including(from_date: '1982-05-17'))
+      subject.all(from_date: '1982-05-17')
+    end
+
+    it "gets the proper response (see fixtures)" do
+      expect(subject.all.count).to be 2
+    end
+
+    it "gets EcwidApi::Order types" do
+      expect(subject.all.all? { |order| order.is_a?(EcwidApi::Order) }).to be(true)
+    end
+  end
+
+  describe "#find" do
+    it "is an `EcwidApi::Order`" do
+      expect(subject.find(35)).to be_a(EcwidApi::Order)
+    end
+
+    it "is nil when not found" do
+      expect(subject.find(404)).to be_nil
+    end
+  end
+end

data/spec/api/product_types_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+ describe EcwidApi::Api::ProductTypes, faraday: true do
+  subject { client.product_types }
+
+   describe "#all" do
+    it "returns an array" do
+      expect(client).to receive(:get).with("classes", {}).and_call_original
+      subject.all
+    end
+
+     it "gets the proper response count (see fixture)" do
+      expect(subject.all.count).to eq 2
+    end
+
+     it "gets the proper product_type (see fixture)" do
+      expect(subject.all.first.name).to eq "Foo"
+    end
+  end
+end