Ruby on rails ActiveRecord:：HasManyThroughCanAssociateThroughAsOne或AnyReflection错误

我有一份模特工作，有很多申请，也有很多问题。答案既属于申请，也属于问题

我正在尝试创建一个管理员可以用来创建应用程序的工厂方法，而用户无需编写任何东西

为此，我写道--

但是，我得到了错误

#<ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection: Cannot modify association 'Application#questions' because the source reflection class 'Question' is associated to 'Job' via :has_many.>

#

但奇怪的是，我并没有修改问题。我只想为每个问题生成空白答案

我该怎么做呢

完整模型

类作业（同城）办
工作
。包括（：工业）
.包括（：城市）
.包括（：问题）
.包括（：项目符号）
.包括（：角色）
job=job.where（城市：{id:city}）如果城市
工作
结束
范围：带搜索，->（搜索）do
作业=作业。包括（：行业）
.包括（：城市）
.包括（：项目符号）
.包括（：角色）
.包括（：问题）
如果搜索
job=job.where（'jobs.job_title LIKE？'，“%#{search}%”）
结束
工作
结束
范围：与_info一起，->do
工作。包括（：行业）
.包括（：城市）
.包括（：项目符号）
.包括（：角色）
.包括（：问题）
结束
自我构建
job=job.new
2.5倍{
job.bullets.build
job.roles.build
}  
工作、问题、构建
工作
结束
def电位
good_fits=用户。包括（：source，：heat，：applications，common_app:[：cities，：industries]）
.where（'cities.id IN（？）、self.city\u id）
.where（'industries.id IN（？）、self.industry_id）
.where（'users.id不在（？）、self.users.map（&:id））
结束
结束

---

类应用程序do
应用
.包括（：工作）
.包括（：问题）
。包括（：答案）
结束
范围：对于作业，->（作业id）do
应用
.包括（用户：[：来源，：热量，常用应用：[：城市，：行业]]）
.包括（问题：：答案）
.where（'applications.job_id=？'，job_id）
结束
def self.build（作业，appl=Application.new）
job.questions.每个do |问题|
应用答案生成（问题id:question.id）
结束
应用
结束
定义自我生成由管理员（参数）
app=Application.new
app.user\u id=参数[：user\u id]
app.job_id=参数[：job_id]
app.questions.each do|问题|
app.answers.new（问题编号：question.id，内容：“不适用”）
结束
失败
应用程序
结束

结束

类问题

结束

class-Answer

我以写作结束

  def self.make_by_admin(params)
    app = Application.new
    app.user_id = params[:user_id]
    app.job_id = params[:job_id]

    app.questions.pluck(:id).each do |id|
      app.answers.new(question_id: id, content: 'N/A')
    end

    app
  end

---

你能分享问题中的工作、申请、问题和答案吗？

class Job < ActiveRecord::Base
  default_scope { order('jobs.created_at DESC') }

  has_many :bullets, dependent: :destroy, inverse_of: :job
  has_many :roles, dependent: :destroy, inverse_of: :job
  has_many :questions, dependent: :destroy, inverse_of: :job

  has_many :job_city_relations, inverse_of: :job, dependent: :destroy 
  has_many :cities, through: :job_city_relations
  has_many :job_industry_relations, inverse_of: :job, dependent: :destroy
  has_many :industries, through: :job_industry_relations
  has_many :applications, inverse_of: :job, dependent: :destroy
  has_many :users,  through: :applications

  validates :cities, 
    :job_title,
    :job_summary,
    :qualifications,
    :industries,
    :bullets, 
    :roles, 
    :questions, 
    presence: true

  accepts_nested_attributes_for :bullets, 
    reject_if:  :all_blank, 
    allow_destroy:  true

  accepts_nested_attributes_for :roles,
    reject_if: :all_blank, 
    allow_destroy:  true

  accepts_nested_attributes_for :questions, 
    reject_if: :all_blank,
    allow_destroy:  true

  scope :with_cities, ->(city) do
    job =  Job
      .includes(:industries)
      .includes(:cities)
      .includes(:questions)
      .includes(:bullets)
      .includes(:roles)

    job = job.where(cities: { id: city })  if city 

    job
  end

  scope :with_search, ->(search) do
    job = Job.includes(:industries)
      .includes(:cities)
      .includes(:bullets)
      .includes(:roles)
      .includes(:questions)

    if search
      job = job.where('jobs.job_title LIKE ?', "%#{search}%")
    end

    job
  end

  scope :with_info, -> do
    Job.includes(:industries)
       .includes(:cities)
       .includes(:bullets)
       .includes(:roles)
       .includes(:questions)
  end

  def self.build
    job = Job.new

    2.times {
      job.bullets.build
      job.roles.build
    }  

    job.questions.build
    job
  end

  def potentials
    good_fits = User.includes(:source, :heat, :applications, common_app: [:cities, :industries]) 
      .where('cities.id IN (?)', self.city_ids)
      .where('industries.id IN (?)', self.industry_ids)
      .where('users.id NOT IN (?)', self.users.map(&:id))
  end
end

class Application < ActiveRecord::Base  
  STATUS_OPTIONS = ["Application Complete",
    "Materials Submitted",
    "Pending Interview",
    "Second Interview"]

  belongs_to :job, counter_cache: true
  belongs_to :user, counter_cache: true
  has_many :questions, through: :job
  has_many :answers, inverse_of: :application, dependent: :destroy

  validates :job_id, presence: true 
  validates :user_id, presence: true 
  validates :answers, presence: true

  accepts_nested_attributes_for :answers,
   allow_destroy: true, reject_if: :all_blank

  scope :with_dependents, -> do
    Application
       .includes(:job)
       .includes(:questions)
       .includes(:answers)
  end

  scope :for_job, ->(job_id) do
    Application
      .includes(user: [:source, :heat, common_app: [:cities, :industries]])
      .includes(questions: :answer)
      .where('applications.job_id = ?', job_id)
  end

  def self.build(job, appl = Application.new)
    job.questions.each do |question|
      appl.answers.build(question_id: question.id)
    end

    appl
  end

  def self.make_by_admin(params)
    app = Application.new
    app.user_id = params[:user_id]
    app.job_id = params[:job_id]

    app.questions.each do |question|
      app.answers.new(question_id: question.id, content: 'N/A')
    end

    fail
    app
  end

class Question < ActiveRecord::Base
    belongs_to :job
    has_one :answer

class Answer < ActiveRecord::Base
  belongs_to :question
  belongs_to :application
end

  def self.make_by_admin(params)
    app = Application.new
    app.user_id = params[:user_id]
    app.job_id = params[:job_id]

    app.questions.pluck(:id).each do |id|
      app.answers.new(question_id: id, content: 'N/A')
    end

    app
  end