Valider l'unicité de l'association

Donné les classes suivantes:

class Candidate
  has_many :applications
  has_many :companies, :through => :job_offers
end

class JobOffer
  belongs_to :company
end

class Application
  belongs_to :candidate
  belongs_to :job_offer
end

Comment puis-je valider la déclaration précédente (dans l'image) sur les Rails?

L'ajout de la suite de la validation de l'Application ne fonctionne pas quand la mise à jour:

def validate_uniqueness_of_candidate_within_company
  errors.add(:job_offer_id, "...") if candidate.companies.include?(company)
end

Cause lorsque vous tentez de modifier l'application à un autre JobOffer de la même entreprise candidate.les entreprises sera de retour cette société.

J'ai aussi essayé de faire quelque chose de ce genre sur Demande:

validates_uniqueness_of :user_id, :scope => {:job_offer => :company_id}

Mais il ne fonctionne pas non plus.
Toutes les idées pour résoudre ce sans avoir à utiliser de 10 lignes de code de merde?

Existe-il des meilleures solutions disponibles maintenant?

OriginalL'auteur user1163964 | 2012-01-22

ruby-on-rails ruby-on-rails-3

14

Il y a probablement de nombreuses approches pour résoudre votre problème, mais je pense que la ligne de fond est que vous essayez de faire respecter une contrainte d'unicité sur la table qui n'est pas (directement) ont tous les attributs (les deux company ET user). J'avais de normaliser la company info dans le tableau d'application (user_id, job_offer_id, company_id) et toujours le mettre dans un before_save de rappel pour correspondre à la job_offer's company. Ensuite, vous devriez être en mesure d'utiliser l'étendue de l'unicité de validation:
```
class JobApplication < ActiveRecord::Base
  belongs_to :user
  belongs_to :job_offer
  belongs_to :hiring_company, :class_name=>"Company", :foreign_key=>"company_id"

  before_save :set_hiring_company

  def set_hiring_company
   self.hiring_company = job_offer.hiring_company
  end

  validates_uniqueness_of :user_id, :scope => :company_id
end
```
Votre réponse est correcte. Si je ne veux pas de normaliser les données juste pour une simple validation.. Merci bien! D'autres idées?
Vous pourriez avoir différentes validations terme :sur=>:créer que :=>:mise à jour, mais je pense toujours que tu finiras encerclant autour de pour avoir l'attribut dans la table de jointure. Je serais intéressé de voir d'autres solutions de moi-même donc j'espère que quelqu'un d'autre carillons. Pour moi, c'était la solution la plus simple (sans 10 lignes de beurk) 😉 Bonne chance.

OriginalL'auteur miked
0

c'est comment je vais structurer les modèles:
```
class Candidate
  has_many :applicatons
  has_many :job_offers
  has_many :offering_companies, :through => :job_offers
end

class Application
  belongs_to :candidate
end

class JobOffer
  belongs_to :candidate
  belongs_to :company

  validates_uniqueness_of :candidate_id, :scope => :company_id
end

class Company
end
```
Cela devrait fonctionner!
Btw. Je vais appeler l'application de quelque chose d'autre pour éviter la confusion de dénomination( rails dispose déjà d'application.rb

Pourquoi le JobOffer belong_to un candidat.. L'offre d'emploi n'appartient qu'à la société.. je pense que vous avez mal compris le schéma de l'image. Merci pour votre réponse!

OriginalL'auteur ez.
0

Que les points de l'image, une candidature et une offre d'emploi ont de nombreuses applications & un candidat ne peut postuler à une offre d'emploi par entreprise. Ainsi, la validation de l'unicité du candidat, d'une portée à une offre d'emploi en application pourrait le faire.
```
class Candidate
  has_many :applications
  has_many :job_offers, :through => :applications
end

class JobOffer
  belongs_to :company
  has_many :applications
  has_many :candidates, :through => :applications
end

class Application
  belongs_to :candidate
  belongs_to :job_offer

  validates_uniqueness_of :candidate_id, :scope => :job_offer_id
end
```
Cela permettra d'éviter une application à être associés à la même candidat pour la même offre d'emploi. Le candidat peut s'appliquer à d'autres offres d'emplois, pas vrai?

Et comme l'a souligné @ez., renommage de l'application pour que quelque chose est mieux.

Espère que cette aide.

Ce n'est pas tout à fait droit. Comme l'a dit sur la photo, un candidat ne peut pas s'appliquer aux 2 offres d'emploi de la même société.. Cela ne fera qu'empêcher le candidat d'appliquer à la même offre deux fois..

OriginalL'auteur prasvin

Pour quiconque de découvrir aujourd'hui. La réponse est à vérifier quand il y a des pré-existants (empêche plusieurs) & ignorer lors de l'application elle-même est de commutation.

def validate_uniqueness_of_candidate_within_company
  pre_existing = Application.includes(:candidate).includes(job_offer: :company).
    where(companies: { id: self.company.id }).
    where(candidates: { id: self.candidate.id })

  if pre_existing.present? && (!pre_existing.map(&:id).include? self.id)
    errors.add(:job_offer_id, "...")
  end
end

OriginalL'auteur nitsujri

Vous devez vous connecter pour publier un commentaire.