cornerstore 0.6.2

data/lib/cornerstore/api/order.rb

@@ -0,0 +1,94 @@
+class Cornerstore::Order < Cornerstore::Model::Base
+  attr_accessor :number,
+    :reference,
+    :checkout_id,
+    :placed_at,
+    :invoice_number,
+    :invoiced_at,
+    :checkout_started_at,
+    :requested_carrier,
+    :weight,
+    :subtotal,
+    :shipping_costs,
+    :payment_costs,
+    :sales_tax,
+    :total,
+    :customer_comment,
+
+    :customer,
+    :shipping_address,
+    :billing_address,
+    :payment_means,
+    :requested_carrier,
+    :line_items,
+    :shipments,
+    :cancellations
+
+  def initialize(attributes, parent=nil)
+    self.payment_costs      = Cornerstore::Price.new(attributes.delete('payment_costs')) if attributes['payment_costs']
+    self.shipping_costs     = Cornerstore::Price.new(attributes.delete('shipping_costs')) if attributes['shipping_costs']
+    self.subtotal           = Cornerstore::Price.new(attributes.delete('subtotal'))
+    self.sales_tax          = Cornerstore::Price.new(attributes.delete('sales_tax')) if attributes['sales_tax']
+    self.total              = Cornerstore::Price.new(attributes.delete('total'))
+
+    self.customer           = Cornerstore::Customer.new(attributes.delete('customer'))
+    self.shipping_address   = Cornerstore::Address.new(attributes.delete('shipping_address'))
+    self.billing_address    = Cornerstore::Address.new(attributes.delete('billing_address'))
+    self.payment_means      = Cornerstore::PaymentMeans.new(attributes.delete('payment_means'))
+    self.requested_carrier  = Cornerstore::Carrier.new(attributes.delete('requested_carrier'))
+
+    self.line_items         = Cornerstore::LineItem::Resource.new(self, attributes.delete('line_items') || [], 'line_items')
+    self.shipments          = Cornerstore::Shipment::Resource.new(self, attributes.delete('shipments') || [], 'shipments')
+    self.cancellations      = Cornerstore::Cancellation::Resource.new(self, attributes.delete('cancellations') || [], 'cancellations')
+
+    self.placed_at          = DateTime.parse(attributes.delete('placed_at')) unless attributes['placed_at'].blank?
+    self.invoiced_at        = DateTime.parse(attributes.delete('invoiced_at')) unless attributes['invoiced_at'].blank?
+
+    super
+  end
+
+  def requires_shipment?
+    self.line_items.any? { |li| li.requires_shipment? }
+  end
+
+  # Returns true if at least one line item of this order is shipped
+  def shipped?
+    !self.shipments.empty?
+  end
+
+  # Returns true if at least one line item of this order is canceled
+  def canceled?
+    !self.cancellations.empty?
+  end
+
+  def invoiced?
+    !self.invoice_number.blank?
+  end
+
+  # Returns true if all line items are shipped
+  def completely_shipped?
+    self.shipments.collect(&:shipped_items).flatten.size == self.line_items.size
+  end
+
+  # Returns true if all line items are canceled
+  def completely_canceled?
+    self.cancellations.collect(&:canceled_items).flatten.size == self.line_items.size
+  end
+
+  def handling_costs
+    if self.shipping_costs and self.payment_costs
+      self.shipping_costs + self.payment_costs
+    elsif self.shipping_costs
+      self.shipping_costs
+    elsif self.payment_costs
+      self.payment_costs
+    else
+      nil      
+    end
+  end
+
+  def check_signature
+    # TODO: Implement signature check
+    return true
+  end
+end

data/lib/cornerstore/api/payment_means.rb

