ecwid_api 0.0.2 → 0.2.3

data/lib/ecwid_api/api/orders.rb

@@ -0,0 +1,36 @@
+require_relative "../paged_ecwid_response"
+
+module EcwidApi
+  module Api
+    # Public: This is the Ecwid API for Orders. It abstracts the end-points
+    # of the Ecwid API that deal with orders.
+    class Orders < Base
+      # Public: Gets Orders from the Ecwid API
+      #
+      # params - optional parameters that can be used to filter the request.
+      #          For a list of params, please refer to the API documentation:
+      #          http://kb.ecwid.com/w/page/43697230/Order%20API
+      #          Note that the limit and offset parameters will be overridden
+      #          since all orders will be returned and enumerated
+      #
+      # Returns a PagedEnumerator of `EcwidApi::Order` objects
+      def all(params = {})
+        PagedEcwidResponse.new(client, "orders", params) do |order_hash|
+          Order.new(order_hash, client: client)
+        end
+      end
+
+      # Public: Finds a an Order given an Ecwid id
+      #
+      # id - an Integer that is the Ecwid Order number
+      #
+      # Returns an EcwidApi::Order if found, nil if not
+      def find(id)
+        response = client.get("orders/#{id}")
+        if response.success?
+          Order.new(response.body, client: client)
+        end
+      end
+    end
+  end
+end

data/lib/ecwid_api/api/product_combinations.rb

@@ -0,0 +1,48 @@
+module EcwidApi
+  module Api
+    class ProductCombinations < Base
+      include Api
+      include Enumerable
+
+      attr_reader :product
+
+      def initialize(product, client)
+        @product = product
+        super(client)
+      end
+
+      def all
+        response = client.get("products/#{product.id}/combinations")
+
+        if response.success?
+          response.body.map do |data|
+            ProductCombination.new(data, client: client, product: product)
+          end
+        end
+      end
+
+      def each(&block)
+        all = self.all || []
+
+        all.each(&block)
+      end
+
+      def find(id)
+        response = client.get("products/#{product.id}/combinations/#{id}")
+
+        if response.success?
+          ProductCombination.new(response.body, product: product, client: client)
+        end
+      end
+
+      def create(params)
+        response = client.post("products/#{product.id}/combinations", params)
+        find(response.body["id"])
+      end
+
+      def delete_all!
+        client.delete("products/#{product.id}/combinations")
+      end
+    end
+  end
+end

data/lib/ecwid_api/api/product_types.rb

@@ -0,0 +1,56 @@
+require_relative "../unpaged_ecwid_response"
+
+ module EcwidApi
+  module Api
+    class ProductTypes < Base
+      # Public: Get all of the ProductType objects for the Ecwid store
+      #
+      # Returns an Array of ProductType objects
+      # NOTE: This endpoint does not behave like other Ecwid endpoints in that
+      #       it does not return paged results.  It simply returns every
+      #       result in an array, without a wrapper with an "items" property.
+      def all(params = {})
+        UnpagedEcwidResponse.new(client, "classes") do |product_type_hash|
+          ProductType.new(product_type_hash, client: client)
+        end
+      end
+
+       # Public: Finds a single product_type by product_type ID
+      #
+      # id - an Ecwid product_type ID
+      #
+      # Returns a ProductType object, or nil if one can't be found
+      def find(id)
+        response = client.get("classes/#{id}")
+        if response.success?
+          ProductType.new(response.body, client: client)
+        end
+      end
+
+       # Public: Creates a new ProductType
+      #
+      # params - a Hash
+      #
+      # Raises an Error if there is a problem
+      #
+      # Returns a ProductType object
+      def create(params)
+        response = client.post("classes", params)
+        find(response.body["id"])
+      end
+
+       # Public: Updates an existing ProductType
+      #
+      # id - the Ecwid product_type ID
+      # params - a Hash
+      #
+      # Raises an Error if there is a problem
+      #
+      # Returns a ProductType object
+      def update(id, params)
+        client.put("classes/#{id}", params)
+        find(id)
+      end
+    end
+  end
+end

data/lib/ecwid_api/api/products.rb

