ein Objekt durch tiefe Verschachtelung in Schienen veröffentlichen

Question

Es gibt ein paar von uns arbeiten an einem Web-API, und einer der Moderatoren wollte eine Gemeinschaft haben, die viele Ereignisse hat, und diese Ereignisse haben viele Tickets.

So sieht die Datei routes.rb aus.

Ich habe meine RSpec Anfragen Tests für die Tickets zu arbeiten, alle außer POST.

Hier ist der Tickets Controller

class TicketsController < ApplicationController 

    before_action :set_community, only: [:create] 
    before_action :set_event,  only: [:index, :create] 
    before_action :set_ticket,  only: [:show, :update, :destroy] 

    def index 
    @tickets = @event.tickets 
    render json: @tickets 
    end 

    def create 
    @ticket = @event.tickets.build(ticket_params) 
    if @ticket.save 
     render json: @ticket, status: :created, location: [@community, @event, @ticket] 
    else 
     render json: @ticket.errors, status: :unprocessable_entity 
    end 
    end 


    def show 
    render json: @ticket 
    end 

    def update 
    if @ticket.update(ticket_params) 
     render json: @ticket 
    else 
     render json: @ticket.errors, status: :unprocessable_entity 
    end 
    end 

    def destroy 
    if @ticket.destroy 
     render json: @ticket 
    else 
     render json: @ticket.errors, status: :unprocessable_entity 
    end 
    end 

    private 
    def ticket_params 
    params.require(:ticket).permit(:name, :cost, :quantity, 
           :sale_starts_at, :sale_ends_at) 
    end 

    def set_ticket 
    @ticket = Ticket.find(params[:id]) 
    end 

    def set_event 
    @event = Event.find(params[:event_id]) 
    end 

    def set_community 
    @community = Community.find(params[:community_id]) 
    end 

end 

In der Funktion erstelle ich @event.tickets.build(ticket_params) schrieb, aber ich habe einen Fehler bei der Überprüfung und es wird gesagt ich die Gemeinschaft brauchen.

Ich dachte, @community.event.tickets.build(ticket_params) würde funktionieren, aber ich bekomme eine keine Methode Fehler von @community.

Es ist vielleicht nicht die beste Methode, so tief zu nisten, aber ich frage mich, wie es funktionieren könnte.

Hier sind die Modelle

class Community < ApplicationRecord 
    has_many :events 
    has_many :tickets, through: :event 

    validates :name, presence: true 
    validates :description, presence: true 
end 

class Event < ApplicationRecord 
    belongs_to :community 
    has_many :tickets 

    validates :name, presence: true 
    validates :description, presence: true 
    validates :event_starts_at, presence:true 
    validates :event_ends_at, presence:true 

end 

class Ticket < ApplicationRecord 
    belongs_to :event 
    belongs_to :community 

    validates :name, presence: true 
    validates :cost, presence: true, 
        numericality: { greater_than_or_equal_to: 0 } 
    validates :quantity, presence: true, 
         numericality: { greater_than_or_equal_to: 1 } 
    validates :sale_starts_at, presence: true 
    validates :sale_ends_at, presence: true 
end 

Ich versuchte belongs_to :community, through: :event im Ticket-Modell zu schreiben, aber aus irgendeinem Grund bekomme ich diesen Fehler: ArgumentError: Unknown key: :through. Valid keys are: :class_name, :anonymous_class, :foreign_key, :validate, :autosave, :foreign_type, etc ...

Jede Hilfe wäre toll, Danke im Voraus.

Answer 1

Das Problem ist, dass Sie die Beziehung zwischen Ticket und Community einrichten sollten, um durch events zu gehen, anstatt den Fremdschlüssel zu duplizieren.

class Ticket < ApplicationRecord 
    belongs_to :event 
    has_one :community, through: :event 
end 

Dies verursacht Ereignis als Join-Tabelle zu arbeiten, die eine gute Sache ist nur, da Active Spur einer Fremdschlüsselbeziehung, wenn Sie schaffen Ressourcen aus einer Vereinigung hält.

Der Unterschied zwischen has_one und belongs_to ist, dass belongs_to Orte der Fremdschlüsselspalte auf dieses Modell, während has_one legt sie auf dem anderen Modell. Deshalb ist eine belongs_to through: Beziehung nicht möglich.