Erstellen Sie Ihr Startup mit PHP: Planen der Verfügbarkeit und Auswahlmöglichkeiten

() translation by (you can also view the original English article)

Final product image — What You'll Be Creating

Dieses Tutorial ist Teil der Reihe Building Your Startup With PHP auf Tuts+. In dieser Serie führe ich Sie durch den Start eines Startups vom Konzept zur Realität anhand meiner Meeting Planner-App als Beispiel aus dem wirklichen Leben. Bei jedem Schritt auf dem Weg werde ich den Meeting Planner-Code als Open Source-Beispiele veröffentlichen, aus denen Sie lernen können. Ich werde auch auf geschäftliche Probleme im Zusammenhang mit Startups eingehen, sobald diese auftreten.

Der gesamte Code für Meeting Planner ist im Yii2 Framework für PHP geschrieben. Wenn Sie mehr über Yii2 erfahren möchten, lesen Sie meine parallele Serie Programmieren mit Yii2 bei Tuts+. Vielleicht möchten Sie auch auf meiner Knowledge Base-Website nach Yii2-Fragen suchen, The Yii2 Developer Exchange.

Die Codierung für die Zeitplan-Besprechungsfunktion erstreckt sich über mindestens vier Episoden. Dies ist die zweite dieser vier Folgen, in der AJAX zur Planungsseite hinzugefügt wird, damit Benutzer ihre Verfügbarkeit festlegen und Orte, Daten und Zeiten auswählen können. Wenn Sie das vorherige Tutorial zum Planen eines Meetings verpasst haben, lesen Sie es bitte zurück, bevor Sie fortfahren.

Im nächsten Tutorial werden wir uns mit der Zustellung der Besprechungsanfrage per E-Mail befassen. Wir werden später zurückkehren, um die Benutzeroberfläche zu optimieren und zu verbessern, da dies für den Erfolg dieses Produkts von entscheidender Bedeutung ist.

Anzeigen der Verfügbarkeit aus der Datenbank

Die Ansicht des Besprechungsplans war relativ komplex zu codieren. Das visuelle Layout der Tabellenspalten hängt nicht direkt mit der Art und Weise zusammen, wie wir die zugehörigen Daten in unserer Datenbank und in unserem Schema speichern. Glücklicherweise verfügt jede Besprechung nicht über einen großen Datensatz mit Optionen für Ort und Datum und Uhrzeit, sodass dies kein besonderes Leistungsproblem darstellt.

In unserem Schema wird die Verfügbarkeit von Plätzen für Organisatoren und Teilnehmer (d. h. Ob ein Platz für diese Besprechung für sie akzeptabel ist) in der Tabelle MeetingPlaceChoice gespeichert. Unter Verwendung unseres relationalen Modells verfügt jedes Meeting über viele MeetingPlaces mit vielen MeetingPlaceChoices.

Verwechseln Sie die MeetingPlaceChoice-Tabelle nicht mit der endgültigen Auswahl für einen Ort, der im MeetingPlace->status gespeichert ist.

Die oben gezeigte Tabelle wird anders angezeigt, wenn der Veranstalter sie anzeigt:

Platz 1 | Veranstalter | Teilnehmer | MeetingPlace.choice
Platz 2 | Veranstalter | Teilnehmer | MeetingPlace.choice

Ab wann der Teilnehmer es sieht:

Platz 1 | Teilnehmer | Veranstalter | (kann vielleicht MeetingPlace.choice machen)
Platz 2 | Teilnehmer | Veranstalter | (kann vielleicht MeetingPlace.choice machen)

Lassen Sie uns nun diskutieren, wie diese Tabellen in den Ansichten implementiert werden.

Anzeigen einer Tabelle mit Bootstrap

Im Moment habe ich mich dafür entschieden, jeden Bereich anzuzeigen, z. Ort oder Datum und Uhrzeit in einem eigenen Bootstrap-Bereich mit Tabellen.

