comment mieux refactoriser deux classes avec beaucoup de logique conditionnelle?

Question

J'ai une classe d'événements qui contient les heures de début et de fin d'un événement. Chaque objet Event peut avoir un nombre d'objets ChildEvent associés représentant chaque récurrence de l'événement parent. Chacune de ces classes doit effectuer une action différente en fonction de la façon dont elles sont éditées, par ex.

Supprimer un seul événement:

• événement: faire le premier enfant, le parent de tous les autres enfants avant de supprimer
• ChildEvent: il suffit de supprimer normalement

Suppression d'un événement et tous postérieurs événements:

• Événement: supprimez tous les événements enfants puis supprimez-le
• ChildEvent: supprimer tous les futurs frères et sœurs, puis supprimer lui-même

édition un seul événement:

• événement: faire le premier enfant, le parent de tous les autres enfants puis mettre à jour
• ChildEvent: mise à jour elle-même comme d'habitude

Modification d'un événement et tous les événements suivants:

• événement: mise à jour tous les événements de l'enfant se met à jour alors
• ChildEvent: mise à jour tous les frères et sœurs à venir se mettre à jour puis

À l'heure actuelle je y parvenir grâce à la vérification des conditions et de prendre des mesures appropriées, mais il commence à devenir désordonné (il y a aussi d'autres conditions avec des comportements associés). Je suis curieux de savoir comment les programmeurs plus expérimentés géreraient cela (j'utilise ruby). Des idées?

Answer 1

sonne comme un cas pour la specification pattern pour encapsuler votre logique

Answer 2

Pourquoi ne pas juste un lien événements, sous la forme d'une liste doublement chaînée?

Un événement aurait un previous et un emplacement next (nul si premier ou dernier d'une chaîne).

Suppression d'un seul événement (delete):

• régler la fente previous de next événement à la fente previous de cet événement
• régler la fente next du previous événement à la fente next de cet événement
• supprimer cet événement

Suppression d'un événement et tous les événements ultérieurs (delete-all):

• Supprimer cet événement
• mis sous next de previous événement à zéro
• récursion sur next événement
• jusqu'à next est nul

Modification d'un seul événement (edit):

• modifier cet événement
• mis sous previous de next événement à previous emplacement de cet événement
• mis next fente previous événement à fente next de cet événement

Modification d'un événement et tous postérieurs événements (edit-all):

• si l'appel initial, mis sous next de previous événement à zéro
• modifier cet événement
• récursion sur next événement
• jusqu'à next est nul

Answer 3

Je suggère d'essayer un modèle d'objet différent. Au lieu de Events et ChildEvents vous pouvez le regarder comme EventType s et Event s.

EventType # Has many Events 
--------- 
name 
# ... 

Event  # Belongs to EventType 
----- 
event_id 
start_time 
end_time 
# ... 

Ensuite, vos opérations d'édition seraient grandement simplifiées.

Trouver l'événement précédent ...

Event.find(:first, :conditions => [ 
    'event_type_id = ? AND start_time > ?', 
    event.type.id, 
    event.start_time], 
    :order => 'ASC' 
) 

Supprimer un événement et tous les événements ultérieurs de ce type ...

events_to_delete = Event.find(:all, 
    :conditions => [ 
    'event_type_id = ? AND start_time >= ?', 
    event.event_type.id, 
    event.start_time 
    ]) 

Event.destroy(all_events_to_delete.map { |event| event.id })