nimbleshop_core 0.0.1.rc1

data/app/models/country_shipping_zone.rb

@@ -0,0 +1,36 @@
+class CountryShippingZone < ShippingZone
+
+  has_many      :regional_shipping_zones, dependent: :destroy
+
+  validates     :country_code,  presence: true
+  validate      :code_validity
+
+  before_save   :set_name,      if: :country_code_changed?
+  after_create  :create_regions
+
+  def country
+    Carmen::Country.coded(country_code)
+  end
+
+  def self.all_country_codes
+    CountryShippingZone.pluck(:country_code)
+  end
+
+  private
+
+  def code_validity
+    unless country
+      errors.add(:country_code, "is invalid")
+    end
+  end
+
+  def create_regions
+    country.subregions.each do | region |
+      regional_shipping_zones.create({ state_code: region.code, country_code: country_code })
+    end
+  end
+
+  def set_name
+    self.name = country.name
+  end
+end

data/app/models/creditcard.rb

@@ -0,0 +1,95 @@
+class Creditcard
+  extend  ActiveModel::Naming
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+  extend  ActiveModel::Callbacks
+  include ActiveModel::Validations::Callbacks
+
+  attr_accessor :cvv, :expires_on, :number, :first_name, :last_name, :address1, :address2,
+                :cardtype, :month, :year, :state, :zipcode
+
+  alias :verification_value :cvv # ActiveMerchant needs this
+
+  delegate :display_number, to: :active_merchant_creditcard
+
+  before_validation :strip_non_numeric_values, if: :number
+
+  validates_presence_of :last_name, :first_name
+
+  validates_presence_of :number,     message: "^Please enter credit card number"
+  validates_numericality_of :number, message: "^Please check the credit card number you entered"
+  validates_presence_of :cvv,        message: "^Please enter CVV"
+
+  validate  :validation_of_cardtype,        if: lambda { |r| r.errors.empty? }
+  validate  :validation_by_active_merchant, if: lambda { |r| r.errors.empty? }
+
+  def initialize(attrs = {})
+    sanitize_month_and_year(attrs)
+
+    attrs.each do | name, value |
+      send("#{name}=", value)
+    end
+  end
+
+  def verification_value?
+    true # ActiveMerchant needs this
+  end
+
+  def persisted?
+    false
+  end
+
+  private
+
+  def add_user_data(options = {})
+    options[:first_name]  = first_name
+    options[:last_name]   = last_name
+  end
+
+  def add_credit_card_data(options = {})
+    options[:year]    = year
+    options[:month]   = month
+    options[:number]  = number
+    options[:type]    = cardtype
+    options[:verification_value]  = verification_value
+  end
+
+  def strip_non_numeric_values
+    self.number = number.to_s.gsub('-', '').strip
+  end
+
+  def validation_of_cardtype
+    if cardtype = ActiveMerchant::Billing::CreditCard.type?(number)
+      self.cardtype = cardtype
+    else
+      errors.add(:base, 'Please check credit card number. It does not seem right.')
+    end
+  end
+
+  def validation_by_active_merchant
+    amcard = active_merchant_creditcard
+
+    unless amcard.valid?
+      amcard.errors.full_messages.each { |message| errors.add(:base, message) }
+    end
+
+    amcard.errors.any?
+  end
+
+  def active_merchant_creditcard
+    options = {}
+    add_user_data(options)
+    add_credit_card_data(options)
+
+    ActiveMerchant::Billing::CreditCard.new(options)
+  end
+
+  def sanitize_month_and_year(attrs)
+    month = attrs.delete("expires_on(2i)")
+    year =  attrs.delete("expires_on(1i)")
+    day = attrs.delete("expires_on(3i)")
+    attrs.reverse_merge!(month: month)
+    attrs.reverse_merge!(year: year)
+  end
+
+end

data/app/models/custom_field.rb

@@ -0,0 +1,8 @@
+class CustomField < ActiveRecord::Base
+
+  has_many :custom_field_answers, dependent: :destroy
+
+  validates :field_type, presence: true, inclusion: { in: %w(text number date) }
+
+  validates :name, presence: true
+end