@@ -0,0 +1,148 @@
+require_relative "../paged_ecwid_response"
+
+module EcwidApi
+  module Api
+    class Products < Base
+      # Public: Get all of the Product objects for the Ecwid store
+      # params - a hash of request parameters. Parameters can be
+      #   keyword                     string            Search term. Use quotes to search for exact match. 
+      #                                                 Ecwid searches products over multiple fields:
+      #                                                   * title
+      #                                                   * description
+      #                                                   * SKU
+      #                                                   * product options
+      #                                                   * category name
+      #                                                   * gallery image descriptions
+      #                                                   * attribute values (except for hidden attributes). 
+      #                                                     If your keywords contain special characters, 
+      #                                                     it may make sense to URL encode them before making a request
+      #   priceFrom                   number            Minimum product price
+      #   priceTo                     number            Maximum product price
+      #   category                    number            Category ID. To get Store Front Page products, specify `&category=0` in the request
+      #   withSubcategories           boolean           `true/false`: defines whether Ecwid should search in subcategories of the 
+      #                                                 category you set in `category` field. Ignored if `category` field is not set.
+      #                                                 `false` is the default value
+      #   sortBy                      string            Sort order. Supported values:
+      #                                                   * `RELEVANCE` default
+      #                                                   * `DEFINED_BY_STORE_OWNER`
+      #                                                   * `ADDED_TIME_DESC`
+      #                                                   * `ADDED_TIME_ASC`
+      #                                                   * `NAME_ASC`
+      #                                                   * `NAME_DESC`
+      #                                                   * `PRICE_ASC`
+      #                                                   * `PRICE_DESC`
+      #                                                   * `UPDATED_TIME_ASC`
+      #                                                   * `UPDATED_TIME_DESC`
+      #                                                 . If request is applicable to a specific category (i.e. `category` is set), 
+      #                                                 then `DEFINED_BY_STORE_OWNER` sort method is used
+      #   offset                      number            Offset from the beginning of the returned items list (for paging)
+      #   limit                       number            Maximum number of returned items. Maximum allowed value: `100`. Default value: `100`
+      #   createdFrom                 string            Product creation date/time (lower bound). Supported formats:
+      #                                                   * UNIX timestamp
+      #                                                 Examples:
+      #                                                   * `1447804800`
+      #   createdTo                   string            Product creation date/time (upper bound). Supported formats:
+      #                                                   * UNIX timestamp
+      #   updatedFrom                 string            Product last update date/time (lower bound). Supported formats:
+      #                                                   * UNIX timestamp
+      #   updatedTo                   string            Product last update date/time (upper bound). Supported formats:
+      #                                                   * UNIX timestamp
+      #   enabled                     boolean           `true` to get only enabled products, `false` to get only disabled products
+      #   inStock                     boolean           `true` to get only products in stock, `false` to get out of stock products
+      #   sku                         string            Product or variation SKU. Ecwid will return details of a product containing that SKU, 
+      #                                                 if SKU value is an exact match. If SKU is specified, other search parameters are ignored, 
+      #                                                 except for product ID.
+      #   productId                   number            Internal Ecwid product ID or multiple productIds separated by a comma. If this field is 
+      #                                                 specified, other search parameters are ignored.
+      #   baseUrl                     string            Storefront URL for Ecwid to use when returning product URLs in the url field. 
+      #                                                 If not specified, Ecwid will use the storefront URL specified in the store settings
+      #   cleanUrls                   boolean           If `true`, Ecwid will return the SEO-friendly clean URL (without hash `'#'`) in the `url` field. 
+      #                                                 If `false`, Ecwid will return URL in the old format (with hash `'#'`). We recommend using 
+      #                                                 `true` value if merchant’s website supports clean SEO-friendly URL feature
+      #   onsale                      string            Use `"onsale"` to get on sale items only or `"notonsale"` for items not currently on sale.
+      #   option_{optionName}         string            Filter by product option values. Format: `option_{optionName}=param[,param]`, 
+      #                                                 where optionName is the attribute name and param is the attribute value. 
+      #                                                 You can place several values separated by comma. In that case, values will be connected 
+      #                                                 through logical “OR”, and if the product has at least one of them it will get to the 
+      #                                                 search results. Example:
+      #                                                   `option_Size=S,M,L&option_Color=Red,Black`
+      #   attribute_{attributeName}   string            Filter by product attribute values. Format: `attribute_{attributeName}=param[,param]`, 
+      #                                                 where attributeName is the attribute name and param is the attribute value. 
+      #                                                 You can place several values separated by comma. In that case, values will be connected 
+      #                                                 through logical “OR”, and if the product has at least one of them it will get to the 
+      #                                                 search results. Example:
+      #                                                   `attribute_Brand=Apple&attribute_Capacity=32GB,64GB`
+      #   lang                        string            Preferred language for the product fields in search results. 
+      #                                                 If a certain field does not have the translation available for the set language, 
+      #                                                 the default language text will be used for that field.
+      # Returns an Array of Product objects
+      def all(params = {})
+        PagedEcwidResponse.new(client, "products", params) do |product_hash|
+          Product.new(product_hash, client: client)
+        end
+      end
+
+      # Public: Finds a single product by product ID
+      #
+      # id - an Ecwid product ID
+      # params - a hash of request parameters. Parameters can be
+      #   baseUrl                     string            Storefront URL for Ecwid to use when returning product URLs in the url field. 
+      #                                                 If not specified, Ecwid will use the storefront URL specified in the 
+      #   cleanUrls                   boolean           If `true`, Ecwid will return the SEO-friendly clean URL (without hash '#') 
+      #                                                 in the url field. If `false`, Ecwid will return URL in the old format (with hash '#'). 
+      #                                                 We recommend using `true` value if merchant’s website supports clean
+      #   lang                        string            Preferred language for the product fields in search results. If a certain field does 
+      #                                                 not have the translation available for the set language, the default language text 
+      #                                                 will be used for that field.
+      # Returns a Product object, or nil if one can't be found
+      def find(id, params = {})
+        response = client.get("products/#{id}", params)
+        if response.success?
+          Product.new(response.body, client: client)
+        end
+      end
+
+      # Public: Finds a single Product by SKU
+      #
+      # sku - a SKU of a product
+      # params - a hash of request parameters. Parameters can be
+      #   baseUrl                     string            Storefront URL for Ecwid to use when returning product URLs in the url field. 
+      #                                                 If not specified, Ecwid will use the storefront URL specified in the 
+      #   cleanUrls                   boolean           If `true`, Ecwid will return the SEO-friendly clean URL (without hash '#') 
+      #                                                 in the url field. If `false`, Ecwid will return URL in the old format (with hash '#'). 
+      #                                                 We recommend using `true` value if merchant’s website supports clean
+      #   lang                        string            Preferred language for the product fields in search results. If a certain field does 
+      #                                                 not have the translation available for the set language, the default language text 
+      #                                                 will be used for that field.      
+      # Returns a Product object, or nil if one can't be found
+      def find_by_sku(sku, params = {})
+        all(params.merge(keyword: sku)).find { |product| product[:sku] == sku }
+      end
+
+      # Public: Creates a new Product
+      #
+      # params - a Hash
+      #
+      # Raises an Error if there is a problem
+      #
+      # Returns a Product object
+      def create(params)
+        response = client.post("products", params)
+        find(response.body["id"])
+      end
+
+      # Public: Updates an existing Product
+      #
+      # id - the Ecwid product ID
+      # params - a Hash
+      #
+      # Raises an Error if there is a problem
+      #
+      # Returns a Product object
+      def update(id, params)
+        client.put("products/#{id}", params)
+        find(id)
+      end
+    end
+  end
+end

