NoMethodError when generating new view - ruby-on-rails

I'm working on making a simple app that has users which can have many playlists. I'm trying to render the New view of a playlist but I'm getting this error:
NoMethodError in PlaylistsController#new
undefined method `playlist' for nil:NilClass
def new
#playlist = #user.playlist.new
end
Here's some context:
EDIT: I uploaded the relevant parts of my code to a gist.github:
https://gist.github.com/izikperz/164eab76e64d375d9075
Playlist_controller.rb
class PlaylistsController < ApplicationController
before_action :set_playlist, only: [:show, :edit, :update, :destroy]
:set_user
# GET /playlists
# GET /playlists.json
def index
#playlists = Playlist.all
end
# GET /playlists/1
# GET /playlists/1.json
def show
end
# GET /playlists/new
def new
#playlist = #user.playlist.new
end
# GET /playlists/1/edit
def edit
end
# POST /playlists
# POST /playlists.json
def create
#playlist = #user.playlists.new(playlist_params)
respond_to do |format|
if #playlist.save
format.html { redirect_to #user.playlist, notice: 'Playlist was successfully created.' }
format.json { render :show, status: :created, location: #playlist }
else
format.html { render :new }
#format.json { render json: #playlist.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /playlists/1
# PATCH/PUT /playlists/1.json
def update
respond_to do |format|
if #playlist.update(playlist_params)
format.html { redirect_to #playlist, notice: 'Playlist was successfully updated.' }
format.json { render :show, status: :ok, location: #playlist }
else
format.html { render :edit }
format.json { render json: #playlist.errors, status: :unprocessable_entity }
end
end
end
# DELETE /playlists/1
# DELETE /playlists/1.json
def destroy
#playlist.destroy
respond_to do |format|
format.html { redirect_to playlists_url, notice: 'Playlist was successfully destroyed.' }
format.json { head :no_content }
end
end
private
def set_user
#user = User.find_by(params[:user_id])
end
# Use callbacks to share common setup or constraints between actions.
def set_playlist
#playlist = Playlist.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def playlist_params
params.require(:playlist).permit(:user_id, :title, :img)
end
end
in my routes.rb I have:
resources :users do
resources :playlists
end
My user.rb model:
class User < ActiveRecord::Base
before_save { self.email = email.downcase }
has_secure_password
validates :password, length: { minimum: 6 }
has_many :playlists
end
Playlist.rb model:
class Playlist < ActiveRecord::Base
belongs_to :user, inverse_of: :playlist
validates :user_id, presence: true
end
My database schema:
ActiveRecord::Schema.define(version: 20141105043809) do
create_table "playlists", force: true do |t|
t.string "title"
t.string "img"
t.datetime "created_at"
t.datetime "updated_at"
t.integer "user_id"
end
create_table "users", primary_key: "user_id", force: true do |t|
t.string "name"
t.string "email"
t.datetime "created_at"
t.datetime "updated_at"
t.string "password_digest"
t.string "imgurl"
end
end
Anyone have any ideas?

The #user object in the new action is nil.
undefined method `playlist' for nil:NilClass
This is because params[:user_id] was not sent from your view.
Fix it by chaniging:
new_user_playlist_path(params[:user_id])
to:
new_user_playlist_path(user_id: params[:user_id])
After fixing that, another error will arise in the new action:
#playlist = #user.playlist.new
It should be pluralized as it is in your association:
#playlist = #user.playlists.new
#or
#playlist = #user.playlists.build
Or Simply ignore that:
#playlist = Playlist.new(user_id: #user.id)

Since the ActiveRecord Association between User and Playlist is :has_many and :belongs_to these are many to many associations. This implies that one user has more than one playlists. The association will provide you with a instance method #user.playlists not #user.playlist. Try to use the plural version. It should work.

Make sure that you are sending user_id along with form so that
#user = User.find_by(id: params[:user_id]) is not nil
and then change this
#playlist = #user.playlists.new

Related

RAILS - ActiveModel::MissingAttributeError - Possible issue with how array is being stored?