data/app/models/custom_field_answer/field.rb

@@ -0,0 +1,101 @@
+class CustomFieldAnswer
+  module Field
+    extend ActiveSupport::Concern
+
+    def custom_field=(custom_field)
+      set_custom_field(custom_field)
+
+      extend_module
+    end
+
+    # when question_id is assigned extend the module
+    def custom_field_id=(question_id)
+      super
+
+      extend_module
+    end
+
+    # Override Answer initialize method to extend proper Response module
+    # For example
+    # Answer instance whose question is TextFieldQuestion will extend TextFieldResponse
+    def initialize(attributes = nil, options = {})
+      super
+
+      extend_module
+    end
+
+    # We need to override after_initialize module to force instance to extend proper module
+    # ActiveRecord instances are created sometimes using malloc which will not invoke the initialize
+    # but they will call after_initialize
+    def after_initialize
+      extend_module
+    end
+
+    def extend_module
+      if target_module = module_to_extend
+        # Don't include module twice
+        kind_of?(target_module) || extend(target_module)
+
+        # Force value coersion for extended module
+        #
+        # For example
+        # if answer is created as shown below
+        # case(1)
+        # q = NumberQuestion.new
+        # a = Answer.new(:question => q, :value => 23.45)
+        # a.float_value ==> nil
+        # a.value  ==> '23.45'
+        #
+        # case(2)
+        # a = Answer.new(:question => q)
+        # a.value = 23.45
+        # a.float_value ==> 23.45
+        # a.value  ==> '23.45'
+        #
+        # Above case appears bcoz modules are extended after
+        # attributes are assigned. reassign_value method will
+        # give the modules to fix this problem please refer
+        # to NumberResponse reassign_value
+        #
+        # Note: currently both cases will work as expected
+        reassign_value
+      end
+    end
+
+    # This method will determine which module to extend
+    # Answer instances which are created using select might throw exception
+    # For example Answer.find(:conditions => [], :select => "value")
+    # retrieve_module_name will throw exception when it tries to access question field
+    # This is the only case Answer will fail to extend proper module
+    def module_to_extend
+      begin
+        CustomFieldAnswer::Field.const_get("#{custom_field.field_type.camelize}Field")
+      rescue
+        nil
+      end
+    end
+
+    def reassign_value
+      self.value = self.value
+    end
+
+    module DateField
+      def value=(value)
+        super
+
+        self.datetime_value = value
+      end
+    end
+
+    module NumberField
+      def value=(value)
+        super
+
+        self.number_value = value
+      end
+    end
+
+    module TextAnswerField
+    end
+  end
+end

data/app/models/custom_field_answer.rb

@@ -0,0 +1,17 @@
+class CustomFieldAnswer < ActiveRecord::Base
+
+  belongs_to :product
+
+  belongs_to :custom_field
+  alias_method :set_custom_field, :custom_field=
+
+  # this module must be included only after belong_to :custom_field definition
+  # this module overrides the dynamic methods which are added by belongs_to
+  include Field
+
+  def custom_field=(custom_field)
+    set_custom_field(custom_field)
+
+    extend_module
+  end
+end

data/app/models/line_item.rb

@@ -0,0 +1,48 @@
+class LineItem < ActiveRecord::Base
+
+  # this is used only to pull the picture of the line_item. If after an order is created a product
+  # is deleted then that product and all the pictures are gone. In that case line item should
+  # display image not available. Besides image line_item should not pull any data from product and
+  # instead used the attributes copied from product to line_item
+  belongs_to :product
+
+  store :metadata, accessors: [ :picture_tiny,      :picture_small,      :picture_medium,      :picture_large,
+                                :picture_tiny_plus, :picture_small_plus, :picture_medium_plus, :picture_large_plus,
+                                :product_permalink ]
+
+  belongs_to :order
+
+  validates_presence_of :order_id
+  validates_presence_of :product_id
+  validates_numericality_of :quantity, minimum: 1
+
+  before_create :copy_product_attributes
+
+  alias_attribute :name, :product_name
+  alias_attribute :description, :product_description
+
+  def price
+    product_price * quantity
+  end
+
+  # updates quantity count. If count is zero then deletes the line_item .
+  def update_quantity(count)
+    count = count.to_i
+    (count > 0) ? update_attributes(quantity: count) : destroy
+  end
+
+  private
+
+  def copy_product_attributes
+    self.product_name        = product.name
+    self.product_description = product.description
+    self.product_price       = product.price
+    self.product_permalink   = product.permalink
+
+    if product.picture
+      %w(tiny tiny_plus small small_plus medium medium_plus large large_plus).each do |size|
+        send("picture_#{size}=", product.picture.picture_url(size.intern))
+      end
+    end
+  end
+end

