shoppy 0.9.0

data/app/helpers/shoppy/manufacturers_helper.rb

@@ -0,0 +1,4 @@
+module Shoppy
+  module ManufacturersHelper
+  end
+end

data/app/helpers/shoppy/options_helper.rb

@@ -0,0 +1,43 @@
+module Shoppy
+  module OptionsHelper
+    def self.create_options_group(group_name, display, options_names)
+      items = options_names.split(',')
+      OptionsGroup.transaction do
+        g = OptionsGroup.new
+        g.name = group_name.downcase.titleize
+        g.display = display
+        g.save
+        items.each do |i|
+          OptionsItem.create(name: i.to_s, options_group_id: g.id)
+        end
+        return g
+      end
+    end
+
+    def self.items_to_string(options_group)
+      ois = ""
+      options_group.options_items.order("name ASC").each do |oi|
+        ois += oi.name + ","
+      end
+      return ois[0..ois.length-2]
+    end
+
+
+    def self.update_options_items(options_group)
+      o = options_group.optionsItems.split(',')
+      n = options_group.items_string.split(',')
+      o.each do |oi|
+        if n.include?(oi) == false
+          to_remove = OptionsItem.find_by(name: oi, options_group_id: options_group.id)
+          to_remove.destroy if to_remove
+        end
+      end
+      n.each do |ni|
+        if o.include?(ni) == false
+          OptionsItem.create(name: ni, options_group_id: options_group.id)
+        end
+      end
+      return true
+    end
+  end
+end

data/app/helpers/shoppy/orders_helper.rb

@@ -0,0 +1,61 @@
+module Shoppy
+  module OrdersHelper
+
+    def self.calculate_points(order)
+      Customer.transaction do
+        c = order.customer
+        ois = order.order_lines
+        ois.each do |ol|
+          c.points += (ol.variant.points * ol.quantity)
+        end
+        c.save
+        return true
+      end
+    end
+
+    def self.new_order(customer, order_lines_hash, customer_address)
+      OrderLine.transaction do
+        order = Order.new
+        order.customer = customer
+        order.customer_name         = customer.name
+        order.customer_email        = customer.email
+        order.customer_phone        = customer.phone
+        order.customer_add_line1    = customer_address.add_line1
+        order.customer_add_line2    = customer_address.add_line2
+        order.customer_city         = customer_address.city
+        order.customer_state        = customer_address.state
+        order.customer_country      = customer_address.country
+        order.customer_zip          = customer_address.zip
+        order.save
+        order_total_price = 0.0
+        ols = []
+        order_lines_hash.each do |variant_id, quantity|
+          v = Variant.find_by(id: variant_id)
+          if v && quantity > 0
+            ol = OrderLine.new
+            ol.order = order
+            ol.variant = Variant.find(variant_id.to_i)
+            ol.quantity = quantity.to_i
+            ol.price_per_one = ol.variant.price
+            line_totalprice = ol.quantity * ol.price_per_one
+            order_total_price += line_totalprice
+            ols += [ol]
+          end
+        end
+        order.total_price = order_total_price
+        order.date = Date.today
+        order.order_lines = ols
+        if ols.count > 0 && order.save
+          OrdersHelper::calculate_points(order)
+          return order
+        else
+          return nil
+        end
+      end
+    end
+
+
+  end
+
+
+end

data/app/helpers/shoppy/products_helper.rb

@@ -0,0 +1,65 @@
+module Shoppy
+  module ProductsHelper
+    def self.add_options_groups_to_product(product, options_groups)
+      product.options_groups += options_groups
+      product.save
+      vs = product.variants
+      vs.each do |v|
+        options_groups.each do |og|
+          v.put_option(og.name, "")
+        end
+        v.save
+      end
+      return product
+    end
+
+    def self.remove_options_groups_from_product(product, options_groups)
+      product.options_groups -= options_groups
+      product.save
+      vs = product.variants
+      vs.each do |v|
+        options_groups.each do |og|
+          v.delete_option(og.name)
+        end
+        v.save
+      end
+      return product
+    end
+
+    def self.update_options_groups_for_product(product, options_groups)
+      Product.transaction do
+        original_groups = product.options_groups
+        new_groups = options_groups
+        added_groups = new_groups - original_groups
+        removed_groups = original_groups - new_groups
+        puts remove_options_groups_from_product(product, removed_groups)
+        puts add_options_groups_to_product(product, added_groups)
+        return true
+      end
+    end
+
+    def self.createVariants_for_product(product, variants_names)
+      variants_names.each do |vn|
+        v = Variant.new
+        v.name = vn
+        v.product = product
+        product.options_groups.each do |h|
+          v.put_option(h.name, "")
+        end
+        v.save
+      end
+      return product
+    end
+
+
+    def self.convert_params_groups_to_objects(params)
+      options_ids = params
+      options = []
+      options_ids.each do |o_id|
+        o = OptionsGroup.find_by(id: o_id.to_i)
+        (options += [o]) if o
+      end
+      return options
+   end
+  end
+end

