Having two objects in shopping at the same time - ruby-on-rails

Question

Two objects at the same time not one add to my shopping cart. Here is the controller and models :
class PublicController < ApplicationController
before_filter :find_or_create_cart, :only => [:add_to_cart, :show_cart]
def list
#products = Product.sorted.paginate(:per_page => 5 , :page => params[:page])
end
def add_to_cart
product = Product.find(params[:id])
#cart.add_product(product)
redirect_to(:action => 'show_cart')
end
def show_cart
end
private
def find_or_create_cart
#cart=session[:cart]||=Cart.new
end
end
AND the model :
class Cart
attr_reader :items
attr_reader :total_price
def initialize
#items = []
#total_price = 0.0
end
def add_product(product)
#items << LineItem.new_based_on(product)
#total_price += product.price
end
end
Model which come from a join table :
class LineItem < ActiveRecord::Base
belongs_to :order
belongs_to :product
def self.new_based_on(product)
line_item = self.new
line_item.product = product
line_item.quantity = 1
line_item.price = product.price
return line_item
end
end
It is a small application which is supposed to do online shopping, but when I hit the button add to cart this will add two objects (same object) to my shopping cart. Hope someone can help me.

Answer 1

I'll write another answer to address your code, but I felt this might help you.
We've developed our own cart system for one of our apps (you can see at http://firststopcosmeticshop.co.uk) we developed based on Ryan Bates' session models Railscast
How It Works
When using sessions to store cart values, you're basically storing a session var with id's from added cart items. Because you want to keep the session as thin as possible, you'll literally just have an array constructed of product id's:
session[:cart][:products] = [] # -> to init
session[:cart][:products] << product.id # -> builds array like [1,5,6,1,6,4,1,5]
This will allow you to then process the cart as you desire (by reading / manipulating the session[:cart][:products] array). If you test the app I referenced, it should help you see it in action
I mentioned your code is inefficient because you're relying on 3 data sources: LineItem, Cart and PublicController. What you really need is CartController and CartSession for a session-based model. This will allow you to call LineItem from your CartController, making it lean
Code
Our session based cart works like this:
#app/models/cart_session.rb
class CartSession
#Initalize Cart Session
def initialize(session)
#session = session
#session[:cart] ||= {}
end
#Cart Count
def cart_count
if (#session[:cart][:products] && #session[:cart][:products] != {})
#session[:cart][:products].count
else
0
end
end
#Cart Contents
def cart_contents
products = #session[:cart][:products]
if (products && products != {})
#Determine Quantities
quantities = Hash[products.uniq.map {|i| [i, products.count(i)]}]
#Get products from DB
products_array = Product.find(products.uniq)
#Create Qty Array
products_new = {}
products_array.each{
|a| products_new[a] = {"qty" => quantities[a.id.to_s]}
}
#Output appended
return products_new
end
end
#Qty & Price Count
def subtotal
products = cart_contents
#Get subtotal of the cart items
subtotal = 0
unless products.blank?
products.each do |a|
subtotal += (a[0]["price"].to_f * a[1]["qty"].to_f)
end
end
return subtotal
end
end
#app/controllers/cart_controller.rb
class CartController < ApplicationController
include ApplicationHelper
#Index
def index
#items = cart_session.cart_contents
#shipping = Shipping.all
end
#Add
def add
session[:cart] ||={}
products = session[:cart][:products]
#If exists, add new, else create new variable
if (products && products != {})
session[:cart][:products] << params[:id]
else
session[:cart][:products] = Array(params[:id])
end
#Handle the request
respond_to do |format|
format.json { render json: cart_session.build_json }
format.html { redirect_to cart_index_path }
end
end
#Delete
def delete
session[:cart] ||={}
products = session[:cart][:products]
id = params[:id]
all = params[:all]
#Is ID present?
unless id.blank?
unless all.blank?
products.delete(params['id'])
else
products.delete_at(products.index(id) || products.length)
end
else
products.delete
end
#Handle the request
respond_to do |format|
format.json { render json: cart_session.build_json }
format.html { redirect_to cart_index_path }
end
end
end
#config/routes.rb
get 'cart' => 'cart#index', :as => 'cart_index'
post 'cart/add/:id' => 'cart#add', :as => 'cart_add'
delete 'cart/remove(/:id(/:all))' => 'cart#delete', :as => 'cart_delete'
This basically allows you to keep a list of people's cart items in a simple session array. The array then gives you the ability to determine the quantity, product type, brand etc, all from the array. It's the most efficient way, and is what I'd recommend for your app

Answer 2

To address your question directly, I believe you need to do the following:
Routes
#config/routes.rb
resources :cart, only: :index do
post :add # -> allows you to add an item
end
Views
#app/views/cart/index.html.erb
<% for product in #products do %>
<%= product.name %>
<%= product.price %>
<% end %>
Controller
class CartController < ApplicationController
respond_to :html, :json, :js
before_action :cart_init, :only => [:add, :index]
#index should replace show_cart
def index
unless #cart.nil?
#products = Product.find #cart #-> will allow you to find multiple ID's
end
respond_with #products
end
#KISS (Keep It Simple)
def add
#cart << params[:id]
respond_with #cart
end
private
def cart_init
#cart = session[:cart][:products] ||= Cart.new #-> keep products in its own key. Allows you to add [:cart][:shipping] etc
end
end
Model
class Cart
attr_reader :items
attr_reader :total
def initialize
#items = session[:cart][:products] ||= []
#total = 0.0
end
end