data/app/models/link.rb

@@ -0,0 +1,3 @@
+class Link < ActiveRecord::Base
+  validates_presence_of :name, :url
+end

data/app/models/link_group.rb

@@ -0,0 +1,8 @@
+class LinkGroup < ActiveRecord::Base
+
+  include Permalink::Builder
+
+  has_many :navigations, dependent: :destroy
+
+  validates :name, presence: true, uniqueness: { case_sensitive: false }
+end

data/app/models/navigation.rb

@@ -0,0 +1,7 @@
+class Navigation < ActiveRecord::Base
+  belongs_to :link_group
+  belongs_to :product_group
+
+  validates  :link_group,     presence: true
+  validates  :product_group,  presence: true
+end

data/app/models/order.rb

@@ -0,0 +1,158 @@
+class Order < ActiveRecord::Base
+
+  # to allow extensions to store any type of information
+  store :metadata
+
+  attr_accessor   :validate_email, :billing_address_same_as_shipping
+  attr_protected  :number
+
+  belongs_to  :user
+  belongs_to  :payment_method
+  belongs_to  :shipping_method
+
+  has_one     :shipping_address,  dependent:  :destroy
+  has_one     :billing_address,   dependent:  :destroy
+
+  has_many    :shipments
+  has_many    :line_items,   dependent:  :destroy
+  has_many    :products,     through:    :line_items
+  has_many    :payment_transactions, dependent:  :destroy
+
+  accepts_nested_attributes_for :shipping_address, allow_destroy: true
+  accepts_nested_attributes_for :billing_address,  reject_if: :billing_address_same_as_shipping?  , allow_destroy: true
+
+  delegate :tax,            to: :tax_calculator
+  delegate :shipping_cost,  to: :shipping_cost_calculator
+
+  validates :email, email: true, if: :validate_email
+
+  validates_inclusion_of :shipping_status, in: %W( nothing_to_ship shipped shipping_pending cancelled )
+  validates_inclusion_of :status,          in: %W( open closed )
+  validates_inclusion_of :checkout_status, in: %W( items_added_to_cart billing_address_provided shipping_method_provided )
+
+  before_create :set_order_number
+
+  # Look at order_observer to see all the callbacks.
+  #
+  # capture is a method defined on kernel by Rails hence kapture is used .
+  #
+  # An order goes into pending state when it is paid for using 'Cash on delivery'
+  state_machine :payment_status, initial: :abandoned do
+
+    event(:authorize) { transition abandoned:   :authorized }
+    event(:pending)   { transition abandoned:   :pending    }
+    event(:kapture )  { transition authorized:  :purchased  }
+    event(:refund)    { transition purchased:   :refunded   }
+
+    event(:purchase)  { transition [:abandoned,  :pending] =>  :purchased  }
+    event(:void)      { transition [:authorized, :pending] =>  :voided     }
+
+    state all - [ :abandoned ] do
+      validates :payment_method, presence: true
+    end
+  end
+
+  state_machine :shipping_status, initial: :nothing_to_ship do
+    after_transition on: :shipped, do: :after_shipped
+
+    event(:shipping_pending) { transition nothing_to_ship: :shipping_pending }
+    event(:shipped)          { transition shipping_pending: :shipped         }
+    event(:cancel_shipment)  { transition shipping_pending: :nothing_to_ship }
+  end
+
+  def mark_as_purchased!
+    touch(:purchased_at) unless purchased_at
+  end
+
+  def available_shipping_methods
+    ShippingMethod.available_for(line_items_total, shipping_address)
+  end
+
+  def item_count
+    line_items.count
+  end
+
+  def add(product)
+    options = { product_id: product.id }
+    if line_items.where(options).empty?
+      line_items.create(options.merge(quantity: 1))
+    end
+  end
+
+  def update_quantity(data = {})
+    data.each do |product_id, quantity|
+      if line_item = line_item_for(product_id)
+        line_item.update_quantity(quantity)
+      end
+    end
+  end
+
+  def remove(product)
+    update_quantity({product.id => 0})
+  end
+
+  # Returns the total price of all line items in float.
+  def line_items_total
+    line_items.reduce(BigDecimal('0')) do |sum, line_item|
+      sum + BigDecimal(line_item.price.to_s)
+    end.round(2).to_f
+  end
+
+  def total_amount
+    line_items_total + shipping_cost + tax
+  end
+
+  def total_amount_in_cents
+    Util.in_cents(total_amount)
+  end
+
+  def to_param
+    number
+  end
+
+  def final_billing_address
+    (shipping_address && !shipping_address.use_for_billing) ? billing_address : shipping_address
+  end
+
+  def initialize_addresses
+    shipping_address || build_shipping_address(country_code: "US", use_for_billing: true)
+    billing_address || build_billing_address(country_code: "US", use_for_billing: false)
+  end
+
+  def billing_address_same_as_shipping?
+    billing_address_same_as_shipping
+  end
+
+  def line_item_for(product_id)
+    line_items.find_by_product_id(product_id)
+  end
+
+  def shippable_countries
+    ShippingMethod.available_for_countries(line_items_total)
+  end
+
+  private
+
+  def set_order_number
+    num = Random.new.rand(11111111...99999999).to_s
+    while self.class.exists?(number: num) do
+      num = Random.new.rand(11111111...99999999).to_s
+    end
+
+    self.number = num
+  end
+
+  def tax_calculator
+    @_tax_calculator ||= TaxCalculator.new(self)
+  end
+
+  def shipping_cost_calculator
+    @_shipping_cost_calculator ||= ShippingCostCalculator.new(self)
+  end
+
+  def after_shipped
+    Mailer.delay.shipment_notification_to_buyer(number)
+    touch(:shipped_at)
+  end
+
+end