data/app/helpers/shoppy/reviews_helper.rb

@@ -0,0 +1,4 @@
+module Shoppy
+  module ReviewsHelper
+  end
+end

data/app/helpers/shoppy/settings_helper.rb

@@ -0,0 +1,5 @@
+module Shoppy
+  module SettingsHelper
+
+  end
+end

data/app/helpers/shoppy/shipments_helper.rb

@@ -0,0 +1,43 @@
+module Shoppy
+  module ShipmentsHelper
+    def self.prepare_shipment(order, order_lines, stock_location, customer_address)
+      if(order.customer_address == customer_address.customer) && ((order_lines - order.orderlines).empty?)
+        Shipment.transaction do
+          s = Shipment.new
+          s.order = order
+          s.stock_location = stock_location
+          s.order_lines = order_lines
+          order_lines.each do |ol|
+            InventoriesHelper::deduct_variant_from_stuck_location(ol.variant, ol.quantity, stock_location)
+          end
+          s.name      = customer_address.customer.name
+          s.phone     = customer_address.customer.phone
+          s.add_line1 = customer_address.add_line1
+          s.add_line2 = customer_address.add_line2
+          s.city      = customer_address.city
+          s.state     = customer_address.state
+          s.country   = customer_address.country
+          s.zip       = customer_address.zip
+          return s.save
+        end
+      else
+        return false
+      end
+    end
+
+    def self.ship_shipment(shipment, tracking_number)
+      s = shipment
+      s.tracking_number = tracking_number
+      s.shipment_date = Date.today
+      s.status = "Shipped"
+      return s.save
+    end
+
+    def self.mark_shipment_delivered(shipment)
+      s = shipment
+      s.status = "Delivered"
+      s.delivery_date = Date.today
+      return s.save
+    end
+  end
+end

data/app/helpers/shoppy/variants_helper.rb

@@ -0,0 +1,4 @@
+module Shoppy
+  module VariantsHelper
+  end
+end

data/app/models/shoppy/admin.rb

@@ -0,0 +1,5 @@
+module Shoppy
+  class Admin < Account
+
+  end
+end

data/app/models/shoppy/brand.rb

@@ -0,0 +1,23 @@
+module Shoppy
+  class Brand < ActiveRecord::Base
+    ## Relationships
+    has_many :products, dependent: :nullify
+
+    has_attached_file :brand_image,
+      :path => ":rails_root/public/uploads/brands/:id_:style_:filename",
+      :url => "/uploads/brands/:id_:style_:filename",
+      :default_url => "/system/no_brand.png"
+
+    ## Validators
+    validates_attachment	:brand_image,
+    						presence: true,
+    						content_type: { content_type: /\Aimage\/.*\Z/ },
+    						size: { less_than: 1.megabyte }
+
+    validates :name, presence: true
+    validates :name, length: { in: 2..100, too_short: "must have at least %{count} letters", too_long: "must have at most %{count} letters" }
+    validates :name, uniqueness: true
+
+
+  end
+end

data/app/models/shoppy/cart_item.rb

@@ -0,0 +1,13 @@
+module Shoppy
+  class CartItem < ActiveRecord::Base
+    ## Relationships
+    belongs_to :customer
+    belongs_to :variant
+
+    ## Validators
+    validates :quantity, presence: true
+    validates :quantity, :numericality => { :greater_than_or_equal_to => 0 }
+
+
+  end
+end

data/app/models/shoppy/category.rb

@@ -0,0 +1,50 @@
+module Shoppy
+  class Category < ActiveRecord::Base
+    ## Relationships
+    belongs_to  :parent_category, class_name: "Category"
+    has_many    :child_categories, class_name: "Category", foreign_key: "parent_category_id", dependent: :nullify
+    has_many    :products, dependent: :nullify
+
+    ## Filters
+    before_save :caps
+
+    ## Validators
+    validates :name, presence: true
+    validates :name, length: { in: 2..100, too_short: "must have at least %{count} letters", too_long: "must have at most %{count} letters" }
+    validates :name, uniqueness: true
+    validate  :parent_is_not_same_category
+
+
+    def breadcrumb
+      bc = [self.id]
+      fbc = "Root -> "
+      c = self
+      while c.parent_category
+        bc.append(c.parent_category.id)
+        c = c.parent_category
+      end
+      bc.reverse.each do |c|
+        fbc += (Category.find(c).name + " -> ")
+      end
+      fbc[0..(fbc.length - 5)]
+    end
+
+    def self.all_sorted
+      self.all.sort_by {|c| c.breadcrumb }
+    end
+
+
+
+
+    private
+    def parent_is_not_same_category
+      if (self.parent_category_id != nil) && (self.parent_category_id == self.id)
+        errors.add(:parent_category, "is same as selected category.")
+      end
+    end
+    def caps
+      self.name = self.name.downcase.titleize
+    end
+
+  end
+end

