ecwid_api 0.0.2 → 0.2.3

data/lib/ecwid_api/customer.rb

@@ -0,0 +1,10 @@
+module EcwidApi
+  class Customer < Entity
+    self.url_root = "customers"
+
+     ecwid_reader :name, :email, :totalOrderCount, :customerGroupId, :customerGroupName
+
+     ecwid_writer :name, :email
+
+   end
+end

data/lib/ecwid_api/entity.rb

@@ -1,12 +1,87 @@
 module EcwidApi
   class Entity
-    # Private: Gets the Client
+    # Private: Gets the Hash of data
+    attr_reader :data, :new_data
+    protected   :data, :new_data
+
     attr_reader :client
-    private :client
+    private     :client
 
-    # Private: Gets the Hash of data
-    attr_reader :data
-    private :data
+    class << self
+      attr_accessor :url_root
+
+      def define_accessor(attribute, &block)
+        if const_defined?(:Accessors, false)
+          mod = const_get(:Accessors)
+        else
+          mod = const_set(:Accessors, Module.new)
+          include mod
+        end
+
+        mod.module_eval do
+          define_method(attribute, &block)
+        end
+      end
+
+      private :define_accessor
+
+      # Public: Creates a snake_case access method from an Ecwid property name
+      #
+      # Example
+      #
+      #   class Product < Entity
+      #     ecwid_reader :id, :inStock
+      #   end
+      #
+      #   product = client.products.find(12)
+      #   product.in_stock
+      #
+      def ecwid_reader(*attrs)
+        attrs.map(&:to_s).each do |attribute|
+          method = attribute.underscore
+          define_accessor(method) do
+            self[attribute]
+          end unless method_defined?(attribute.underscore)
+        end
+      end
+
+      # Public: Creates a snake_case writer method from an Ecwid property name
+      #
+      # Example
+      #
+      #   class Product < Entity
+      #     ecwid_writer :inStock
+      #   end
+      #
+      #   product = client.products.find(12)
+      #   product.in_stock = true
+      #
+      def ecwid_writer(*attrs)
+        attrs.map(&:to_s).each do |attribute|
+          method = "#{attribute.underscore}="
+          define_accessor(method) do |value|
+            @new_data[attribute] = value
+          end unless method_defined?(method)
+        end
+      end
+
+      # Public: Creates a snake_case accessor method from an Ecwid property name
+      #
+      # Example
+      #
+      #   class Product < Entity
+      #     ecwid_accessor :inStock
+      #   end
+      #
+      #   product = client.products.find(12)
+      #   product.in_stock
+      #   product.in_stock = true
+      #
+      def ecwid_accessor(*attrs)
+        ecwid_reader(*attrs)
+        ecwid_writer(*attrs)
+      end
+    end
 
     # Public: Initialize a new entity with a reference to the client and data
     #
@@ -16,6 +91,7 @@ module EcwidApi
     #
     def initialize(data, opts={})
       @client, @data = opts[:client], data
+      @new_data = {}
     end
 
     # Public: Returns a property of the data (actual property name)
@@ -31,37 +107,83 @@ module EcwidApi
     #
     # Returns the value of the property, or nil if it doesn't exist
     def [](key)
-      data[key.to_s]
+      @new_data[key.to_s] || data[key.to_s]
     end
 
-    # Public: Get a property of the data (snake_case)
+    # Public: The URL of the entity
     #
-    # This is used as a helper to allow easy access to the data. It will work
-    # with both CamelCased and snake_case keys. For example, if the data
-    # contains a "parentId" key, then calling `entity.parent_id` should work.
-    #
-    # This will NOT return null of the property doesn't exist on the data!
-    #
-    # Examples
+    # Returns a String that is the URL of the entity
+    def url
+      url_root = self.class.url_root
+      raise Error.new("Please specify a url_root for the #{self.class.to_s}") unless url_root
+
+      if url_root.respond_to?(:call)
+        url_root = instance_exec(&url_root)
+      end
+
+      url_root + "/#{id}"
+    end
+
+    def assign_attributes(attributes)
+      attributes.each do |key, val|
+        send("#{key}=", val)
+      end
+    end
+
+    def assign_raw_attributes(attributes)
+      attributes.each do |key, val|
+        @new_data[key.to_s] = val
+      end
+    end
+
+    def update_attributes(attributes)
+      assign_attributes(attributes)
+      save
+    end
+
+    def update_raw_attributes(attributes)
+      assign_raw_attributes(attributes)
+      save
+    end
+
+    # Public: Saves the Entity
     #
-    #   entity.parent_id    # same as `entity["parentId"]`
+    # Saves anything stored in the @new_data hash
     #
