Django: Wie behält man den Überblick über einen linearen (aber flexiblen) Projektmanagement-Workflow?

Question

Ich entwickle eine Projektmanagement-Anwendung in Django, die eine etwas lineare Antwort Prozess mit verschiedenen Gruppen von Benutzern (wie in Django Auth Groups) erfordert. Jeder Schritt im Antwortprozess hat mehrere Antwortoptionen (die meisten Optionen sind einzigartig für den Schritt) und wird einem Benutzer innerhalb einer bestimmten Gruppe zugewiesen. Der nächste Schritt im Prozess wird durch die Antwort des Benutzers bestimmt, und gelegentlich müssen zusätzliche Informationen von einem der Mitglieder des Projekts angefordert werden.

Das Problem ist, dass meine derzeitige Implementierung ziemlich umständlich zu sein scheint, und ich bin sicher, dass es eine bessere Möglichkeit gibt, den Antwortprozess zu verfolgen. Ich hatte gehofft, dass jemand einen Einblick in eine robustere Lösung geben könnte.

Ein einfaches Beispiel ist ein Projekt mit den folgenden Benutzergruppen: Vertriebsmitarbeiter, Vertriebsleiter und Projektleiter. Die Modelle sehen derzeit wie folgt aus:

class Project(models.Model):  
    assigned_to = models.ForeignKey(User, related_name="projects_assigned_to") #Indicates which user needs to respond next.  Will be sales_rep, sales_mgr, or project_mgr.
    sales_rep = models.ForeignKey(User, related_name="sales_rep_projects") #choices limited to "Sales Rep" Group  
    sales_mgr = models.ForeignKey(User, related_name="sales_mgr_projects") #choices limited to "Sales Manager" Group 
    project_mgr = models.ForeignKey(User, related_name="project_mgr_projects") #choices limited to "Project Manager" Group
    current_step = models.ForeignKey(Step, related_name="projects_with_current_step")
    previous_step = models.ForeignKey(Step, related_name="projects_with_previous_step")
    status = models.ForeignKey(Status) #Automatically assigned according to the user's response.  Includes things like "On Track", "On Hold", "Rejected", "Accepted", etc.

class Step(models.Model):
    name = models.CharField(max_length=50) 

class Status(models.Model):
    name = models.CharField(max_length=50) 

Hier ein einfacher Überblick, wie das Verfahren ablaufen könnte:

1. Der Vertriebsmitarbeiter legt ein neues Projekt an und weist es dem Vertriebsleiter zu.
2. Der Vertriebsleiter hat die folgenden Möglichkeiten:
   (a) das Projekt zu genehmigen oder
   (b) weitere Informationen vom Handelsvertreter anfordern
3. Wenn das Projekt genehmigt wird, weisen Sie es dem Projektleiter zu, der dann folgende Optionen hat:
   (a) das Projekt zu beginnen
   (b) das Projekt ablehnen
   (c) weitere Informationen vom Vertriebsmitarbeiter oder Vertriebsleiter anfordern
4. Wenn weitere Informationen von einem Benutzer angefordert werden, wird das Projekt diesem Benutzer zugewiesen, und er muss nur eine Textfeldantwort geben. Sobald die Antwort eingegangen ist, muss das Projekt jedoch zum vorherigen Schritt zurückkehren (daher die obige Aufzeichnung von current_step und previous_step). Wenn in diesem Beispiel der Projektmanager den Vertriebsmitarbeiter um weitere Informationen bittet, sollte das Projekt nach der Antwort des Vertriebsmitarbeiters wieder dem Projektmanager zugewiesen werden, und zwar mit denselben Antwortmöglichkeiten, die er zuvor hatte (annehmen, ablehnen, weitere Informationen anfordern).

Der gesamte Prozess besteht aus etwa 10 Schritten wie diesen.

Erschwerend kommt hinzu, dass ich in der Lage sein muss, die für jeden Schritt gewählte Antwort anzuzeigen. Wenn z. B. der Vertriebsleiter das Projekt genehmigt, sollte "Vertriebsleiter hat das Projekt genehmigt" zusammen mit etwaigen Kommentaren angezeigt werden. Das Modell sieht wie folgt aus:

class Response(models.Model):
    comment = models.TextField()
    response_action = models.ForeignKey(ResponseAction)
    submitted = models.DateTimeField()

class ResponseAction(models.Model):
     """ I.e. 'Sales Manager approved the project', 'Project Manager commenced the project'"""  
     name = models.CharField(max_length=100)

Im Moment ist die Logik für jede Antwortaktion fest in der Ansicht kodiert, und es gibt keine formale Beziehung zwischen einem Schritt und einem anderen. Ich habe das Gefühl, dass es eine bessere Modell- oder Datenstruktur gibt, die ich verwenden sollte, um diesen Workflow zu verfolgen, aber ich arbeite schon so lange mit dem aktuellen System, dass es mir schwerfällt, anders darüber nachzudenken. Jede Einsicht oder Inspiration wäre sehr willkommen! Lassen Sie mich wissen, wenn ich etwas klarstellen muss.

Answer 1

Stärkere Nutzung des Stufenmodells. Sie können es die möglichen nächsten Schritte als Fremdschlüssel speichern lassen. Auf diese Weise können Sie den Ablauf bearbeiten, indem Sie die Daten ändern (z. B. über den Administrator, anstatt sie fest zu kodieren). Vielleicht so etwas wie:

class Step(models.Model):
    name = models.CharField(max_length=50)
    responsible_role = models.CharField(max_length=50) # this contains 'sales_rep', 'sales_mgr' etc
    allowed_actions = models.ManyToManyField('AllowedAction')

class AllowedAction(models.Model):
    name = models.CharField(max_length=50)
    next_step = models.ForeignKey('Step') # the next step, if this action is chosen

Trennen Sie die aktuelle Projekthistorie von einem anderen Modell:

class ProjectHistoryStep(models.Model):
    timestamp = models.DateTimeField()
    step = models.ForeignKey('Step')
    project = models.ForeignKey('Project')  

Sie können dieses Modell verwenden, um den tatsächlichen Fortschritt Ihrer Projekte zu verfolgen (vergessen Sie nicht, dass Modelle eine get_next_by_FOO ).

Sie benötigen nur eine Ansicht, die die gesamte Logik handhabt (sie sollte lediglich eine Methode der Projektklasse aufrufen, um die eigentliche Arbeit zu erledigen) - prüfen Sie, in welchem Zustand sich das Projekt jetzt befindet (letzter ProjectHistoryStep für dieses Projekt) und welche Aktion der Benutzer durchgeführt hat, und handeln Sie entsprechend.