In \frontend\views\meeting\view.php sehen Sie die Aufnahme für das Places-Bedienfeld wie folgt:

1	<?= $this->render('../meeting-place/_panel', [
2	'model'=>$model,
3	'placeProvider' => $placeProvider,
4	]) ?>

Hier ist ein Teil der Panel-Ansichtsdatei für den meeting-place. Dies richtet das Tabellenraster ein und enthält ein Listenansicht-Widget zum Anzeigen der Zeilen:

<?php
use yii\helpers\Html;
use yii\widgets\ListView;
?>
<div class="panel panel-default">
  <!-- Default panel contents -->
  <div class="panel-heading">
    <div class="row">
      <div class="col-lg-6"><h4><?= Yii::t('frontend','Places') ?></h4></div>
      <div class="col-lg-6" ><div style="float:right;"><?= Html::a('', ['meeting-place/create', 'meeting_id' => $model->id], ['class' => 'btn btn-primary glyphicon glyphicon-plus']) ?></div>
    </div>
  </div>
  </div>

  <?php
   if ($placeProvider->count>0): 
  ?>
  <table class="table">
     <thead>
     <tr class="small-header">
       <td></td>
       <td ><?=Yii::t('frontend','You') ?></td>
        <td ><?=Yii::t('frontend','Them') ?></td>
        <td >
          <?php
           if ($placeProvider->count>1) echo Yii::t('frontend','Choose');
          ?>    </tr>
    </thead>
    <?= ListView::widget([ 
           'dataProvider' => $placeProvider, 
           'itemOptions' => ['class' => 'item'], 
           'layout' => '{items}',
           'itemView' => '_list',
           'viewParams' => ['placeCount'=>$placeProvider->count],
       ]) ?>
  </table>
    
  <?php else: ?>
  <?php endif; ?>

</div>

Schauen wir uns die Listenansicht des meeting-place genauer an.

Anzeigen der Zeilen mit Bootstrap-Switch-Widgets

In der Yii-Listenansicht wird für jeden Ort eine Datenzeile angezeigt. Der Code funktioniert für Datums- und Uhrzeitangaben nahezu identisch.

Ich verwende Krajees Yii2 Switch Input Widget für den Bootstrap Switch anstelle langweiliger Kontrollkästchen und Kombinationsfelder:

Ich mag die Art und Weise, wie die Drei-Status-Option es uns ermöglicht, den Teilnehmern einen eindeutigen Status anzuzeigen, bevor sie eine Auswahl treffen. Außerdem können wir dem Veranstalter zeigen, dass der Teilnehmer noch keine Auswahl getroffen hat.

Lassen Sie uns Spalte für Spalte durch den Code gehen. Hier ist das Place-Panel und die Tabelle, die wir implementieren:

Die Platzspalte

In der ersten Spalte verwende ich den Yii-HTML-Link-Helfer, um den Namen des Ortes mit seiner eigenen Ansichtsseite zu verknüpfen. Beachten Sie, wie wir den Orts-Slug verwenden.

<?php
use yii\helpers\Html;
use yii\helpers\BaseUrl;
use \kartik\switchinput\SwitchInput;

?>

<tr > 
  <td style >
        <?= Html::a($model->place->name,BaseUrl::home().'/place/'.$model->place->slug) ?>
  </td>

Die Organizer-Spalte

Um die Auswahl des Organisators zu finden, durchlaufen wir das Array von MeetingPlaceChoices und ordnen user_id der meeting->owner_id zu:

  <td style>
      <?
      foreach ($model->meetingPlaceChoices as $mpc) {
        if ($mpc->user_id == $model->meeting->owner_id) {
            if ($mpc->status == $mpc::STATUS_YES)
              $value = 1;
            else
              $value =0;              
            echo SwitchInput::widget([
            'type'=>SwitchInput::CHECKBOX,
            'name' => 'meeting-place-choice',
            'id'=>'mpc-'.$mpc->id,          
            'value' => $value,
            'pluginOptions' => ['size' => 'mini','onText' => '<i class="glyphicon glyphicon-ok"></i>','offText'=>'<i class="glyphicon glyphicon-remove"></i>','onColor' => 'success','offColor' => 'danger',],
            ]);          
        }
      }      
      ?>
     </td>