data/lib/ecwid_api/category.rb

@@ -1,14 +1,63 @@
 module EcwidApi
   class Category < Entity
+    self.url_root = "categories"
+
+    ecwid_reader :id, :parentId, :orderBy, :thumbnailUrl, :originalImageUrl,
+                 :name, :url, :productCount, :description, :enabled, :productIds
+
+    ecwid_writer :name, :parentId, :orderBy, :description, :enabled, :productIds
+
     # Public: Returns an Array of sub categories for the Category
-    def sub_categories
-      @sub_categories ||= client.categories.all(id)
+    def sub_categories(params = {})
+      @sub_categories ||= client.categories.all(params.merge(parent: id))
+    end
+
+    # Public: Returns an Array of all of the sub categories (deep) for the
+    #         Category
+    def all_sub_categories(params = {})
+      @all_sub_categories ||= sub_categories(params) + sub_categories.flat_map do |sub|
+        sub.all_sub_categories(params)
+      end
     end
 
     # Public: Returns the parent EcwidApi::Category, or nil if there isn't one
     def parent
-      parent_id = data["parentId"]
-      client.categories.find(parent_id) if parent_id
+      @parent ||= begin
+        parent_id = data["parentId"]
+        client.categories.find(parent_id) if parent_id
+      end
+    end
+
+    def parents
+      if parent
+        parent.parents + [parent]
+      else
+        []
+      end
+    end
+
+    # Public: Returns the Products that belong to the Category
+    #
+    # params - a Hash of values that can be used for a Prdocut search
+    #
+    # Returns an Enumeration of Products
+    def products(params = {})
+      @products ||= product_ids.map do |product_id|
+        client.products.find(product_id)
+      end
+    end
+
+    def product_ids
+      super || []
+    end
+
+    # Public: Uploads an image for the Category
+    #
+    # filename - a String that is the path to a local file or a URL
+    #
+    # Returns a Faraday::Response object
+    def upload_image!(filename)
+      client.post_image("categories/#{id}/image", filename)
     end
   end
 end

data/lib/ecwid_api/client.rb

@@ -1,5 +1,4 @@
-require 'faraday'
-require 'faraday_middleware'
+require "open-uri"
 
 module EcwidApi
   # Public: Client objects manage the connection and interface to a single Ecwid
@@ -7,89 +6,97 @@ module EcwidApi
   #
   # Examples
   #
