将select_tag列表限制为仅属于rails中另一个对象的对象

Question

我拥有属于学校和学校has_many教室的教室列表。我有属于一所学校的用户并填写了一些信息。在这种形式，我有以下选择：

引脚/ _form.html.erb

<div class="form-group"> 
    <%= label_tag(:classroom, "Select your classroom:") %> 
    <%= select_tag "pin[code]", options_from_collection_for_select(Classroom.all, "code", "code",) %> 
    </div> 

眼下这种形式显示在数据库中列出的所有教室。我需要它来展示属于学校的教室。教室有一个名字和一个代码，代码就是将学生提交的表单与课堂联系起来。

我仍然在学习RoR，并且一直努力在这种情况下找出这类问题。

这里的课堂控制器

class ClassroomsController < ApplicationController 
    before_action :set_classroom, only: [:show, :edit, :update, :destroy] 
    after_action :verify_authorized 
    respond_to :html 
def home 
    @classrooms = Classroom.all 
    respond_with(@classrooms) 
    authorize @classrooms 
end 
def index 
    @classrooms = Classroom.all 
    respond_with(@classrooms) 
    authorize @classrooms 
end 

def show 
    respond_with(@classroom) 
end 

def new 
    @school = School.find(params[:school_id]) 
    @classroom = @school.classrooms.new 
    @teachers = @school.teachers 
    respond_with(@classroom) 
    flash[:notice] = "Classroom created." 
    authorize @classroom 
end 

def edit 
end 

def create 
    @school = School.find(params[:school_id]) 
    @classroom = @school.classrooms.new(classroom_params) 
    @classroom.save 
    respond_with @school 
    authorize @classroom 
end 

def update 
    @classroom.update(classroom_params) 
    respond_with([@school,@classroom]) 
end 

def destroy 
    @classroom.destroy 
    redirect_to @school 
    flash[:notice] = "You have succesfully deleted the classroom." 
end 

    private 
    def set_classroom 
    @classroom = Classroom.find(params[:id]) 
    @school = School.find(params[:school_id]) 
    authorize @classroom 
    end 

    def classroom_params 
    params.require(:classroom).permit(:teacher_id, :name, :code) 
    end 
end 

Pins_controller

class PinsController < ApplicationController 
before_action :set_pin, only: [:show, :edit, :update, :destroy] 
    respond_to :html 

def show 
    respond_with(@pin) 
end 

def new 
    @pin = Pin.new 
    @emotions = Emotion.all 
    @causes = Cause.all 
    @school = School.find(params[:school]) 
    @classrooms = @school.classrooms 
    respond_with(@pin) 
    authorize @pin 
end 

def edit 
end 

def create 
    code = params[:pin][:code] 
    @classroom = Classroom.where('code LIKE ?', code).first 
    unless @classroom 
    flash[:error] = "Classroom code incorrect" 
    @emotions = Emotion.all 
    @causes = Cause.all 
    render :new 
    else 
    params[:pin][:classroom_id] = @classroom.id 

    @pin = Pin.new(pin_params) 
    @pin.save 
     params[:pin][:cause_ids].each do |cause_id| 
     @cause = Cause.find(cause_id) 
     @pin.causes << @cause 
    end 
    params[:pin][:emotion_ids].each do |emotion_id| 
     @emotion = Emotion.find(emotion_id) 
     @pin.emotions << @emotion 
    end 



    if @pin.save 
     redirect_to signout_path and return 
    end 
    respond_with(@pin) 
    authorize @pin 
    end 
end 


def update 
    @pin.update(pin_params) 
    respond_with(@pin) 
    authorize @pin 
end 

def destroy 
    @pin.destroy 
    respond_with(@pin) 
    authorize @pin 
end 

private 
    def set_pin 
    @pin = Pin.find(params[:id]) 
    authorize @pin 
    end 

def pin_params 
    params.require(:pin).permit(:user_id, :question, :question1, :question2, 
    :question3, :question4, :question5, :classroom_id, :sad, 
    :happy, :mad, :brave, :embarrassed, :sorry, :frustrated, 
    :silly, :left_out, :excited, :hurt, :jealous, :confused, 
    :proud, :other) 
    end 

末

School.rb模型