Zur Auswahl Ihrer Verfügbarkeit an einem bestimmten Ort verwenden wir den Kontrollkästchenmodus des Schaltereingangs, d. H. Dieser Ort funktioniert für Sie (ein) oder nicht (aus).

Die value-Eigenschaft setzt den Schalter beim Laden. Die ID, die der MeetingPlaceChoice->id entspricht, wird für AJAX unten verwendet, um diesen bestimmten Switch zu identifizieren.

Möglicherweise stellen Sie auch fest, dass wir anstelle von Beschriftungen Glyphicons für Ja und Nein verwenden.

Die Teilnehmerspalte

Der Code für den Teilnehmer implementiert Drei-Zustands-Schalter. d.h. dieser Ort funktioniert für Sie (ein), er funktioniert nicht (aus) oder Sie haben noch nicht angegeben (unbestimmt):

<td style>
    <?
  foreach ($model->meetingPlaceChoices as $mpc) {
    if (count($model->meeting->participants)==0) break;    
    if ($mpc->user_id == $model->meeting->participants[0]->participant_id) {
        if ($mpc->status == $mpc::STATUS_YES)
          $value = 1;
        else if ($mpc->status == $mpc::STATUS_NO)
          $value =0;
        else if ($mpc->status == $mpc::STATUS_UNKNOWN)
          $value =-1;
        echo SwitchInput::widget([
          'type'=>SwitchInput::CHECKBOX,         
          'name' => 'meeting-place-choice',
          'id'=>'mpc-'.$mpc->id,          
          'tristate'=>true,
          'indeterminateValue'=>-1,
          'indeterminateToggle'=>false,
          'disabled'=>true,
          'value' => $value,
          'pluginOptions' => ['size' => 'mini','onText' => '<i class="glyphicon glyphicon-ok"></i>','offText'=>'<i class="glyphicon glyphicon-remove"></i>','onColor' => 'success','offColor' => 'danger'],
      ]);          
    }
  }
    ?>
  </td>

Wenn wir Unterstützung für Besprechungen hinzufügen, bei denen der Teilnehmer Orte und Datums- und Uhrzeitangaben vorschlagen kann, fügen wir der Organisator-Spalte auch Widgets mit drei Status hinzu.

Anzeigen des Schalters "Ort und Datum auswählen"

Wenn der Veranstalter das Meeting anzeigt, können er den endgültigen Ort und die Uhrzeit des Meetings auswählen. In Kürze werden wir auch Unterstützung für Besprechungen hinzufügen, damit der Teilnehmer diese auswählen kann.

In diesem Fall trifft der Benutzer eine zeilenübergreifende Auswahl (Auswahl einer der aufgelisteten Stellen). Dies erfordert, dass wir den Schaltereingang im Optionsfeldmodus verwenden. Bei den AJAX-Ereignissen für die Auswahl können wir nur die Eigenschaft name abhören - es wird keine ID benötigt, da nur eine Auswahl für das Panel möglich ist.

Ich wollte auch, dass der Auswahlschalter anders aussieht als die Verfügbarkeitsschalter, also habe ich sie breiter gemacht und verschiedene Farben verwendet.

  <td style>    
      <?
      if ($placeCount>1) {
        if ($model->status == $model::STATUS_SELECTED) {
            $value = $model->id;
        }    else {
          $value = 0;        
        } 
        echo SwitchInput::widget([
          'type' => SwitchInput::RADIO,
          'name' => 'place-chooser',
            'items' => [
                [ 'value' => $model->id],
            ],
            'value' => $value,
            'pluginOptions' => [  'size' => 'mini','handleWidth'=>60,'onText' => '<i class="glyphicon glyphicon-ok"></i>','offText'=>'<i class="glyphicon glyphicon-remove"></i>'],
            'labelOptions' => ['style' => 'font-size: 12px'],
        ]);              
      }
      ?>
  </td>