data/app/models/payment_method.rb

@@ -0,0 +1,20 @@
+class PaymentMethod < ActiveRecord::Base
+
+  store :metadata
+
+  include Permalink::Builder
+
+  # By default payment_method does not require that application must use SSL.
+  # Individual payment method should override this method.
+  def use_ssl?
+    false
+  end
+
+  def demodulized_underscore
+    self.class.name.demodulize.underscore
+  end
+
+  def self.partialize
+    name.gsub("PaymentMethod::","").underscore
+  end
+end

data/app/models/payment_transaction.rb

@@ -0,0 +1,11 @@
+class PaymentTransaction < ActiveRecord::Base
+
+  belongs_to  :order
+  serialize   :params,          Hash
+  serialize   :metadata,        Hash
+
+  def to_partial_path
+    "admin/orders/payment_transactions/#{order.payment_method.class.partialize}"
+  end
+
+end

data/app/models/picture.rb

@@ -0,0 +1,30 @@
+class Picture < ActiveRecord::Base
+
+  belongs_to :product
+
+  mount_uploader :picture, PictureUploader
+
+  validates_presence_of :picture
+
+  before_save :update_picture_attributes
+
+  %w(tiny tiny_plus small small_plus medium medium_plus large large_plus).each do |version|
+    define_method :"#{version}_height" do
+      picture.send(version).height
+    end
+
+    define_method :"#{version}_width" do
+      picture.send(version).width
+    end
+  end
+
+  private
+
+  def update_picture_attributes
+    if picture.present?
+      self.content_type = picture.file.content_type
+      self.file_size = picture.file.size
+    end
+  end
+
+end

data/app/models/product.rb