class School < ActiveRecord::Base 
    has_many :users 
    has_many :classrooms 

    validates_uniqueness_of :code 

    def classrooms 
    self.users.classrooms 
    end 


    def students 
    self.users.students 
    end 

    def teachers 
    self.users.teachers 
    end 

    def admins 
    self.users.admins 
    end 
end 

用户模型

class User < ActiveRecord::Base 
    devise :timeoutable, :database_authenticatable, :registerable, 
    :recoverable, :rememberable, :trackable, :validatable 

    has_many :pins 
    has_many :reflections 
    has_many :classrooms, :foreign_key => :teacher_id 
    belongs_to :school 

    validates :name, presence: true 
    validates :role, presence: true 
# validates :school, presence: true 

    scope :students, -> { where(role: "student") } 
    scope :teachers, -> { where(role: "teacher")} 
    scope :teachers_and_admins, -> { where(:role => ["teacher", "admin"]) } 
    scope :admins, -> { where(role: "admin") } 
    scope :online, lambda{ where("updated_at > ?", 15.days.ago) } 
    def online? 
    updated_at > 15.days.ago 
    end 

    def admin? 
    role == "admin" 
    end 

    def teacher? 
    role == "teacher" 
    end 

    def student? 
    role == "user" || role == "student" 
    end 

def superadmin? 
    role == "superadmin" 
end 

def admin_of_school?(school) 
    self.admin? && self.school == school 
end 

def teacher_of_school?(school) 
    self.teacher? && self.school == school 
end 

def admin_or_teacher_of_school?(school) 
    self.admin_of_school?(school) || self.teacher_of_school?(school) 
end 

end 

课堂模式

class Classroom < ActiveRecord::Base 

    belongs_to :school 
    belongs_to :teacher, :class_name => "User" 
    has_and_belongs_to_many :users 

    has_many :pins 
    has_many :reflections 

    validates_presence_of :school 
    validates_presence_of :teacher 
    validates :code, :uniqueness => { :scope => :school_id } 


end 

我发现了一个类似的答案在这里：Rails only give records that "belong_to"

但它并没有帮助我了解如何将下拉列表限制为仅当前学校的教室。

关于如何处理他的情况的任何想法？

Answer 1

您已经选择在控制器中的学校，所以只用它的观点，而不是做一个Classroom.all做@school.classrooms

<%= select_tag "pin[code]", 
    options_from_collection_for_select(@school.classrooms, "code", "code") 
%> 

---

这部分是不是一个答案，但改进和修复了代码

首先，用户模型可以留下，因为它是

class User < ActiveRecord::Base 
    #devise place holder 

    # assocciations 
    has_many :pins 
    has_many :reflections 
    has_many :classrooms, foreign_key: :teacher_id 
    belongs_to :school 

    #validations place holder 

    #scopes 
    scope :students, -> { where(role: "student") } 
    scope :teachers, -> { where(role: "teacher")} 
    scope :admins, -> { where(role: "admin") } 
    scope :teachers_and_admins, -> { teachers.admins } 
    scope :online, -> { where("updated_at > ?", 15.days.ago) } 

    # some check methods 
end 

教室类

class Classroom < ActiveRecord::Base 
    belongs_to :school 
    belongs_to :teacher, ->{ User.teachers }, class_name: 'User' 

    has_many :pins 
    has_many :reflections 
end 

学校班级

class School < ActiveRecord::Base 
    has_many :users 
    has_many :admins, ->{ User.admins }, class: User 
    has_many :students, ->{ User.students }, class: User 
    has_many :teachers, ->{ User.teachers }, class: User 
    has_many :classrooms 
end 

现在控制器

你需要清理重复，所以这里是从乌尔pins#new行动为例

def new 
    @pin = Pin.new 
    prepare_lookups 
    respond_with(@pin) 
    authorize @pin 
end 

def prepare_lookups 
    @emotions = Emotion.all 
    @causes = Cause.all 
    @school = School.find(params[:school]) 
    @classrooms = @school.classrooms 
end 

我删除了一个通用的代码parate方法，并随时调用它，当然，您可以根据需要添加或删除该方法。

不管怎么说，我认为你应该阅读更多关于active record assocciations并书面控制器操作的惯例