</tr>

Jetzt werde ich Ihnen zeigen, wie wir die AJAX-Unterstützung für all diese Wähler implementiert haben.

Implementierung der AJAX-Unterstützung

Natürlich wollte ich vermeiden, dass Benutzer Änderungen an diesen Formularen speichern müssen. Stattdessen wollte ich, dass die Switches den Status über AJAX ohne Seitenaktualisierung ändern.

Der Code ist unterteilt in das Einrichten von Ereignis-Listenern, um auf Statusänderungen zu reagieren, und Controller-Aktionen, um die Änderungen in unserer Datenbank aufzuzeichnen. Es ist auch etwas anders für die Kontrollkästchenschalter als für die Funkschalter.

Erstellen von Ereignis-Listenern

Wir erstellen Ereignis-Listener, um Code auszuführen, wenn der Status einer Schaltfläche geändert wird. Das Listen-Ereignis ist JavaScript-Code, der von PHP in der Bedienfeldansicht generiert wird (für die gesamte Optionstabelle).

Hier ist der Code am Ende von \frontend\views\meeting-place\_panel.php:

<?php
$script = <<< JS
  
// allows user to set the final place
$('input[name="place-chooser"]').on('switchChange.bootstrapSwitch', function(e, s) {
//  console.log(e.target.value); // true | false
  $.ajax({
     url: '/mp/meetingplace/choose',   
     data: {id: $model->id, 'val': e.target.value},
     // e.target.value is selected MeetingPlaceChoice model 
     success: function(data) {
       return true;
     }
  });  
});  
...
JS;
$position = \yii\web\View::POS_READY;
$this->registerJs($script, $position);
?>

Übrigens, wenn mir jemand den Namen der JS-Blockkürzel für PHP sagen kann, posten Sie ihn im Kommentarbereich. Ich würde gerne wissen. Einige Dinge sind schwer zu suchen.

Die Funktion registerJs in Yii rendert das Skript für eine bestimmte $position auf der Seite. In diesem Fall handelt es sich um ein On-Ready-Ereignis.

Der obige Code richtet Listener-Ereignisse für alle Optionsfelder zur Ortsauswahl für alle Orte mit der Eigenschaft name ein. Der Zielwert der Veranstaltung repräsentiert die gewählte Treffpunkt-ID. Ich werde gleich mehr über die AJAX-Funktion sprechen.

Mit anderen Worten, die Switch-Radio-Ereignisse reagieren darauf, dass der Organisator (im Allgemeinen) einen Ort oder eine Uhrzeit auswählt, um die Besprechung abzuschließen, und die Besprechungsort- oder Besprechungszeit-ID überträgt.

Hier ist der Code zum Abhören von Verfügbarkeitsänderungen mit den Kontrollkästchen für die Schaltereingabe:

// users can say if a place is an option for them
$('input[name="meeting-place-choice"]').on('switchChange.bootstrapSwitch', function(e, s) {
  //console.log(e.target.id,s); // true | false  
  // set intval to pass via AJAX from boolean state
  if (s)
    state = 1;
  else
    state =0;  
  $.ajax({
     url: '/mp/meetingplacechoice/set',   
     data: {id: e.target.id, 'state': state},
     success: function(data) {
       return true;
     }
  });  
});

Der Listener ist für alle Eigenschaften des Namens für die meeting-place-choice eingerichtet, muss jedoch die ID übergeben, um genau anzugeben, welche MeetingPlaceChoice geändert wird.

Zur Verdeutlichung können Benutzer mithilfe der Ereignis-Listener für Schalter-Eingabekästchen angeben, ob sie für einen Ort oder eine Uhrzeit verfügbar sind oder nicht. Sie senden eine ID zur meeting-place-choice oder eine ID zur meeting-place-time.