@@ -0,0 +1,76 @@
+class Product < ActiveRecord::Base
+
+  include Permalink::Builder
+
+  alias_attribute :title, :name
+
+  attr_accessor :pictures_order
+
+  validates :status, inclusion: { in: %w(active hidden sold_out) }, presence: true
+
+  has_many :pictures, order: 'pictures.position'
+
+  has_many :custom_field_answers, dependent: :destroy
+
+  accepts_nested_attributes_for :pictures, allow_destroy: true, reject_if: proc { |r| r[:picture].blank? }
+
+  accepts_nested_attributes_for :custom_field_answers, allow_destroy: true
+
+  after_initialize :initialize_status
+
+  scope :with_prictures, includes: 'pictures'
+
+  scope :active,    where(status: 'active')
+  scope :hidden,    where(status: 'hidden')
+  scope :sold_out,  where(status: 'sold_out')
+
+
+  validates_presence_of :name, :description, :price
+
+  validates_numericality_of :price
+
+  def picture
+    pictures.first
+  end
+
+  # path is full path to the picture.
+  #
+  # Rails.root.join('db', 'original_pictures', filename )
+  #
+  # This method is used only in development and test to attach a picture.
+  def attach_picture(filename, path)
+    img = File.open(path) {|i| i.read}
+    encoded_img = Base64.encode64 img
+    io = FilelessIO.new(Base64.decode64(encoded_img))
+    io.original_filename = filename
+    p = Picture.new(product: self, picture: io)
+    p.save
+  end
+
+  def find_or_build_answer_for_field(field)
+    custom_field_answers.detect {|t| t.custom_field_id.to_s == field.id.to_s } ||
+      custom_field_answers.build(custom_field_id: field.id)
+  end
+
+  def find_or_build_all_answers
+    CustomField.all.each { |f| find_or_build_answer_for_field(f) }
+  end
+
+
+  def pictures_order=(value)
+    return if value.empty?
+    ordered_pictures = ActiveSupport::JSON.decode(value)
+    current_pictures = pictures
+
+    ordered_pictures.each{|position, picture_id|
+      if picture_id.present?
+        pic = current_pictures.find { |x| x.id == picture_id.to_i }
+        pic.update_column(:position, position) if pic
+      end
+    }
+  end
+
+  def initialize_status
+    self.status ||= 'active'
+  end
+end

data/app/models/product_group.rb

@@ -0,0 +1,65 @@
+class ProductGroup < ActiveRecord::Base
+
+  include Permalink::Builder
+
+  validates :name, presence: true
+
+  has_many :product_group_conditions, dependent: :destroy, extend: ProductGroupSearch::Extension
+
+  has_many :navigations, dependent:  :destroy
+
+  has_many :link_groups, through:    :navigations
+
+  accepts_nested_attributes_for :product_group_conditions, allow_destroy: true
+
+  # determines if the given product exists in the product group
+  def contains?(product)
+    products.include?(product)
+  end
+
+  def self.fields
+    c = []
+    c << { "id" => 'name', "name" => 'Name', "field_type" => 'text' }
+    c << { "id" => 'price', "name" => 'Price', "field_type" => 'number' }
+
+    CustomField.all.map do | field |
+      c << field.attributes.slice("id", "name", "field_type")
+    end
+
+    c
+  end
+
+  def self.operators
+    {
+      text:   [{ name: 'Contains',    value: 'contains' },
+               { name: 'Starts With', value: 'starts'},
+               { name: 'Ends With',   value:'ends'}],
+
+      number: [{ name: 'Equal', value: 'eq' },
+               { name: 'Greater Than', value: 'gt' },
+               { name: 'Grater Than Equal To', value:'gteq' },
+               { name: 'Less Than', value: 'lt' },
+               { name: 'Less Than Equal To', value: 'lteq'}],
+
+      date:   [{ name: 'On', value: 'eq' },
+               { name: 'After', value: 'gt' },
+               { name: 'On or After', value:'gteq' },
+               { name: 'Before', value: 'lt' },
+               { name: 'On or Before', value: 'lteq'}],
+    }
+  end
+
+  def products
+    product_group_conditions.search
+  end
+
+  def summarize
+    product_group_conditions.map(&:summary).join('  and ')
+  end
+
+   # list of all product groups containing input product
+  def self.contains_product(product)
+    all.select { | product_group | product_group.contains?(product) }
+  end
+
+end