-  #   client = EcwidApi::Client.new do |config|
-  #     config.store_id = '12345'
-  #     config.url = 'http://app.ecwid.com/api/v1'
-  #     config.order_secret_key = 'ORDER_SECRET_KEY'
-  #     config.product_secret_key = 'PRODUCT_SECRET_KEY'
-  #   end
+  #   client = EcwidApi::Client.new(store_id: '12345', token: 'the access_token')
+  #   client.get "/products"
   #
   class Client
+    extend Forwardable
+
     # The default base URL for the Ecwid API
-    DEFAULT_URL = "https://app.ecwid.com/api/v1"
+    DEFAULT_URL = "https://app.ecwid.com/api/v3"
 
     # Public: Returns the Ecwid Store ID
     attr_reader :store_id
+    attr_reader :token
+    attr_reader :adapter
+
+    attr_reader :connection, :categories, :customers, :orders, :products, :product_types
 
-    # Public: Gets or sets the Order API Secret Key for the Ecwid Store
-    attr_accessor :order_secret_key
+    # Public: Initializes a new Client to interact with the API
+    #
+    # store_id - the Ecwid store_id to interact with
+    # token    - the authorization token provided by oAuth. See the
+    #            Authentication class
+    #
+    def initialize(store_id, token, adapter = Faraday.default_adapter)
+      @store_id, @token, @adapter = store_id, token, adapter
 
-    # Public: Gets or sets the default Product API Secret Key for the Ecwid Store
-    attr_accessor :product_secret_key
+      @connection = Faraday.new store_url do |conn|
+        conn.request  :oauth2, token, param_name: :token
+        conn.request  :json
 
-    def initialize
-      yield(self) if block_given?
-      raise Error.new("The store_id is required") unless store_id
+        conn.response :json, content_type: /\bjson$/
+        conn.response :logger
+
+        conn.adapter  adapter
+      end
+
+      @categories     = Api::Categories.new(self)
+      @customers      = Api::Customers.new(self)
+      @orders         = Api::Orders.new(self)
+      @products       = Api::Products.new(self)
+      @product_types  = Api::ProductTypes.new(self)
     end
 
-    # Public: Returns the base URL of the Ecwid API
-    def url
-      @url || DEFAULT_URL
+    # Public: The URL of the API for the Ecwid Store
+    def store_url
+      "#{DEFAULT_URL}/#{store_id}"
     end
 
-    # Public: Sets the base URL for the Ecwid API
-    def url=(url)
-      reset_connection
-      @url = url
+    def_delegators :connection, :get
+
+    def post(*args, &block)
+      raise_on_failure connection.post(*args, &block)
     end
 
-    # Public: Sets the Ecwid Store ID
-    def store_id=(store_id)
-      reset_connection
-      @store_id = store_id
+    def put(*args, &block)
+      raise_on_failure connection.put(*args, &block)
     end
 
-    # Public: The URL of the API for the Ecwid Store
-    def store_url
-      "#{url}/#{store_id}"
+    def delete(*args, &block)
+      raise_on_failure connection.delete(*args, &block)
     end
 
-    # Public: Sends a GET request to the Ecwid API
+    # Public: A helper method for POSTing an image
     #
-    # path   - The String path for the URL of the request without the base URL
-    # params - A Hash of query string parameters
-    #
-    # Examples
-    #
-    #   # Gets the Categories where the parent Category is 1
-    #   client.get("categories", parent: 1)
-    #   # => #<Faraday::Response>
+    # url - the URL to POST the image to
+    # filename - the path or URL to the image to upload
     #
     # Returns a Faraday::Response
-    def get(path, params={})
-      connection.get(path, params)
-    end
-
-    # Public: Returns the Category API
-    def categories
-      @categories ||= CategoryApi.new(self)
+    #
+    def post_image(url, filename)
+      post(url) do |req|
+        req.body = open(filename).read
+      end
     end
 
     private
 
-    # Private: Resets the connection.
+    # Private: Raises a ResponseError if the request failed
     #
-    # Should be used if the base URL to the Ecwid API changes
-    def reset_connection
-      @connection = nil
-    end
-
-    # Private: Returns a Faraday connection to interface with the Ecwid API
-    def connection
-      @connection ||= Faraday.new store_url do |conn|
-        conn.response :json, content_type: /\bjson$/
-        conn.adapter  Faraday.default_adapter
+    # response - a Faraday::Response object that is the result of a request
+    #
+    # Raises ResponseError if the request wasn't successful
+    #
+    # Returns the original response if the request was successful
+    #
+    #
+    def raise_on_failure(response)
+      if response.success?
+        response
+      else
+        raise ResponseError.new(response)
       end
     end
   end
-end
+end