Schauen wir uns nun genauer an, wie die AJAX-Ereignisse unsere PHP-basierten Controller-Aktionen aufrufen, um Statusänderungen in der Datenbank aufzuzeichnen.

Erstellen der Controller-Aktionen

Hier ist noch einmal der Code für die Auswahl des Optionsfelds für den meeting-place:

$.ajax({
     url: '/mp/meetingplace/choose',   
     data: {id: $model->id, 'val': e.target.value},
     // e.target.value is selected MeetingPlaceChoice model 
     success: function(data) {
       return true;
     }
  });  

Die URL gibt den Pfad zur Auswahlaktion des MeetingPlace-Controllers an:

public function actionChoose($id,$val) {
      // meeting_place_id needs to be set active
      // other meeting_place_id for this meeting need to be set inactive
      $meeting_id = intval($id);
      $mtg=Meeting::find()->where(['id'=>$meeting_id])->one();
      if (Yii::$app->user->getId()!=$mtg->owner_id) return false;
      // to do - also check participant id if participants allowed to choose
      foreach ($mtg->meetingPlaces as $mp) {
        if ($mp->id == intval($val)) {
          $mp->status = MeetingPlace::STATUS_SELECTED;          
        }
        else {
          $mp->status = MeetingPlace::STATUS_SUGGESTED;          
        }
        $mp->save();
      }
      return true;
    }

Die eingehende $id repräsentiert die meeting_id. Der Wert repräsentiert die ausgewählte MeetingPlace-ID. STATUS_SELECTED zeigt an, dass der Ort ausgewählt wurde, während STATUS_SUGGESTED nur angibt, dass er vorgeschlagen wurde (nicht ausgewählt).

Dieser Code durchläuft die Treffpunkte jedes Meetings und aktualisiert den Status des ausgewählten Ortes.

Schauen wir uns noch einmal den Code für die Kontrollkästchen für die Schaltereingabe an, mit denen festgestellt wird, ob jemand für einen bestimmten Ort verfügbar ist:

$.ajax({
     url: '/mp/meetingplacechoice/set',   
     data: {id: e.target.id, 'state': state},
     success: function(data) {
       return true;
     }
  });  

Diese Ereignisse rufen die festgelegte Aktion des MeetingPlaceChoice-Controllers mit einer Zeichenfolge auf, deren Suffix die ID des MeetingPlaceChoice-Datensatzes enthält, der aktualisiert werden muss:

public function actionSet($id,$state)
    {
      // caution - incoming AJAX type issues with val
      $id=str_replace('mpc-','',$id);      
      $mpc = $this->findModel($id);      
      if (Yii::$app->user->getId()!=$mpc->user_id) return false;        
      if (intval($state) == 0 or $state=='false')
        $mpc->status = MeetingPlaceChoice::STATUS_NO;
      else
        $mpc->status = MeetingPlaceChoice::STATUS_YES;
      $mpc->save();
      return $mpc->id;
    }

Sichern von AJAX-Anfragen

Aus Sicherheitsgründen müssen wir überprüfen, ob die AJAX-Anforderung vom tatsächlichen Benutzer initiiert wurde, der diese Änderungen vornehmen kann. Dieser Code macht das:

1	if (Yii::$app->user->getId()!=$mtg->owner_id) return false;

und

1	if (Yii::$app->user->getId()!=$mpc->user_id) return false;

Ohne diese Überprüfungen wäre es für einen Hacker einfach, ein Skript zu schreiben, um die Besprechungseinstellungen für jedermann zu ändern.

Der AJAX-Code zum Anzeigen der Verfügbarkeit für Datums- und Uhrzeitangaben und zum Treffen von Auswahlmöglichkeiten ist nahezu identisch.

Unterstützung der Verfügbarkeitseinstellungen