-    # TODO: #method_missing isn't the ideal solution because Ecwid will only
-    # return a property if it doesn't have a null value. An example of this are
-    # the top level categories. They don't have a parentId, so that property
-    # is ommitted from the API response. Calling `category.parent_id` will
-    # result in an "undefined method `parent_id'". However, calling `#parent_id`
-    # on any other category will work.
+    # path - the URL of the entity
     #
-    # Returns the value of the property
-    def method_missing(method, *args)
-      method_string = method.to_s
-
-      [ method_string, method_string.camel_case ].each do |key|
-        return data[key] if data.has_key?(key)
+    def save
+      unless @new_data.empty?
+        client.put(url, @new_data).tap do |response|
+          @data.merge!(@new_data)
+          @new_data.clear
+        end
       end
+    end
+
+    # Public: Destroys the Entity
+    def destroy!
+      client.delete(url)
+    end
+
+    def to_hash
+      data
+    end
+
+    def to_json(*args)
+      data.to_json(*args)
+    end
+
+    def marshal_dump
+      [@data, @new_data]
+    end
+
+    def marshal_load(array)
+      @data, @new_data = *array
+    end
 
-      super method, *args
+    def ==(other)
+      data == other.data && new_data == other.new_data
     end
   end
-end
+end

data/lib/ecwid_api/error.rb

@@ -1,3 +1,13 @@
 module EcwidApi
   class Error < StandardError; end;
+
+  class ResponseError < Error
+    def initialize(response)
+      if response.respond_to?(:reason_phrase)
+        super "#{response.reason_phrase} (#{response.status})\n#{response.body}"
+      else
+        super "The Ecwid API responded with an error (#{response.status})"
+      end
+    end
+  end
 end

data/lib/ecwid_api/o_auth.rb

@@ -0,0 +1,106 @@
+require "cgi"
+require "ostruct"
+
+module EcwidApi
+  # Public: Authentication objects manage OAuth authentication with an Ecwid
+  #         store.
+  #
+  # Examples
+  #
+  #   app = EcwidApi::Authentication.new do |config|
+  #     # see initialize for configuration
+  #   end
+  #
+  #   app.oauth_url  # send the user here to authorize the app
+  #
+  #   token = app.access_token(params[:code]) # this is the code they provide
+  #                                           # to the redirect_uri
+  #   token.access_token
+  #   token.store_id      # these are what you need to access the API
+  #
+  class OAuth
+    CONFIG = %w(client_id client_secret scope redirect_uri)
+    attr_accessor *CONFIG
+
+    # Public: Initializes a new Ecwid Authentication for OAuth
+    #
+    # Examples
+    #
+    #   app = EcwidApi::Authentication.new do |config|
+    #     config.client_id     = "some client id"
+    #     config.client_secret = "some client secret"
+    #     config.scope         "this_is_what_i_want_to_do oh_and_that_too"
+    #     config.redirect_uri  = "https://example.com/oauth"
+    #   end
+    #
+    def initialize
+      yield(self) if block_given?
+      CONFIG.each do |method|
+        raise Error.new("#{method} is required to initialize a new EcwidApi::Authentication") unless send(method)
+      end
+    end
+
+    # Public: The URL for OAuth authorization.
+    #
+    # This is the URL that the user will need to go to to authorize the app
+    # with the Ecwid store.
+    #
+    def oauth_url
+      "https://my.ecwid.com/api/oauth/authorize?" + oauth_query
+    end
+
+    # Public: Obtain the access token in order to use the API
+    #
+    # code - the temporary code obtained from the authorization callback
+    #
+    # Examples
+    #
+    #   token = app.access_token(params[:code])
+    #   token.access_token  # the access token that authenticates each API request
+    #   token.store_id      # the authenticated Ecwid store_id
+    #
+    # Returns an OpenStruct which responds with the information needed to
+    # access the API for a store.
+    def access_token(code)
+      response = connection.post("/api/oauth/token",
+        client_id:     client_id,
+        client_secret: client_secret,
+        code:          code,
+        redirect_uri:  redirect_uri,
+        grant_type:    "authorization_code"
+      )
+
+      if response.success?
+        OpenStruct.new(response.body)
+      else
+        raise Error.new(response.body["error_description"])
+      end
+    end
+
+    private
+
+    # Private: The query parameters for the OAuth authorization request
+    #
+    # Returns a String of query parameters
+    def oauth_query
+      {
+        client_id:     client_id,
+        scope:         scope,
+        response_type: "code",
+        redirect_uri:  redirect_uri
+      }.map do |key, val|
+        "#{CGI.escape(key.to_s)}=#{CGI.escape(val.to_s)}"
+      end.join(?&)
+    end
+
+    # Private: Returns a connection for obtaining an access token from Ecwid
+    #
+    def connection
+      @connection ||= Faraday.new "https://my.ecwid.com" do |conn|
+        conn.request  :url_encoded
+        conn.response :json, content_type: /\bjson$/
+        conn.adapter  Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/ecwid_api/order.rb