I'm getting a missing attribute error when trying to automatically create a InvoiceAppCollection when an Invoice is created.
This is the error that I'm getting:
ActiveModel::MissingAttributeError in InvoicesController#create
can't write unknown attribute app_collection_id
From what I've looked up when other people have this issue it has to do with the relationships between the models, but I'm pretty sure that I have the models communicating to each other properly.
The function I wrote to create the invoice app collection is in the invoice controller
def create_invoice_app_collection
InvoiceAppCollection.create(
po_number: #invoice.po_number,
app_collection: #invoice.app_collection
)
end
Here are my models and controllers. I also have the select box where the app_collections are being selected at the bottom.
Here are the Models
class AppCollection < ApplicationRecord
belongs_to :company
acts_as_tenant(:company)
has_many :invoice_app_collections
has_many :invoices, through: :invoice_app_collections
validates :name, uniqueness: true
end
class Invoice < ApplicationRecord
belongs_to :company
acts_as_tenant(:company)
has_many :invoice_app_collections
has_many :app_collections, through: :invoice_app_collections
validates :expiration, on: [:create, :update, :save], :presence => true
end
class InvoiceAppCollection < ApplicationRecord
belongs_to :app_collection
belongs_to :invoice
belongs_to :company
acts_as_tenant(:company)
accepts_nested_attributes_for :app_collection
end
AppCollectionController
class AppCollectionsController < ApplicationController
before_action :set_app_collection, only: %i[ show edit update destroy ]
def index
AppCollections = app_collection.all
end
def create
#app_collection = app_collection.new(app_collection_params)
respond_to do |format|
if #app_collection.save
format.html { redirect_to app_collection_url(#app_collection), notice: "App collection was successfully created." }
format.json { render :show, status: :created, location: #app_collection }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: #app_collection.errors, status: :unprocessable_entity }
end
end
end
def update
respond_to do |format|
if #app_collection.update(app_collection_params)
format.html { redirect_to app_collection_url(#app_collection), notice: "App collection was successfully updated." }
format.json { render :show, status: :ok, location: #app_collection }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: #app_collection.errors, status: :unprocessable_entity }
end
end
end
def destroy
#app_collection.destroy
respond_to do |format|
format.html { redirect_to app_collections_url, notice: "app collection was successfully destroyed." }
format.json { head :no_content }
end
end
private
def set_app_collection
#app_collection = app_collection.find(params[:id])
end
def app_collection_params
params.require(:app_collection).permit(:app_collection_type_id, :name, :company_id)
end
end
InvoicesController
class InvoicesController < ApplicationController
before_action :set_invoice, only: %i[ show edit update destroy ]
prepend_before_action :set_tenant
after_action :create_invoice_app_collection, only: [:create, :update]
def new
#invoice_app_collection = Invoice.new
end
def create
#invoice = Invoice.new(invoice_params)
respond_to do |format|
if #invoice.save
format.html { redirect_to invoice_url(#invoice), notice: "Invoice was successfully created." }
format.json { render :show, status: :created, location: #invoice }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: #invoice.errors, status: :unprocessable_entity }
end
end
end
def update
respond_to do |format|
if #invoice.update(invoice_params)
format.html { redirect_to invoice_url(#invoice), notice: "Invoice was successfully updated." }
format.json { render :show, status: :ok, location: #invoice }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: #invoice.errors, status: :unprocessable_entity }
end
end
end
private
def set_invoice
#invoice = Invoice.find(params[:id])
end
def invoice_params
params.require(:invoice).permit(:company_id, :po_number, :amount, :expiration, {:app_collection_id => []} )
end
def create_invoice_app_collection
InvoiceAppCollection.create(
po_number: #invoice.po_number,
app_collection: #invoice.app_collection
)
end
end
InvoiceAppCollectionsController
class InvoiceAppCollectionsController < ApplicationController
before_action :set_invoice_app_collection, only: %i[ show edit update destroy ]
prepend_before_action :set_tenant
def new
#invoice_app_collection = InvoiceAppCollection.new
end
private
def set_invoice_app_collection
#invoice_app_collection = InvoiceAppCollection.find(params[:id])
end
def invoice_app_collection_params
params.require(:invoice_app_collection).permit(:company_id, :po_number, {:app_collection => []} )
end
end
App Collection being set in the invoice form
<div>
<%= form.label :app_collection, style: "display: block" %>
<label> Select multiple app collections by holding the command key </label>
<%= form.select :app_collection, options_for_select(app_collection.all.map {|a| [a.name, a.name]}),{include_blank: false} , class:"form-select", multiple: true %>
</div>
Schema
create_table "app_collections", charset: "latin1", force: :cascade do |t|
t.integer "app_collection_type_id"
t.string "name"
t.integer "company_id"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
end
create_table "invoice_app_collections", charset: "latin1", force: :cascade do |t|
t.integer "company_id"
t.string "po_number"
t.string "app_collection"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
end
create_table "invoices", charset: "latin1", force: :cascade do |t|
t.integer "company_id"
t.string "po_number"
t.decimal "amount", precision: 10
t.datetime "expiration"
t.string "app_collection"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
end
I believe that the issue is that the app_collection is an array that gets sent to InvoiceAppController so I set it to an array in both controllers and that hasn't fixed it. I also allowed InvoiceAppCollection to accept nested attribues for app_collection but that also isn't fixing it.
I'm not really sure how to resolve this error so any guidance would be very appreciated
Thank you!
I found a small problem, you wrote: #invoice.app_collection, but as your Invoice model is:
class Invoice < ApplicationRecord
has_many :app_collections, through: :invoice_app_collections
end
The code will look for relation belongs_to :app_collection, it required column app_collection_id in your Invoice model, which is not correct in this many-to-many between Invoice and AppCollection. Btw, I think this part {:app_collection_id => []} of invoice_params could raise error when this code Invoice.new(invoice_params) is executed
My suggestion, to update the many-to-many relation:
#invoice.app_collections = AppCollection.where(id: params[:app_collection_ids]) // maybe you will want to update the params structure
#invoice.save
This code will auto-generate correspondant InvoiceAppCollection records.

Moving Line Items from my Cart into an Order to checkout - Ruby on Rails

I followed this tutorial to build a shop with cart functionality. The tutorial ended there though and I am a bit woefully unprepared for this next step. If anyone could give me some direction on this, I would greatly appreciate it.
I currently have products I can add as line_items to a cart. I am unable to figure out how to take those line_items from the cart and pass them into an order. After the order is saved/placed, I want to destroy the cart and start again as the order is being processed.
My guess?: take the line items from the cart as an array/hash and add it to the order, but how?
Rails 6.0.2.2
ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-linux]
rbenv 1.1.2-28-gc2cfbd1
Cart Model
class Order < ApplicationRecord
has_one :cart
# has_many :order_items, dependent: :destroy
# has_many :products, through: :order_items
# def add_cart(cart)
# current_cart = Cart.find(session[:cart_id])
# current_cart.line_items
# end
# def total_price
# line_items.to_a.sum { |item| item.total_price }
# end
end
CurrentCart Concern in Models
module CurrentCart
private
def set_cart
#cart = Cart.find(session[:cart_id])
rescue ActiveRecord::RecordNotFound
#cart = Cart.create
session[:cart_id] = #cart.id
end
end
LineItem Model
class LineItem < ApplicationRecord
belongs_to :product
belongs_to :cart
def total_price
product.price * quantity
end
end
Order Model
class Order < ApplicationRecord
belongs_to :cart
# has_many :order_items, dependent: :destroy
# has_many :products, through: :order_items
# def add_cart(cart)
# current_cart = Cart.find(session[:cart_id])
# current_cart.line_items
# end
# def total_price
# line_items.to_a.sum { |item| item.total_price }
# end
end
Cart Controller
class CartsController < ApplicationController
rescue_from ActiveRecord::RecordNotFound, with: :invalid_cart
#before_action :authenticate_user!, except: [:index, :show]
before_action :set_cart, only: [:show, :edit, :update, :destroy]
# GET /carts
# GET /carts.json
def index
#carts = Cart.all
end
# GET /carts/1
# GET /carts/1.json
def show
end
# GET /carts/new
def new
#cart = Cart.new
end
# GET /carts/1/edit
def edit
end
# POST /carts
# POST /carts.json
def create
#cart = Cart.new(cart_params)
respond_to do |format|
if #cart.save
format.html { redirect_to #cart, notice: 'Cart was successfully created.' }
format.json { render :show, status: :created, location: #cart }
else
format.html { render :new }
format.json { render json: #cart.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /carts/1
# PATCH/PUT /carts/1.json
def update
respond_to do |format|
if #cart.update(cart_params)
format.html { redirect_to #cart, notice: 'Cart was successfully updated.' }
format.json { render :show, status: :ok, location: #cart }
else
format.html { render :edit }
format.json { render json: #cart.errors, status: :unprocessable_entity }
end
end
end
# DELETE /carts/1
# DELETE /carts/1.json
def destroy
#cart.destroy if #cart.id == session[:cart_id]
session[:cart_id] = nil
respond_to do |format|
format.html { redirect_to root_path, notice: 'Cart was successfully destroyed.' }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_cart
#cart = Cart.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def cart_params
params.fetch(:cart, {})
end
def invalid_cart
logger.error "Attempt to access invalid cart #{params[:id]}"
redirect_to root_path, notice: "That cart doesn't exist"
end
end
LineItem Controller
class LineItemsController < ApplicationController
include CurrentCart
before_action :set_line_item, only: [:show, :edit, :update, :destroy]
before_action :set_cart, only: [:create]
# GET /line_items
# GET /line_items.json
def index
#line_items = LineItem.all
end
# GET /line_items/1
# GET /line_items/1.json
def show
end
# GET /line_items/new
def new
#line_item = LineItem.new
end
# GET /line_items/1/edit
def edit
#line_item = LineItem.find(params[:id])
end
# POST /line_items
# POST /line_items.json
def create
product = Product.find(params[:product_id])
#line_item = #cart.add_product(product)
respond_to do |format|
if #line_item.save
format.html { redirect_to #line_item.cart, notice: 'Item added to cart.' }
format.json { render :show, status: :created, location: #line_item }
else
format.html { render :new }
format.json { render json: #line_item.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /line_items/1
# PATCH/PUT /line_items/1.json
def update
respond_to do |format|
if #line_item.update(line_item_params)
format.html { redirect_to #line_item, notice: 'Item was successfully updated.' }
format.json { render :show, status: :ok, location: #line_item }
else
format.html { render :edit }
format.json { render json: #line_item.errors, status: :unprocessable_entity }
end
end
end
# DELETE /line_items/1
# DELETE /line_items/1.json
def destroy
#cart = Cart.find(session[:cart_id])
#line_item.destroy
respond_to do |format|
format.html { redirect_to cart_path(#cart), notice: 'Item successfully removed.' }
format.json { head :no_content }
end
end
def add_quantity
#line_item = LineItem.find(params[:id])
#line_item.quantity += 1
#line_item.save
redirect_to root_url
end
def reduce_quantity
#line_item = LineItem.find(params[:id])
if #line_item.quantity > 1
#line_item.quantity -= 1
end
#line_item.save
redirect_to root_url
end
private
# Use callbacks to share common setup or constraints between actions.
def set_line_item
#line_item = LineItem.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def line_item_params
params.require(:line_item).permit(:product_id)
end
end
OrderController
class OrdersController < ApplicationController
before_action :set_cart, only: [:new, :create]
before_action :set_order, only: [:show, :edit, :update, :destroy]
# GET /orders
# GET /orders.json
def index
#orders = Order.all
end
# GET /orders/1
# GET /orders/1.json
def show
end
# GET /orders/new
def new
#order = Order.new
#order = #cart.line_items
end
# GET /orders/1/edit
def edit
end
# POST /orders
# POST /orders.json
def create
#order = Order.new(order_params)
respond_to do |format|
if #order.save
format.html { redirect_to #order, notice: 'Order was successfully created.' }
format.json { render :show, status: :created, location: #order }
else
format.html { render :new }
format.json { render json: #order.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /orders/1
# PATCH/PUT /orders/1.json
def update
respond_to do |format|
if #order.update(order_params)
format.html { redirect_to #order, notice: 'Order was successfully updated.' }
format.json { render :show, status: :ok, location: #order }
else
format.html { render :edit }
format.json { render json: #order.errors, status: :unprocessable_entity }
end
end
end
# DELETE /orders/1
# DELETE /orders/1.json
def destroy
#order.destroy
respond_to do |format|
format.html { redirect_to orders_url, notice: 'Order was successfully destroyed.' }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_order
#order = Order.find(params[:id])
end
# Only allow a list of trusted parameters through.
def order_params
params.fetch(:order, {})
end
end
Schema
ActiveRecord::Schema.define(version: 2020_04_22_162713) do
create_table "carts", force: :cascade do |t|
t.datetime "created_at", precision: 6, null: false
t.datetime "updated_at", precision: 6, null: false
end
create_table "line_items", force: :cascade do |t|
t.integer "product_id", null: false
t.integer "cart_id", null: false
t.datetime "created_at", precision: 6, null: false
t.datetime "updated_at", precision: 6, null: false
t.integer "quantity", default: 1
t.index ["cart_id"], name: "index_line_items_on_cart_id"
t.index ["product_id"], name: "index_line_items_on_product_id"
end
create_table "orders", force: :cascade do |t|
t.datetime "created_at", precision: 6, null: false
t.datetime "updated_at", precision: 6, null: false
t.integer "cart_id"
t.index ["cart_id"], name: "index_orders_on_cart_id"
end
create_table "products", force: :cascade do |t|
t.string "product_type"
t.datetime "created_at", precision: 6, null: false
t.datetime "updated_at", precision: 6, null: false
t.integer "length"
t.integer "width"
t.decimal "price", precision: 10, scale: 2
t.decimal "depth", precision: 3, scale: 3
end
create_table "themes", force: :cascade do |t|
t.datetime "created_at", precision: 6, null: false
t.datetime "updated_at", precision: 6, null: false
end
create_table "users", force: :cascade do |t|
t.string "email", default: "", null: false
t.string "encrypted_password", default: "", null: false
t.string "reset_password_token"
t.datetime "reset_password_sent_at"
t.datetime "remember_created_at"
t.datetime "created_at", precision: 6, null: false
t.datetime "updated_at", precision: 6, null: false
t.index ["email"], name: "index_users_on_email", unique: true
t.index ["reset_password_token"], name: "index_users_on_reset_password_token", unique: true
end
add_foreign_key "line_items", "carts"
add_foreign_key "line_items", "products"
add_foreign_key "orders", "carts"
end
Routes
Rails.application.routes.draw do
resources :orders
devise_for :users
resources :themes
resources :line_items
# resources :carts
resources :products
# For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
root "themes#index"
get 'carts/:id' => "carts#show", as: "cart"
delete 'carts/:id' => "carts#destroy"
post 'line_items/:id/add' => "line_items#add_quantity", as: "line_item_add"
post 'line_items/:id/reduce' => "line_items#reduce_quantity", as: "line_item_reduce"
post 'line_items' => "line_items#create"
delete 'line_items/:id' => "line_items#destroy"
end
I would recommend trying to seperate Cart and Order by creating another model similar to LineItem and call it something like OrderItem. This new model should have the same attributes of LineItem such as product_id and quantity. You will need to set up as similar belongs_to / has_many relationship here.
You need someway of determining what your current cart is through something like a current_cart helper stored on your session, I would recommend following this video for help on that -it will also take you away from scaffolding which may help you get more control over your code:
https://www.youtube.com/watch?v=rPmlA_T_J84
Equipped with current_cart you could in the OrdersController#create action copy line_items to order_items over like this:
def create
if #order = Order.save(order_params) # this will save the order
current_cart.line_items.each do |line_item|
# using the bang (!) to save to the DB and raise any errors
# rather than failing silently
#order.order_items.create!(
product_id: line_item.product_id,
quantity: line_item.quantity
)
end
redirect_to #order, notice: 'Order was successfully created.'
else
redirect_to root_path, notice: 'Something went wrong saving the order.'
end
end

Article/post drafts in Rails

I am working on a wiki application in Rails that would be publicly editable. I have an articles controller and a drafts controller. When someone clicks 'edit' on an article, I would like to create a new draft with the contents of the original article, and then save that to the database table when the user clicks 'save'. Any ideas on how I might go about doing this? I've been stuck on it for a few days.
Currently, each article belongs_to a category, a subcategory, and has_many drafts.
Database schema:
ActiveRecord::Schema.define(version: 20160723153357) do
create_table "articles", force: :cascade do |t|
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
t.string "title"
t.text "content"
t.integer "category_id"
t.integer "subcategory_id"
end
create_table "categories", force: :cascade do |t|
t.string "name"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
end
create_table "drafts", force: :cascade do |t|
t.string "title"
t.text "content"
t.integer "category_id"
t.integer "subcategory_id"
t.integer "article_id"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
end
create_table "subcategories", force: :cascade do |t|
t.string "name"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
t.integer "category_id"
end
end
Articles_controller:
class ArticlesController < ApplicationController
before_action :set_article, only: [:show, :edit, :update, :destroy]
# GET /articles
# GET /articles.json
def index
if params[:category].blank? && params[:subcategory].blank?
#articles = Article.all.order("created_at DESC")
elsif params[:subcategory].blank?
#category_id = Category.find_by(name: params[:category]).id
#articles = Article.where(category_id: #category_id).order("created_at DESC")
else
#subcategory_id = Subcategory.find_by(name: params[:subcategory]).id
#articles = Article.where(subcategory_id: #subcategory_id).order("created_at DESC")
end
end
# GET /articles/1
# GET /articles/1.json
def show
end
# GET /articles/new
def new
#article = Article.new
end
# GET /articles/1/edit
def edit
end
# POST /articles
# POST /articles.json
def create
#parameters = article_params
#parameters[:category] = Category.find_by(id: Subcategory.find_by(id: article_params[:subcategory_id]).category_id)
#article = Article.new(#parameters)
respond_to do |format|
if #article.save
format.html { redirect_to #article, notice: 'Article was successfully created.' }
format.json { render :show, status: :created, location: #article }
else
format.html { render :new }
format.json { render json: #article.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /articles/1
# PATCH/PUT /articles/1.json
def update
respond_to do |format|
if #article.update(article_params)
format.html { redirect_to #article, notice: 'Article was successfully updated.' }
format.json { render :show, status: :ok, location: #article }
else
format.html { render :edit }
format.json { render json: #article.errors, status: :unprocessable_entity }
end
end
end
# DELETE /articles/1
# DELETE /articles/1.json
def destroy
#article.destroy
respond_to do |format|
format.html { redirect_to articles_url, notice: 'Article was successfully destroyed.' }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_article
#article = Article.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def article_params
params.require(:article).permit(:title,:content,:subcategory_id)
end
end
Drafts_controller:
class DraftsController < ApplicationController
before_action :set_draft, only: [:show, :edit, :update, :destroy]
# GET /drafts
# GET /drafts.json
def index
#drafts = Draft.all
end
# GET /drafts/1
# GET /drafts/1.json
def show
end
# GET /drafts/new
def new
#draft = Draft.new
end
# GET /drafts/1/edit
def edit
end
# POST /drafts
# POST /drafts.json
def create
#parameters = draft_params
#parameters[:article_id] = params[:article_id]
#parameters[:subcategory_id] = 2
#parameters[:category_id] = 2
#draft = Draft.new(#parameters)
respond_to do |format|
if #draft.save
format.html { redirect_to #draft, notice: 'Draft was successfully created.' }
format.json { render :show, status: :created, location: #draft }
else
format.html { render :new }
format.json { render json: #draft.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /drafts/1
# PATCH/PUT /drafts/1.json
def update
respond_to do |format|
if #draft.update(draft_params)
format.html { redirect_to #draft, notice: 'Draft was successfully updated.' }
format.json { render :show, status: :ok, location: #draft }
else
format.html { render :edit }
format.json { render json: #draft.errors, status: :unprocessable_entity }
end
end
end
# DELETE /drafts/1
# DELETE /drafts/1.json
def destroy
#draft.destroy
respond_to do |format|
format.html { redirect_to drafts_url, notice: 'Draft was successfully destroyed.' }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_draft
#draft = Draft.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def draft_params
params.require(:draft).permit(:title, :content)
end
end
Article model:
class Article < ApplicationRecord
belongs_to :category
belongs_to :subcategory
has_many :drafts
end
Draft model:
class Draft < ApplicationRecord
belongs_to :category
belongs_to :subcategory
belongs_to :article
end
I think an approach I would probably follow would be to extract the content information to another table altogether. Here's a rough implementation I could come up with immediately:
class Article < ApplicationRecord
#column_names: ['type:string']
has_many :contents
has_one :current_content, -> { current.or(approved) }, class_name: 'Content'
delegate :title, :content, to: :current_content, allow_nil: true
end
class Content < ApplicationRecord
#column_names: ["article_id:int", "title:string", "content:text", "status:int"]
belongs_to :article
enum status: [:unapproved, :approved, :current]
end
class Draft < Article
#use STI here
end
#services/set_current_article_content.rb
class SetCurrentArticleContent
attr_reader :article, :content
def initialize(article, content)
#article = article
#content = content
end
def call
article.current_content.approved!
content.current!
end
end
#services/edit_wiki_content.rb
class EditWikiContent.rb
attr_reader :article, :content
def initialize(article, content)
#article = article
#content = content
end
def call
article.contents << content
content.save!
end
end
#services/publish_draft.rb
class PublishDraft
attr_reader :draft
def initialize(draft)
#draft = draft
end
def call
draft.becomes!(Article)
end
end
There are three services which would handle the updating and setting of the current content and also publishing the draft, you could add some additional logic in any of them. Also note the condition for the current_content in the article model, your logic might be different from the way I have implemented it.

Add table columns correctly in rails 4

I'm writing a simple rails app which has users,projects and tasks.
And I have the next problem: each user must have his own projects,and each projects must have it's own tasks.When I'm trying to debug my app via console I can see that projects and tasks are created without "user_id" and "project_id".So my DB was configurated incorrectly and because of app doesn't work correctly(columns weren't add to Projects and Tasks tables and because of it app simply can't create projects,that will belong to only one user and tasks which belong to only one project.(and that's the main point of the app)
Can someone help me to deal with my models and migrations,cause I'me really stuck with this stuff
Here are the corresponding models and migrations
Project.rb
class Project < ActiveRecord::Base
belongs_to :user
has_many :tasks, dependent: :destroy
validates :name, presence: true, uniqueness: true
end
User.rb
class User < ActiveRecord::Base
has_many :tasks, through: :projects, dependent: :destroy
has_many :projects, dependent: :destroy
attr_accessor :remember_token
before_save { self.email = email.downcase }
validates :name, presence: true, length: { maximum: 50 }
VALID_EMAIL_REGEX = /\A[\w+\-.]+#[a-z\d\-.]+\.[a-z]+\z/i
validates :email, presence: true, length: { maximum: 255 },
format: { with: VALID_EMAIL_REGEX },
uniqueness: { case_sensitive: false }
has_secure_password
validates :password, presence: true, length: { minimum: 6 }, allow_nil: true
# Returns the hash digest of the given string.
def User.digest(string)
cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST :
BCrypt::Engine.cost
BCrypt::Password.create(string, cost: cost)
end
# Returns a random token.
def User.new_token
SecureRandom.urlsafe_base64
end
# Remembers a user in the database for use in persistent sessions.
def remember
self.remember_token = User.new_token
update_attribute(:remember_digest, User.digest(remember_token))
end
# Returns true if the given token matches the digest.
def authenticated?(remember_token)
return false if remember_digest.nil?
BCrypt::Password.new(remember_digest).is_password?(remember_token)
end
# Forgets a user
def forget
update_attribute(:remember_digest, nil)
end
end
Task.rb
class Task < ActiveRecord::Base
belongs_to :project
end
Migration for creating projects
class CreateProjects < ActiveRecord::Migration
def change
create_table :projects do |t|
t.string :name
t.timestamps null: false
end
end
end
And for creating tasks
class CreateTasks < ActiveRecord::Migration
def change
create_table :tasks do |t|
t.string :name
t.datetime :deadline
t.timestamps null: false
end
end
end
Now when I try to create/update/delete a new task I always get some errors like
Also here are the corresponding controllers,maybe something also wrong there
projects_controller.rb
class ProjectsController < ApplicationController
before_action :find_project!, only: [ :update, :destroy]
# GET /projects
# GET /projects.json
def index
#projects = current_user.projects
#project = Project.new
end
# GET /projects/1
# GET /projects/1.json
def show
end
# GET /projects/new
def new
#project = Project.new
end
# GET /projects/1/edit
def edit
end
# POST /projects
# POST /projects.json
def create
#project = current_user.projects.create(project_params)
respond_to do |format|
if #project.save
format.html { redirect_to home_url }
format.json { render :show, status: :created, location: #project }
else
format.html { render :home_url }
format.json { render json: #project.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /projects/1
# PATCH/PUT /projects/1.json
def update
respond_to do |format|
if #project.update(project_params)
format.html { redirect_to home_url }
format.json { render :show, status: :ok, location: #project }
else
format.html { render :home_url }
format.json { render json: #project.errors, status: :unprocessable_entity }
end
end
end
# DELETE /projects/1
# DELETE /projects/1.json
def destroy
#project.destroy
respond_to do |format|
format.html { redirect_to home_url }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions
def find_project!
#project = current_user.projects.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def project_params
params.require(:project).permit(:name)
end
end
tasks_controller.rb
class TasksController < ApplicationController
before_action :set_task, only: [:show, :edit, :update, :destroy]
# GET /tasks
# GET /tasks.json
def index
#tasks = Task.all
end
# GET /tasks/1
# GET /tasks/1.json
def show
end
# GET /tasks/new
def new
#task = Task.new
end
# GET /tasks/1/edit
def edit
end
# POST /tasks
# POST /tasks.json
def create
#task = #project.tasks.create(task_params)
respond_to do |format|
if #task.save
format.html { redirect_to home_url }
format.json { render :show, status: :created, location: #task }
else
format.html { render :home_url }
format.json { render json: #task.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /tasks/1
# PATCH/PUT /tasks/1.json
def update
respond_to do |format|
if #task.update(task_params)
format.html { redirect_to home_url }
format.json { render :home_url, status: :ok, location: #task }
else
format.html { render :home_url }
format.json { render json: #task.errors, status: :unprocessable_entity }
end
end
end
# DELETE /tasks/1
# DELETE /tasks/1.json
def destroy
current_user.tasks.where(id: params[:task][:task_ids])
respond_to do |format|
format.html { redirect_to home_url }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def task_params
params.require(:task).permit(:name, :position)
end
def find_task!
#task = current_user.tasks.find(params[:id])
end
def find_project!
#project = current_user.projects.find(params[:task][:project_id])
end
end
Add the belongs to in the migrations as well.
class CreateProjects < ActiveRecord::Migration
def change
create_table :projects do |t|
t.string :name
t.belongs_to :user
t.timestamps null: false
end
end
end
class CreateTasks < ActiveRecord::Migration
def change
create_table :tasks do |t|
t.string :name
t.datetime :deadline
t.belongs_to :project
t.timestamps null: false
end
end
end

How to solve NoMethodError for this case?

So my rails app has a number of airport fares defined for each operator, as:
class AirportFare < ActiveRecord::Base
belongs_to :operator
end
class Operator < ActiveRecord::Base
has_many :airport_fares
end
My routes are defined as:
resources :operators do
resources :airport_fares
end
And following is my airport_fares_controller:
class AirportFaresController < ApplicationController
before_action :set_airport_fare, only: [:show, :edit, :update, :destroy]
before_action :set_operator
# GET /airport_fares
# GET /airport_fares.json
def index
#operator = Operator.find(params[:operator_id])
#airport_fares = Operator.find(params[:operator_id]).airport_fares
end
# GET /airport_fares/1
# GET /airport_fares/1.json
def show
end
# GET /airport_fares/new
def new
#airport_fare = Operator.find(params[:operator_id]).airport_fares.build
end
# GET /airport_fares/1/edit
def edit
end
# POST /airport_fares
# POST /airport_fares.json
def create
#airport_fare = Operator.find(params[:operator_id]).airport_fares.build(airport_fare_params)
respond_to do |format|
if #airport_fare.save
format.html { redirect_to #airport_fare, notice: 'Airport fare was successfully created.' }
format.json { render :show, status: :created, location: #airport_fare }
else
format.html { render :new }
format.json { render json: #airport_fare.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /airport_fares/1
# PATCH/PUT /airport_fares/1.json
def update
respond_to do |format|
if #airport_fare.update(airport_fare_params)
format.html { redirect_to #airport_fare, notice: 'Airport fare was successfully updated.' }
format.json { render :show, status: :ok, location: #airport_fare }
else
format.html { render :edit }
format.json { render json: #airport_fare.errors, status: :unprocessable_entity }
end
end
end
# DELETE /airport_fares/1
# DELETE /airport_fares/1.json
def destroy
#airport_fare.destroy
respond_to do |format|
format.html { redirect_to operator_airport_fares_path(operator_id: #operator.id), notice: 'Airport fare was successfully destroyed.' }
format.json { head :no_content }
end
end
private
# Use callbacks to share common setup or constraints between actions.
def set_operator
#operator = Operator.find(params[:operator_id])
end
def set_airport_fare
#airport_fare = AirportFare.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
def airport_fare_params
params.require(:airport_fare).permit(:cabcat, :triptype, :triptime, :basedist, :basehr, :basechrg, :ratepkm, :waitingbtime, :waitingchrg, :notes, :operator_id)
end
end
My db schema says:
create_table "airport_fares", force: true do |t|
t.string "cabcat"
t.string "triptype"
t.string "triptime"
t.decimal "basedist", precision: 8, scale: 2
t.integer "basehr"
t.decimal "basechrg", precision: 8, scale: 2
t.decimal "ratepkm", precision: 8, scale: 2
t.integer "waitingbtime"
t.decimal "waitingchrg", precision: 8, scale: 2
t.text "notes"
t.datetime "created_at"
t.datetime "updated_at"
t.integer "operator_id"
end
The problem is when I try this in my console: AirportFare.first.operator. This leads to the error:
NoMethodError: undefined method 'operator' for #<AirportFare>.
Where is the problem?
In new action you should do:
def new
#operator = Operator.find(params[:operator_id])
#airprot_fare = AirportFare.new
end
in your form:
<%= form_for [#operator, #airport_fare] do |f| %>
This should work.
It Should be operator.first.airport_fares. As you have has_many relationship on operators

Resources