Um alle oben genannten Funktionen zu unterstützen, müssen wir auch Code hinzufügen, der den Tabellen MeetingPlaceChoice und MeetingTimeChoice-Datensätze hinzufügt, wenn Teilnehmer, Orte und Datumszeiten hinzugefügt werden. Dafür verwenden wir die AfterSave-Ereignisse von Yii.

Wenn ein Teilnehmer hinzugefügt wird, müssen wir für jeden MeetingPlace neue MeetingPlaceChoice-Zeilen und für jede MeetingTime neue MeetingTimeChoice-Zeilen hinzufügen. Hier ist der Code im Participate-Modell, der dies automatisch für uns erledigt:

    public function afterSave($insert,$changedAttributes)
    {
        parent::afterSave($insert,$changedAttributes);
        if ($insert) {
          // if Participant is added
          // add MeetingPlaceChoice & MeetingTimeChoice this participant
          $mt = new MeetingTime;          
          $mt->addChoices($this->meeting_id,$this->participant_id);
          $mp = new MeetingPlace;          
          $mp->addChoices($this->meeting_id,$this->participant_id);
        } 
    }

Wenn ein neuer Ort hinzugefügt wird, werden für jeden Teilnehmer neue MeetingPlaceChoices benötigt:

public function afterSave($insert,$changedAttributes)
    {
        parent::afterSave($insert,$changedAttributes);
        if ($insert) {
          // if MeetingPlace is added
          // add MeetingPlaceChoice for owner and participants
          $mpc = new MeetingPlaceChoice;
          $mpc->addForNewMeetingPlace($this->meeting_id,$this->suggested_by,$this->id);
        } 
    }

Wenn eine neue Datums- und Uhrzeitangabe hinzugefügt wird, werden für jeden Teilnehmer neue Einträge für MeetingTimeChoice benötigt:

public function afterSave($insert,$changedAttributes)
    {
        parent::afterSave($insert,$changedAttributes);
        if ($insert) {
          // if MeetingTime is added
          // add MeetingTimeChoice for owner and participants
          $mtc = new MeetingTimeChoice;
          $mtc->addForNewMeetingTime($this->meeting_id,$this->suggested_by,$this->id);
        } 
    }
    

Es wird davon ausgegangen, dass der Organisator eines Meetings, wenn er einen Ort oder eine Uhrzeit hinzufügt, zunächst für ihn funktioniert.

Auswahl des endgültigen Ortes, Datums und der Uhrzeit

Sobald mindestens ein Teilnehmer, ein Ort und eine Zeit eingeladen ist, kann der Organisator des Meetings das Meeting abschließen. In Zukunft können die Teilnehmer das Meeting auch abschließen.

Während sich dieser Code in Zukunft etwas ändert, gibt es im Besprechungsmodell eine Funktion, die der Ansicht mitteilt, ob die Schaltfläche Finalize aktiviert werden soll:

