问制作一个比萨饼并选择你的配料

EN

require 'active_record'
require 'logger'

ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
ActiveRecord::Base.logger = Logger.new $stdout
ActiveSupport::LogSubscriber.colorize_logging = false

ActiveRecord::Schema.define do
  self.verbose = false

  create_table :pizzas do |t|
    t.string :name
  end

  create_table :pizzas_toppings_groups do |t|
    t.integer :pizza_id
    t.integer :toppings_group_id
  end

  create_table :toppings_groups do |t|
    t.string :name
    t.integer :user_id
  end

  create_table :toppings do |t|
    t.integer :toppings_group_id
    t.string :name
  end

  create_table :orders do |t|
    t.integer :user_id
  end

  create_table :ordered_pizzas do |t|
    t.integer :order_id
    t.string :name
  end

  create_table :ordered_pizza_toppings do |t|
    t.integer :ordered_pizza_id
    t.integer :topping_id
  end
end

class Pizza < ActiveRecord::Base
  has_many :pizzas_toppings_groups
  has_many :toppings_groups, through: :pizzas_toppings_groups
  has_many :toppings, through: :toppings_groups
end

class PizzasToppingsGroup < ActiveRecord::Base
  belongs_to :pizza
  belongs_to :toppings_group
end

class ToppingsGroup < ActiveRecord::Base
  belongs_to :user
  has_many :pizzas_toppings_groups
  has_many :pizzas, through: :pizzas_toppings_groups
  has_many :toppings

  validates :name, presence: true
end

class Topping < ActiveRecord::Base
  belongs_to :toppings_group

  validates :name, presence: true
end

class Order < ActiveRecord::Base
  belongs_to :user
  has_many :ordered_pizzas
end

class OrderedPizza < ActiveRecord::Base
  belongs_to :order

  has_many :ordered_pizza_toppings
  has_many :toppings, through: :ordered_pizza_toppings
end

class OrderedPizzaTopping < ActiveRecord::Base
  belongs_to :ordered_pizza
  belongs_to :topping
end

# admin defines pizzas and available toppings groups and related toppings

cheesy_pizza = Pizza.create(name: "cheeeeeeeese")

cheap_cheesy_group = cheesy_pizza.toppings_groups.create!(name: 'basic cheeses')
mozza = cheap_cheesy_group.toppings.create!(name: 'mozzarella')

fancy_cheesy_group = cheesy_pizza.toppings_groups.create(name: 'fancy cheeses')
goat = fancy_cheesy_group.toppings.create!(name: 'goat')
cheddar = fancy_cheesy_group.toppings.create!(name: 'cheddar')

# imagine there is a fancy user interface where the user can choose 
# toppings from topping groups, but certain groups
# have min/max limits on the toppings you can choose, etc etc
# for now here's a method that
# just takes in chosen toppings, and ties it to the ordered_pizza:
def create_order(pizza:, chosen_toppings:)
  Order.transaction do
    order = Order.create
    ordered_pizza = order.ordered_pizzas.create(name: pizza.name)
    ordered_pizza.toppings << chosen_toppings # imagine this line is lots of complicated validations
    order
  end
end

# user orders a pizza

jims_order = create_order(pizza: cheesy_pizza, chosen_toppings: [mozza, goat])

jims_order.reload

jims_order.ordered_pizzas

# for business reasons, some toppings are no longer available, and are removed.

mozza.destroy
goat.destroy

jims_order.reload
jims_order.ordered_pizzas.first.toppings