@@ -0,0 +1,32 @@
+class Cornerstore::PaymentMeans < Cornerstore::Model::Base
+  attr_accessor :kind,
+                :paid_at,
+                :refunded_at,
+                :card_token,
+                :issuer,
+                :last_digits,
+                :owner,
+                :bank,
+                :iban,
+                :swift_bic,
+                :payment_id
+
+  alias_method :type, :kind
+
+  def initialize(attributes = {}, parent = nil)
+    if attributes
+      self.paid_at      = DateTime.parse(attributes.delete('paid_at')) unless attributes['paid_at'].blank?
+      self.refunded_at  = DateTime.parse(attributes.delete('refunded_at')) unless attributes['refunded_at'].blank?
+    end
+
+    super
+  end
+
+  def paid?
+    self.paid_at.is_a?(DateTime)
+  end
+
+  def refunded?
+    self.refunded_at.is_a?(DateTime)
+  end
+end

data/lib/cornerstore/api/price.rb

@@ -0,0 +1,77 @@
+class Cornerstore::Price < Cornerstore::Model::Base
+  include Comparable
+
+  attr_accessor :gross,
+                :net,
+                :tax,
+                :tax_rate,
+                :currency,
+                :amount
+
+  validates :gross, numericality: { greater_than_or_equal_to: 0 }, if: Proc.new { |p| not p.amount }
+  validates :amount, numericality: { greater_than_or_equal_to: 0 }, if: Proc.new { |p| not p.gross }
+  validates :net, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+  validates :tax_rate, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+  validates :currency, presence: true, inclusion: { in: %w( EUR USD ) }
+
+  def attributes
+    if gross or tax_rate
+      {
+        gross: gross,
+        net: net,
+        tax_rate: tax_rate,
+        currency: currency
+      }
+    else
+      {
+        amount: amount,
+        currency: currency
+      }
+    end
+  end
+
+  def <=> (other_object)
+    case other_object
+    when Integer, Float, Fixnum
+      self.amount <=> other_object
+    when Cornerstore::Price
+      self.amount <=> other_object.amount
+    else
+      raise ArgumentError, 'can only compare Integer, Float, Fixnum or Price objects with Price'
+    end
+  end
+
+  def +(other_object)
+    return self if not other_object or other_object == 0
+
+    if gross
+      Cornerstore::Price.new({
+        gross:    gross + other_object.gross,
+        net:      net + other_object.net,
+        currency: currency,
+        tax_rate: other_object.tax_rate == tax_rate ? tax_rate : nil
+      })
+    else
+      Cornerstore::Price.new({
+        amount:   amount + other_object.amount,
+        currency: currency
+      })
+
+    end
+  end
+
+  def to_f
+    @amount || @gross
+  end
+
+  def amount
+    @amount || @gross
+  end
+
+  def currency_symbol
+    {
+      'USD' => '$',
+      'EUR' => '€',
+    }[currency]
+  end
+end

data/lib/cornerstore/api/product.rb

