La gestion des relations de l'enfant avec une forme d'attribut imbriqué

Question

Ce que je suis en train de faire est la suivante:

À quiconque fois qu'un utilisateur peut avoir 1 profil actif. Ce profil actif doit être autorisée par un administrateur pour vous assurer qu'il est conforme aux règles et règlements du site. Lorsqu'un utilisateur modifie leur profil leur profil public n'est pas affecté jusqu'à ce que le signe administrateur leurs changements. S'ils font un modifier alors que leur profil est à l'examen, les modifications sont appliquées au profil exceptionnel pour examen et est poussé à l'arrière de la file d'attente.

Mes modèles ressemblent à ceci:

class Profile < AR:B
    belongs_to :user
end

class User < AR:B
    has_many :profiles do
        def active
            ...
        end
        def latest
        end
    end
    def profile
        self.profiles.active
    end
end

Il y a une petite touche ... l'utilisateur ne doit pas être en mesure de modifier le profil directement, comme la collection de profils ne sont pas exposés. Au contraire, ils modifier leur utilisateur et les champs de profil, sont projetés.

Quelle est la meilleure façon de gérer cela? Actuellement, je suis en utilisant:

accepts_nested_attributes_for :profiles

Dans l'utilisateur, mais cela semble tout à fait aki. Idéalement la plupart de cette logique vivrais dans le modèle, mais l'autre chose que je flirte avec est l'utilisation d'un présentateur.

Toutes les pensées seraient grandement appréciés, laissez-moi savoir si vous avez besoin de plus d'informations comme commentaire et je vais mettre à jour ce poste de façon appropriée.

Answer 1

Peut-être que vous devriez essayer d'avoir deux relations de l'utilisateur au profil. L'un est celui qu'ils peuvent modifier à travers l'interface utilisateur, et l'autre est celui qui est approuvé par l'administrateur.

Il pourrait travailler quelque chose comme:

class User < AB:B

has_one :profile #the user-editable one one
has_one :active_profile, :class_name=>"profile" #the one shown

end

Chaque modification du profil de l'utilisateur via le formulaire montrerait alors pour l'administrateur (à l'aide et de l'observateur ou peut-être juste et « after_save » filtre). Quand il aproves il, les changements sont ensuite déversés à l'active_profile un, et montré quelque part.

De cette façon, vous pouvez avoir une interface de forme propre, et quand ils le modifient à nouveau, ils voient la dernière (mais pas approuvé) profil. Vous pouvez également commander la file d'attente en utilisant la colonne updated_at pour obtenir les « leurs modifications sont appliquées au profil exceptionnel pour examen et est poussé à l'arrière de la file d'attente » fonctionalité.

Answer 2

J'aller à ce sujet en ayant le modèle de l'utilisateur ont une relation avec deux profils comme suggéré ci-dessus ainsi. Un profil « approuvé », et celui pour l'édition qui va dans la file d'attente d'administration.

Toutefois, afin de gérer les transitions entre « en attente » profils et profils « approuvés » je proposerais en ajoutant éventuellement dans une machine d'état pour gérer les transitions. Le joyau AASM m'a été bonne dans un récent projet. ( http://github.com/rubyist/aasm/tree/master ), et je crois que Rails bord a juste cuit au four droit Machinage Etat aussi bien. ( http://github.com/rails/rails/commit/aad5a30bf25d8a3167afd685fc91c99f4f09cc57 )

Votre modèle pourrait ressembler à ceci:

class User < AR:B

has_one :active_profile 
has_one :pending_profile

include ActiveRecord:: StateMachine

state_machine do
   state :approved
   state :pending
   state :rejected

   event :update_profile_pending do
    transitions :to => :pending, :from => [:approved], :on_transition => :send_to_admin_queue
  end

   event :update_profile_approved do
    transitions :to => :approved, :from => [:pending], :on_transition => :update_current_profile
   end

   event :update_to_rejected do
    transitions :to => :rejected, :from => [:pending]
  end
end

def send_to_admin_queue
  //method to handlesending pending profiles to admin for approval
end

def update_current_profile
 //method to handle updated profiles with changes
end

end

Vous pouvez ensuite appeler le profil User.update en attente! ou un profil User.update approuvé! la transition entre les états de profil et en utilisant les fonctions de rappel de transition pour gérer l'envoi des données d'édition entre le profil actif et un profil en cours.

En ce qui concerne l'utilisation du nested_attributes_for avec votre forme actuelle, je ne pense pas que c'est un hack, je l'ai utilisé aussi bien de mettre à jour les attributs imbriqués et je travaillerais bien. Dans ce cas, si vous ne pouvez pas besoin de trop puisque vous avez 2 profils (une publique, une instance).

Juste une idée! En pensant à haute voix ici!