@@ -0,0 +1,118 @@
+module EcwidApi
+  # Public: This is an Ecwid Order
+  class Order < Entity
+    self.url_root = "orders"
+
+    ecwid_reader :id, :orderNumber, :vendorOrderNumber, :subtotal, :total, :email,
+                 :paymentMethod, :paymentModule, :tax, :ipAddress,
+                 :couponDiscount, :paymentStatus, :fulfillmentStatus,
+                 :refererUrl, :orderComments, :volumeDiscount, :customerId,
+                 :membershipBasedDiscount, :totalAndMembershipBasedDiscount,
+                 :discount, :usdTotal, :globalReferer, :createDate, :updateDate,
+                 :customerGroup, :discountCoupon, :items, :billingPerson,
+                 :shippingPerson, :shippingOption, :additionalInfo,
+                 :paymentParams, :discountInfo, :trackingNumber,
+                 :paymentMessage, :extTransactionId, :affiliateId,
+                 :creditCardStatus, :handlingFee
+
+
+    ecwid_writer :subtotal, :total, :email, :paymentMethod, :paymentModule,
+                 :tax, :ipAddress, :couponDiscount, :paymentStatus,
+                 :fulfillmentStatus, :refererUrl, :orderComments,
+                 :volumeDiscount, :customerId, :membershipBasedDiscount,
+                 :totalAndMembershipBasedDiscount, :discount, :globalReferer,
+                 :createDate, :updateDate, :customerGroup, :discountCoupon,
+                 :items, :billingPerson, :shippingPerson, :shippingOption,
+                 :additionalInfo, :paymentParams, :discountInfo,
+                 :trackingNumber, :paymentMessage, :extTransactionId,
+                 :affiliateId, :creditCardStatus, :handlingFee
+
+    VALID_FULFILLMENT_STATUSES = %w(
+      AWAITING_PROCESSING
+      PROCESSING
+      SHIPPED
+      DELIVERED
+      WILL_NOT_DELIVER
+      RETURNED
+      READY_FOR_PICKUP
+      OUT_FOR_DELIVERY
+    ).freeze
+
+    VALID_PAYMENT_STATUSES = %w(
+      AWAITING_PAYMENT
+      PAID
+      CANCELLED
+      REFUNDED
+      PARTIALLY_REFUNDED
+      INCOMPLETE
+    ).freeze
+
+    # @deprecated Please use {#id} instead
+    def vendor_order_number
+      warn "[DEPRECATION] `vendor_order_number` is deprecated.  Please use `id` instead."
+      id
+    end
+
+    # @deprecated Please use {#id} instead
+    def order_number
+      warn "[DEPRECATION] `order_number` is deprecated.  Please use `id` instead."
+      id
+    end
+
+    # Public: Returns the billing person
+    #
+    # If there isn't a billing_person, then it assumed to be the shipping_person
+    #
+    def billing_person
+      build_billing_person || build_shipping_person
+    end
+
+    # Public: Returns the shipping person
+    #
+    # If there isn't a shipping_person, then it is assumed to be the
+    # billing_person
+    #
+    def shipping_person
+      build_shipping_person || build_billing_person
+    end
+
+    # Public: Returns a Array of `OrderItem` objects
+    def items
+      @items ||= data["items"].map { |item| OrderItem.new(item) }
+    end
+
+    def fulfillment_status=(status)
+      status = status.to_s.upcase
+      unless VALID_FULFILLMENT_STATUSES.include?(status)
+        raise Error("#{status} is an invalid fullfillment status")
+      end
+      super(status)
+    end
+
+    def fulfillment_status
+      super && super.downcase.to_sym
+    end
+
+    def payment_status=(status)
+      status = status.to_s.upcase
+      unless VALID_PAYMENT_STATUSES.include?(status)
+        raise Error("#{status} is an invalid payment status")
+      end
+      super(status)
+    end
+
+    def payment_status
+      super && super.downcase.to_sym
+    end
+
+    private
+
+    def build_billing_person
+      @billing_person ||= data["billingPerson"] && Person.new(data["billingPerson"])
+    end
+
+    def build_shipping_person
+      @shipping_person ||= data["shippingPerson"] && Person.new(data["shippingPerson"])
+    end
+  end
+end