@@ -0,0 +1,72 @@
+class Cornerstore::Product < Cornerstore::Model::Base
+  attr_accessor :name,
+                :description,
+                :manufacturer,
+                :enabled,
+                :variants,
+                :images,
+                :properties
+
+  def initialize(attributes = {}, parent = nil)
+    self.images     = Cornerstore::Image::Resource.new(self, attributes.delete('images') || [], 'images')
+    self.variants   = Cornerstore::Variant::Resource.new(self, attributes.delete('variants') || [], 'variants')
+    self.properties = Cornerstore::Property::Resource.new(self, attributes.delete('properties') || [], 'properties')
+    super
+  end
+
+  def attributes
+    {
+      name: name,
+      description: description,
+      manufacturer: manufacturer,
+      enabled: enabled
+    }
+  end
+
+  def price
+    variants.collect { |v| v.price }.sort.first
+  end
+
+  def order_number
+    variants.many? ? :many : variants.first.order_number
+  end
+
+  def sold_out?
+    variants.all? { |v| v.sold_out? }
+  end
+
+  def offer?
+    variants.any? { |v| v.offer? }
+  end
+
+  def new?
+    self.created_at >= 2.weeks.ago
+  end
+
+  def cover_image
+    @cover_image ||= self.images.to_a.find {|i| i.cover == true }
+  end
+
+  class Resource < Cornerstore::Resource::Base
+    include Cornerstore::Resource::Remote
+    include Cornerstore::Resource::Filter
+
+    def enabled
+      self.clone.set_filter(:enabled, true)
+    end
+
+    def by_collection(collection_id)
+      self.clone.tap{|r| r.parent = Cornerstore::Collection.find(collection_id)}
+    end
+    alias find_by_collection by_collection
+
+    def order(key)
+      first = %w(name popularity created_at price)
+      second = %w(desc asc)
+      pattern = /\A(#{first.join('|')})( (#{second.join('|')}))?\z/i
+      raise "order key must be one of: #{first.join(', ')} [#{second.join(', ')}]" unless key.match pattern
+      super
+    end
+    alias order_by order
+  end
+end

data/lib/cornerstore/api/property.rb

@@ -0,0 +1,30 @@
+class Cornerstore::Property < Cornerstore::Model::Base
+  include Cornerstore::Model::Writable
+
+  attr_accessor :key,
+                :value
+  
+  def attributes
+    {
+      key: key,
+      value: value
+    }
+  end
+  
+  # TODO: Rewrite #url on base model to automatically detect parent/url depth.
+  def url
+    super(2)
+  end
+  
+  def initialize(attributes = {}, parent = nil)
+    @key = attributes.delete(:key)
+    @value = attributes.delete(:value)
+        
+    super
+  end
+  
+  class Resource < Cornerstore::Resource::Base
+    include Cornerstore::Resource::Remote
+    include Cornerstore::Resource::Writable
+  end
+end

data/lib/cornerstore/api/search.rb

@@ -0,0 +1,35 @@
+class Cornerstore::Search
+  extend ActiveModel::Naming
+
+  attr_accessor :keywords, :products, :scores
+  alias :results :products
+
+  def initialize(keywords = nil)
+    @keywords, @scores, @products = keywords, Array.new, Cornerstore::Product::Resource.new
+  end
+
+  def results?
+    !@products.empty?
+  end
+
+  def to_key
+    ['']
+  end
+
+  def persisted?
+    false
+  end
+
+  def run
+    return false unless @keywords
+
+    RestClient.get("#{Cornerstore.root_url}/products/search?keywords=#{URI::encode(@keywords)}", Cornerstore.headers) do |response, request, result, &block|
+      if response.code == 200
+        data = ActiveSupport::JSON.decode(response)
+        @scores   = data['scores']
+        @products = Cornerstore::Product::Resource.new(nil, data['products'])
+        return true
+      end
+    end
+  end
+end

data/lib/cornerstore/api/shipment.rb

@@ -0,0 +1,24 @@
+class Cornerstore::Shipment < Cornerstore::Model::Base
+  attr_accessor :carrier,
+    :tracking_number,
+    :created_at,
+    :line_item_ids
+
+  alias_method :shipped_at, :created_at
+
+  def initialize(attributes = {}, parent=nil)
+    self.carrier  = Cornerstore::Carrier.new(attributes.delete('carrier'))
+    self.line_item_ids = attributes.delete('shipped_items')
+    super
+  end
+
+  def line_items
+    return [] unless self.parent
+    self.parent.line_items.select { |li| self.line_item_ids.include?(li.id) }
+  end
+  alias_method :shipped_items, :line_items
+
+
+  class Resource < Cornerstore::Resource::Base
+  end
+end

data/lib/cornerstore/api/variant.rb

@@ -0,0 +1,49 @@
+class Cornerstore::Variant < Cornerstore::Model::Base
+  attr_accessor :order_number,
+                :price,
+                :qty_in_stock,
+                :qty_reserved,
+                :offer,
+                :oversell,
+                :weight,
+                :unit,
+                :properties,
+                :differentiating_properties
+
+  alias product parent
+  alias offer? offer
+
+  def attributes
+    {
+      order_number: order_number,
+      price: price,
+      qty_in_stock: qty_in_stock,
+      qty_reserved: qty_reserved,
+      offer: offer,
+      oversell: oversell,
+      weight: weight,
+      unit: unit
+    }
+  end
+
+  def initialize(attributes = {}, parent = nil)
+    self.price = Cornerstore::Price.new(attributes.delete('price'))
+    self.properties = Cornerstore::Property::Resource.new(self, attributes.delete('properties') || [])
+    super
+  end
+
+  def qty_available
+    if self.qty_in_stock and not self.oversell
+      self.qty_in_stock - self.qty_reserved
+    else
+      Float::INFINITY
+    end
+  end
+
+  def sold_out?
+    self.qty_available == 0
+  end
+
+  class Resource < Cornerstore::Resource::Base
+  end
+end

data/lib/cornerstore/model.rb

@@ -0,0 +1,117 @@
+module Cornerstore
+  module Model
+    class Base
+      include ActiveModel::Validations
+      include ActiveModel::Serializers::JSON
+
+      attr_accessor :_id
+      attr_accessor :_slugs
+      attr_accessor :parent
+      attr_accessor :created_at
+      attr_accessor :updated_at
+
+      alias id _id
+
+      def initialize(attributes = {}, parent = nil)
+        self.attributes = attributes
+        self.parent = parent
+        yield self if block_given?
+      end
+
+      def to_param
+        if _slugs and !_slugs.empty?
+          _slugs.first
+        else
+          _id
+        end
+      end
+
+      def ==(other)
+        other.id == self.id
+      end
+
+      alias eql? ==
+
+      def inspect
+        {class: self.class.name, id: id}.merge!(attributes).to_s
+      end
+
+      def attributes
+        {}
+      end
+
+      def attributes=(attributes)
+        attributes ||= {}
+        attributes.each_pair do |name, value|
+          send("#{name}=", value) if respond_to?("#{name}=")
+        end
+      end
+
+      def url(depth = 1)
+        root = (@parent && depth > 0) ? @parent.url(depth-1) : Cornerstore.root_url
+        "#{root}/#{self.class.name.split('::').last.underscore.pluralize}/#{id}"
+      end
+
+      def self.method_missing(method, *args, &block)
+        if (self.const_defined?("Resource") and self.const_get("Resource").method_defined?(method))
+          self.const_get("Resource").new.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if Writable.method_defined?(method)
+          raise "Sorry, this part of the Cornerstore-API is currently read-only"
+        else
+          super
+        end
+      end
+    end
+
+    module Writable
+      def new?
+        id.nil?
+      end
+
+      alias new_record? new?
+
+      def to_key
+        new? ? [id] : nil
+      end
+
+      def save
+        return false unless valid?
+        wrapped_attributes = {self.class.name.split('::').last.underscore => self.attributes}
+        if new?
+          response = RestClient.post(url, wrapped_attributes, Cornerstore.headers){|response| response}
+          self.attributes = ActiveSupport::JSON.decode(response)
+        else
+          response = RestClient.patch(url, wrapped_attributes, Cornerstore.headers){|response| response}
+        end
+
+        if response.success?
+          return true
+        else
+          if data = ActiveSupport::JSON.decode(response) and data.has_key?('errors')
+            data['errors'].each_pair do |key, messages|
+              messages.map { |message| self.errors.add(key, message) }
+            end
+
+            return false
+          else
+            return false
+          end
+        end
+      end
+
+      def destroy
+        RestClient.delete(url, Cornerstore.headers).success?
+      end
+
+      def self.create(attributes = {}, &block)
+        self.new(attributes, &block).tap{|obj| obj.save}
+      end
+    end
+  end
+end