data/app/models/shoppy/concerns/models/api_token_authenticatable.rb

@@ -0,0 +1,36 @@
+module Shoppy::Concerns::Models::ApiTokenAuthenticatable
+  extend ActiveSupport::Concern
+
+  # For every model that you want to make ApiTokenAuthenticatable,
+  # Add the following attributes to the model:
+    # string    :api_token, null: false, default: ""
+    # datetime  :api_token_expires_at
+    # boolean   :api_token_active, null: false, default: false
+
+
+  def api_token_expired?
+    DateTime.now >= self.api_token_expires_at
+  end
+
+  def valid_api_token?
+    self.api_token_active && !self.api_token_expired?
+  end
+
+
+  def generate_api_token
+    begin
+      self.api_token = SecureRandom.hex
+    end while self.class.exists?(api_token: api_token)
+    self.api_token_expires_at = DateTime.now + 1.day
+    self.api_token_active = true
+    self
+  end
+
+  def invalidate_api_token
+    self.api_token = ""
+    self.api_token_expires_at = Time.now
+    self.api_token_active = false
+  end
+
+
+end

data/app/models/shoppy/concerns/models/hashable.rb

@@ -0,0 +1,60 @@
+module Shoppy::Concerns::Models::Hashable
+  extend ActiveSupport::Concern
+
+  ## For each model that you need to make 'Hashable', make sure
+  ## You have an attribute called 'hash_data' for that model.
+  ## Also, make sure to give that attribute a default value in
+  ## the database that is equal to an empty hash, or '{}'
+  ##
+  ## In simple format, add this field to your migration file:
+  ## # Hashable
+  ## t.hstore :hash_data, null: false, default: {}
+
+
+  # This method will add a key value paid to the model
+  # or update the value of the key, if the key is found
+  # for a given instance of the model
+  def put_hash(key, value)
+    if self.hash_data[key] == nil
+      self.hash_data.merge!({key => value}) unless key == ""
+      self.hash_data_will_change! unless key == ""
+      self
+    else
+      self.hash_data[key] = value unless key == ""
+      self.hash_data_will_change! unless key == ""
+      self
+    end
+  end
+
+  # This mothos will delete the key/value pair for the
+  # give instance, if the key is founf. if not, the command
+  # will be ignored.
+  def delete_hash(key)
+    self.hash_data.delete(key)
+    self.hash_data_will_change!
+    self
+  end
+
+  def empty_hash
+    self.hash_data = {}
+    self.hash_data_will_change!
+    self
+  end
+
+
+  ## These are shared mothods, a.k.a class methods
+  module ClassMethods
+    # Query all model instances that have a given key,
+    # regardless of the valiue for that key.
+    def by_hash_key(key)
+      self.where("hash_data ? :key", key: key)
+    end
+
+    # Query all model instance sthat have a given
+    # key/value pair.
+    def by_hash_key_value(key, value)
+      kv = key + "=>" + value
+      self.where("hash_data @> :kv", kv: kv)
+    end
+  end
+end

data/app/models/shoppy/concerns/models/optionable.rb

@@ -0,0 +1,60 @@
+module Shoppy::Concerns::Models::Optionable
+  extend ActiveSupport::Concern
+
+  ## For each model that you need to make 'Optionable', make sure
+  ## You have an attribute called 'options' for that model.
+  ## Also, make sure to give that attribute a default value in
+  ## the database that is equal to an empty option, or '{}'
+  ##
+  ## In simple format, add this field to your migration file:
+  ## # Optionable
+  ## t.hstore :options, null: false, default: {}
+
+
+  # This method will add a key value paid to the model
+  # or update the value of the key, if the key is found
+  # for a given instance of the model
+  def put_option(key, value)
+    if self.options[key] == nil
+      self.options.merge!({key => value}) unless key == ""
+      self.options_will_change! unless key == ""
+      self
+    else
+      self.options[key] = value unless key == ""
+      self.options_will_change! unless key == ""
+      self
+    end
+  end
+
+  # This mothos will delete the key/value pair for the
+  # give instance, if the key is founf. if not, the command
+  # will be ignored.
+  def delete_option(key)
+    self.options.delete(key)
+    self.options_will_change!
+    self
+  end
+
+  def empty_option
+    self.options = {}
+    self.options_will_change!
+    self
+  end
+
+
+  ## These are shared mothods, a.k.a class methods
+  module ClassMethods
+    # Query all model instances that have a given key,
+    # regardless of the valiue for that key.
+    def by_option_key(key)
+      self.where("options ? :key", key: key)
+    end
+
+    # Query all model instance sthat have a given
+    # key/value pair.
+    def by_option_key_value(key, value)
+      kv = key + "=>" + value
+      self.where("options @> :kv", kv: kv)
+    end
+  end
+end