public function canFinalize() {
        // check if meeting can be finalized by viewer
        if ($this->canSend()) {
          // organizer can always finalize
          if ($this->viewer == Meeting::VIEWER_ORGANIZER) {
            $this->isReadyToFinalize = true;
          } else {
            // viewer is a participant
            // has participant responded to one time or is there only one time
            // has participant responded to one place or is there only one place
            
          }          
        }    

Hier ist der Ansichtscode:

1	<?= Html::a(Yii::t('frontend', 'Finalize'), ['finalize', 'id' => $model->id], ['class' => 'btn btn-success '.(!$model->isReadyToFinalize?'disabled':'')]) ?>

Sobald das Meeting abgeschlossen ist, ändert MeetingPlanner den Modus von der Unterstützung der Planung zur Erleichterung der Teilnahme der Teilnehmer durch eine Vielzahl cooler Funktionen, die wir in zukünftigen Tutorials behandeln werden.

Codierungsprobleme, auf die ich gestoßen bin

Ich wollte einige Probleme erwähnen, auf die ich beim Schreiben des Codes für diesen relativ komplizierten Abschnitt gestoßen bin.

AJAX-Typen

Die SwitchInput-Zustände wurden über JavaScript als boolesche Typen gesendet, z. wahr oder falsch, aber ich musste diese in ganzzahlige Werte konvertieren, um sie erfolgreich über AJAX an die Controller zu übertragen.

// users can say if a place is an option for them
$('input[name="meeting-place-choice"]').on('switchChange.bootstrapSwitch', function(e, s) {
  //console.log(e.target.id,s); // true | false  
  // set intval to pass via AJAX from boolean state
  if (s)
    state = 1;
  else
    state =0;  

Überlappende IDs

Die numerischen IDs der Widgets MeetingPlaceChoice und MeetingTimeChoice überlappen sich. Es dauerte eine Weile, bis ich herausgefunden hatte, warum die Switch-Widgets für mich nicht mehr richtig gerendert wurden, als ich die Auswahlfunktionen hinzufügte. Da es überlappende IDs gab, wurden die Switch-Widgets nur für das erste Objekt gerendert.

Es war notwendig, Präfixe wie mpc- oder mtc- zu den IDs hinzuzufügen und diese in den Controller-Aktionen zu entfernen.

 echo SwitchInput::widget([
          'type'=>SwitchInput::CHECKBOX,         
          'name' => 'meeting-place-choice',
          'id'=>'mpc-'.$mpc->id,          
          'tristate'=>true,

Hier entfernen wir das Präfix im Controller, um das Modell zu laden:

    public function actionSet($id,$state)
    {
      // caution - incoming AJAX type issues with val
      $id=str_replace('mpc-','',$id);      
      $mpc = $this->findModel($id);      

Swith Input Widget Optionsfeld Ladezustand

Es dauerte eine Weile, bis ich herausgefunden hatte, wie der anfängliche Ladezustand / -wert für das Weicheingabe-Widget im Optionsfeldmodus eingestellt werden konnte. Es gab keine Dokumentation, die zeigte, wie das geht. Ich habe hier endlich einen Erklärer für andere geschrieben: Einstellen des Status des Optionsfelds "Switch Input Widget".

Was kommt weiter?

Nachdem die gesamte AJAX vorhanden ist und funktioniert, ist es an der Zeit, einige der verbleibenden Bereiche der Besprechungsplanungsansicht fertigzustellen, um Einladungen vorzubereiten, die zugestellt wurden und von den Teilnehmern angezeigt werden müssen.

Beispielsweise unterscheidet sich die Ansicht des Besprechungsplans, die die Teilnehmer sehen, im Layout vom Veranstalter und hängt davon ab, welche Befugnisse der Veranstalter delegiert hat.

Beispielsweise müssen sich die Spalten "Sie" und "Sie" gegenüber ihrer aktuellen Implementierung ändern. Die Einstellungen des Besprechungsmodells müssen erweitert werden, um zu bestimmen, ob die Teilnehmer Orte und Datumsangaben vorschlagen und die Besprechung abschließen können.

In der Zukunft möchte ich wahrscheinlich mehrere Teilnehmer zulassen und muss mehr Verfügbarkeitsspalten für die Organisationsansicht anzeigen. Diese Funktionalität ist nicht Teil unseres Minimum Viable Product (MVP).

Ich muss auch die Implementierung des MeetingLog abschließen, in dem jede Änderung aufgezeichnet wird, die während des Planungsprozesses an einem Meeting vorgenommen wurde. Dies liefert eine Art Planungsverlauf für jedes Meeting. Ich kann auch afterSave()-Ereignisse dafür verwenden.

Achten Sie auf bevorstehende Tutorials in unserer Reihe Erstellen Sie Ihr Startup mit PHP. Eine Liste der bevorstehenden Themen finden Sie jetzt in unserem Inhaltsverzeichnis.

Bitte zögern Sie nicht, Ihre Fragen und Kommentare unten hinzuzufügen; Ich nehme in der Regel an den Diskussionen teil. Sie können mich auch auf Twitter @reifman erreichen oder mir direkt eine E-Mail senden.