Construyendo tu Startup: Solicitando cambios de agenda

Spanish (Español) translation by Elías Nicolás (you can also view the original English article)

Final product image — What You'll Be Creating

Este tutorial es parte de la serie Envato Tuts+ Construyendo tu startup. En esta serie, te guiare para lanzando una startup desde el concepto de la realidad usando mi app Meeting Planner como un ejemplo de vida real. Cada paso del camino, publicare el codigo Meeting Planner como un open-source ejemplo con el cual puedes aprender También me ocuparé de asuntos relacionados con el inicio de negocios a medida que surjan.

Cambiando tus planes de reunión

Como el testeo de Meeting Planner alpha comienza, la clara característica faltante fue la inhabilidad de cambiar una reunión después de que fue programada No es un problema facil. ¿Esta bien solo cambiar una reunion sin el consentimiento del participante? ¿O deberia preguntar? ¿O hacer cualquiera?, dependiendo del rol que tengas organizando la reunión. ¿Que pasaría si solo quieres preguntar si esta bien reunirnos 15 mas tarde? —Debería ser facil, ¿no?

Resolviendo todo esto, requiere reflejar todos los aspectos sociales de cambiar una reunion

Con el tiempo, me di cuenta que la habilidad de cambiar una reunion facilmente que han programado podria hacer o quebrar la marca "Meeting Planner"

En nuestro ultimo episodio en programación avanzada, implemente Hacer Cambios, que permite un organizador o participante con permisos para esencialmente re programar una reunión sin pedir permiso En el tutorial de hoy, los guiare por todo el proceso de construir toda la infraestructura de "Pedir cambios" Requiere que los participantes pidan cambios y los otros puedan aceptar o declinar, afectando los detalles del calendario de la reunión final

Mientras lees, espero puedas intentar la característica "Pide un cambio" en el sitio y compartas sus pensamientos y opiniones en los comentarios de abajo. Participio en las discusiones, pero puedes contactarme en @reifman en twitter. Estoy siempre abierto a ideas de caracteristicas nuevas para Meeting Planner como tambien sugerencias para futuras episodios de la serie.

Como recordatorio, todo el codigo para Meeting Planner es previsto como codigo abierto y escrito en la Yii2 Framework para PHP. Si te gustaria aprender mas de Yii2, visita mi serie paralela Programando con Yii2.

Empecemos.

Construyendo "Pedir cambios"

Una montaña alta por escalar

Aparte de la vista de las características de reunión y programación, "Pedir cambios" requiere mas tiempo y nuevo código que cualquier otra característica en este proyecto.

Como mencione en el anterior episodio, programar todo con seguridad básica toma un poco mas tiempo que rápido prototipo, pero diseñar y construir esta característica también toque mucho las otras áreas de la plataforma:

Diseñar con la ingeniería social de solicitar y hacer cambios de horario.
Mantener el UX para las solicitudes de cambio simple, ayudando a la gente a solicitar y responder a las solicitudes de cambio sin enturbiar la interfaz.
Manejar solicitudes para reuniones de 1:1 sería fácil, pero la programacion de la nueva característica de múltiples participantes requeriría una infraestructura mucho más sofisticada.
Manejo de las respuestas a las solicitudes con varios participantes por delante.
Notificaciones por correo electrónico de solicitudes nuevas y retiradas, respuestas aceptadas y rechazadas.
Actualizar la confirmación de la reunión y los detalles del calendario cuando las solicitudes aceptadas afectan a la reunion programada.

Por lo tanto, aunque esto no es una imagen perfecta de los cambios sólo para esta característica, aquí hay capturas de pantalla de la eventual extracción de código de servidor de producción.

Aqui estan los cambios al codigo existente:

Build Your Startup Request Scheduling Changes - Git Pull File Changes

Y aqui estan los nuevos archivos:

Build Your Startup Request Scheduling Changes - Git Pull New Files

Hubo mucho codigo nuevo en esta caracteristica.

Las tablas y sus migraciones

En última instancia, me decidí por una arquitectura construida alrededor de dos tablas. El primero fue Pedidos:

$this->createTable('{{%request}}', [
    'id' => Schema::TYPE_PK,
    'meeting_id' => Schema::TYPE_INTEGER.' NOT NULL DEFAULT 0',
    'requestor_id' => Schema::TYPE_BIGINT.' NOT NULL DEFAULT 0',
    'completed_by' => Schema::TYPE_BIGINT.' NOT NULL DEFAULT 0',
    'time_adjustment' => Schema::TYPE_SMALLINT . ' NOT NULL DEFAULT 0',
    'alternate_time' => Schema::TYPE_BIGINT.' NOT NULL DEFAULT 0',
    'meeting_time_id' => Schema::TYPE_BIGINT.' NOT NULL DEFAULT 0',
    'place_adjustment' => Schema::TYPE_SMALLINT . ' NOT NULL DEFAULT 0',
    'meeting_place_id' => Schema::TYPE_BIGINT.' NOT NULL DEFAULT 0',
    'note' => Schema::TYPE_TEXT.' NOT NULL DEFAULT ""',
    'status' => Schema::TYPE_SMALLINT . ' NOT NULL DEFAULT 0',
    'created_at' => Schema::TYPE_INTEGER . ' NOT NULL',
    'updated_at' => Schema::TYPE_INTEGER . ' NOT NULL',
], $tableOptions);
$this->addForeignKey('fk_request_meeting', '{{%request}}', 'meeting_id', '{{%meeting}}', 'id', 'CASCADE', 'CASCADE');
$this->addForeignKey('fk_request_user', '{{%request}}', 'requestor_id', '{{%user}}', 'id', 'CASCADE', 'CASCADE');

Aqui estan las constantes que explican el modelo mas a fondo:

  const STATUS_OPEN = 0;
  const STATUS_ACCEPTED = 10;
  const STATUS_REJECTED = 20;
  const STATUS_WITHDRAWN = 30;

  const TIME_ADJUST_NONE = 50;
  const TIME_ADJUST_ABIT = 60;
  const TIME_ADJUST_OTHER = 70;

  const PLACE_ADJUST_NONE = 80;
  const PLACE_ADJUST_OTHER = 90;

Hay dos maneras de ajustar el tiempo: TIME_ADJUST_ABIT, es decir, intervalos de minutos u horas antes o después de la hora elegida, o TIME_ADJUST_OTHER, un tiempo de reunión diferente por completo.

Y la segunda tabla fue RequestResponses

$this->createTable('{{%request_response}}', [
    'id' => Schema::TYPE_PK,
    'request_id' => Schema::TYPE_INTEGER.' NOT NULL DEFAULT 0',
    'responder_id' => Schema::TYPE_BIGINT.' NOT NULL DEFAULT 0',
    'note' => Schema::TYPE_TEXT.' NOT NULL DEFAULT ""',
    'response' => Schema::TYPE_SMALLINT . ' NOT NULL DEFAULT 0',
    'created_at' => Schema::TYPE_INTEGER . ' NOT NULL',
    'updated_at' => Schema::TYPE_INTEGER . ' NOT NULL',
], $tableOptions);

Básicamente, quién pidió el cambio, quién respondió a él y cuál fue la respuesta: aceptar o rechazar.

La segunda tabla es necesaria para la ocasion de muchos participantes.

Pidiendo Cambios

Los organizadores de la reunión y los participantes pueden acceder a los Pedidos de cambio a través del menú de opciones desplegable que construimos en el último episodio:

Build Your Startup Request Scheduling Changes - Options Menu Request Changes

El formulario de Pedir Cambio

El actionCreate() de RequestController.php carga el formulario desde el cual el usuario pide cambios:

Build Your Startup Request Scheduling Changes - Request a Change Form

Y aquí es donde comenzó la complejidad. ¿Qué tipo de cambios podrían solicitar los participantes?

¿Quieres reunirte mas temprano o más tarde?
¿Quieres reunirte en un momento totalmente diferente?
¿Quieres reunirte en un lugar diferente?

Nota: Todavía no he implementado la posibilidad de agregar nuevos lugares y horas. En este momento, puede elegir fechas y lugares alternativos entre los que se ofrecieron durante el proceso de planificación.

Un desplegable de tiempos anteriores y posteriores

El código para crear la lista desplegable era complicado. Lo hice para que pudiera elegir dos horas y media antes o más tarde, en incrementos de 15 minutos cerca del tiempo original y los incrementos de 30 minutos después de eso:

for ($i=1;$i<12;$i++) {
  // later times
  if ($i<4 || $i%2 == 0) {
    $altTimesList[$chosenTime->start+($i*15*60)]=Meeting::friendlyDateFromTimestamp($chosenTime->start+($i*15*60),$timezone,false);
  }
  // earlier times
  $earlierIndex = ((12-$i)*-15);
  if ($i%2 == 0 || $i>=9) {
    $altTimesList[$chosenTime->start+($earlierIndex*60)]=Meeting::friendlyDateFromTimestamp($chosenTime->start+($earlierIndex*60),$timezone,false);
  }
}
$altTimesList[$chosenTime->start]='────────────────────';
$altTimesList[-1000]=Yii::t('frontend','Select an alternate time below');
ksort($altTimesList);

Llené $altTimesList con claves de cada tiempo posible con valores del tiempo amigable ajustado para la zona horaria del usuario. Luego utilicé ksort () para ordenar la lista desplegable para que aparecieran tiempos anteriores más tarde.

Uno de los asesores de Meeting Planner (sólo tengo uno por el momento), sugirió que se muestre el tiempo de reunión actualmente seleccionado, el cual hice a continuación. También agregué un separador con la opción deshabilitada en un menú desplegable. Divide tiempos anteriores de tiempos posteriores pero no es seleccionable:

Build Your Startup Request Scheduling Changes - Enhanced Request Form with Separator

Aquí está el código desplegable, que muestra cómo deshabilitar el separador basado en clave de índice de $currentStart:

<?php
echo $form->field($model, 'alternate_time')->label(Yii::t('frontend','Choose a time slightly earlier or later than {currentStartStr}',['currentStartStr'=>$currentStartStr]))
  ->dropDownList(
      $altTimesList,
      ['options' => [$currentStart => ['disabled' => true]]]
  );
  ?>

Y, cuando los participantes quieren elegir una de las otras veces, hay JQuery para cambiar los desplegables, otra complejidad a la construcción de los formularios:

1	<?php ActiveForm::end();
2	$this->registerJsFile(MiscHelpers::buildUrl().'/js/request.js',['depends' => [\yii\web\JqueryAsset::className()]]);
3	?>
4	</div>

Aquí está /frontend/web/js/request.js:

  $("#adjust_how" ).change(function() {
    if ($("#adjust_how" ).val()==50) {
      $("#choose_earlier").addClass('hidden');
      $("#choose_another").addClass('hidden');
    } else if ($("#adjust_how" ).val()==60) {
      $("#choose_earlier").removeClass('hidden');
      $("#choose_another").addClass('hidden');
    } else {
      $("#choose_earlier").addClass('hidden');
      $("#choose_another").removeClass('hidden');
    }
  });

Asi es como el formulario se ve con las horas alternativas ocultas:

Build Your Startup Request Scheduling Changes - Selecting a different place

Diferentes lugares se integran en la lista desplegable del lugar (como se puede ver con la imagen arriba).

Manejando el Pedido

Una vez que el pedido es hecho, notificamos que la otra persona participante sera notificada. Y, cuando haya pedidos activos para una reunion, hay un enlace para Mirarlos

Build Your Startup Request Scheduling Changes - Meeting page View Requests

Decidí que esto sería un acercamiento simple, sin impedimentos para que la gente tenga acceso a peticiones.

La lista de pedidos de reuniones

Aqui esta la lista de Pedidos para una reunion, casi siempre uno solo:

Build Your Startup Request Scheduling Changes - List of Meeting Requests

Request::buildSubject() crea la string basado en el contenido de la solicitud, el cambio de tiempo y/o lugar:

public static function buildSubject($request_id,$include_requestor = true) {
  $r = Request::findOne($request_id);
  $requestor = MiscHelpers::getDisplayName($r->requestor_id);
  $timezone = MiscHelpers::fetchUserTimezone(Yii::$app->user->getId());
  $rtime ='';
  $place = '';
  switch ($r->time_adjustment) {
    case Request::TIME_ADJUST_NONE:
    break;
    case Request::TIME_ADJUST_ABIT:
      $rtime = Meeting::friendlyDateFromTimestamp($r->alternate_time,$timezone);
    break;
    case Request::TIME_ADJUST_OTHER:
      $t = MeetingTime::findOne($r->meeting_time_id);
      if (!is_null($t)) {
          $rtime = Meeting::friendlyDateFromTimestamp($t->start,$timezone);;
      }
    break;
  }
  if ($r->place_adjustment == Request::PLACE_ADJUST_NONE || $r->place_adjustment == 0 && $r->meeting_place_id ==0 ) {
    // do nothing
  } else {
    // get place name
    $place = MeetingPlace::findOne($r->meeting_place_id)->place->name;
  }
  $result = $requestor.Yii::t('frontend',' asked to meet at ');
  if ($rtime=='' && $place =='') {
    $result.=Yii::t('frontend','oops...no changes were requested.');
  } else if ($rtime<>'') {
    $result.=$rtime;
    if ($place<>'') {
      $result.=Yii::t('frontend',' and ');
    }
  }
  if ($place<>'') {
    $result.=$place;
  }
  return $result;
}

Esta función es también usada repetidamente en las notificaciones por correo.

Hay también limites en RequestController.php el cual previenen a usuarios de hacer mas de una petición para reunión a la vez:

public function actionCreate($meeting_id)
    {
        // verify is attendee
        if (!Meeting::isAttendee($meeting_id,Yii::$app->user->getId())) {
          $this->redirect(['site/authfailure']);
        }
        if (Request::countRequestorOpen($meeting_id,Yii::$app->user->getId())>0) {
            $r = Request::find()
              ->where(['meeting_id'=>$meeting_id])
              ->andWhere(['requestor_id'=>Yii::$app->user->getId()])
              ->andWhere(['status'=>Request::STATUS_OPEN])
              ->one();
            Yii::$app->getSession()->setFlash('info', Yii::t('frontend','You already have an existing request below.'));
              return $this->redirect(['view','id'=>$r->id]);
        }
    

Aquí como se ve la pagina de petición mostrando cuando se limita:

Build Your Startup Request Scheduling Changes - Viewing a Request

Si es tu propio pedido, puedes Cancelar Tu Pedido.

Como puedes ver, hay mucha diversidad de funcionalidad UX para construir para esto. Y no te he mostrado cuando otras personas que no sean el solicitante responden.

Notificaciones por email de Pedido y Respuesta

En el proceso de creación de estas características, decidí crear plantillas de correo electrónico generic_html y generic_text, así como una función Request::notify() reutilizable para facilitar la entrega de diferentes tipos de anuncios en torno a Meeting Planner.

Aqui el metodo Request::create() para preparar un correo electronico:

public function create() {
  $user_id = $this->requestor_id;
  $meeting_id = $this->meeting_id;
  $subject = Request::buildSubject($this->id);
  $content=[
    'subject' => Yii::t('frontend','Change Requested to Your Meeting'),
    'heading' => Yii::t('frontend','Requested Change to Your Meeting'),
    'p1' => $subject,
    'p2' => $this->note,
    'plain_text' => $subject.' '.$this->note.'...'.Yii::t('frontend','Respond to the request by visiting this link: '),
  ];
  $button= [
    'text' => Yii::t('frontend','Respond to Request'),
    'command' => Meeting::COMMAND_VIEW_REQUEST,
    'obj_id' => $this->id,
  ];
  $this->notify($user_id,$meeting_id, $content,$button);
  // add to log
  MeetingLog::add($meeting_id,MeetingLog::ACTION_REQUEST_SENT,$user_id,0);
}

La matriz $content se rellena para el asunto del correo electrónico, el encabezado del mensaje y los párrafos, mientras que la matriz $button se utiliza para cualquier botón de comando como Responder a solicitud o Ver reunión.

Aqui el metodo notify(), similar a las acciones anteriores send() y finalize() las cuales envian el correo electronico:

public static function notify($user_id,$meeting_id,$content,$button = false) {
  // sends a generic message based on arguments
  $mtg = Meeting::findOne($meeting_id);
  // build an attendees array for all participants without contact information
  $cnt =0;
  $attendees = array();
  foreach ($mtg->participants as $p) {
      $auth_key=\common\models\User::find()->where(['id'=>$p->participant_id])->one()->auth_key;
      $attendees[$cnt]=['user_id'=>$p->participant_id,'auth_key'=>$auth_key,
      'email'=>$p->participant->email,
      'username'=>$p->participant->username];
      $cnt+=1;
  }
  // add organizer
  $auth_key=\common\models\User::find()->where(['id'=>$mtg->owner_id])->one()->auth_key;
  $attendees[$cnt]=['user_id'=>$mtg->owner_id,'auth_key'=>$auth_key,
    'email'=>$mtg->owner->email,
    'username'=>$mtg->owner->username];
// use this code to send
foreach ($attendees as $cnt=>$a) {
  // check if email is okay and okay from this sender_id
  if ($user_id != $a['user_id'] && User::checkEmailDelivery($a['user_id'],$user_id)) {
    Yii::$app->timeZone = $timezone = MiscHelpers::fetchUserTimezone($a['user_id']);
      // Build the absolute links to the meeting and commands
      $links=[
        'home'=>MiscHelpers::buildCommand($mtg->id,Meeting::COMMAND_HOME,0,$a['user_id'],$a['auth_key']),
        'view'=>MiscHelpers::buildCommand($mtg->id,Meeting::COMMAND_VIEW,0,$a['user_id'],$a['auth_key']),
        'footer_email'=>MiscHelpers::buildCommand($mtg->id,Meeting::COMMAND_FOOTER_EMAIL,0,$a['user_id'],$a['auth_key']),
        'footer_block'=>MiscHelpers::buildCommand($mtg->id,Meeting::COMMAND_FOOTER_BLOCK,$user_id,$a['user_id'],$a['auth_key']),
        'footer_block_all'=>MiscHelpers::buildCommand($mtg->id,Meeting::COMMAND_FOOTER_BLOCK_ALL,0,$a['user_id'],$a['auth_key']),
      ];
      if ($button!==false) {
        $links['button_url']=MiscHelpers::buildCommand($mtg->id,$button['command'],$button['obj_id'],$a['user_id'],$a['auth_key']);
        $content['button_text']=$button['text'];
      }
      // send the message
      $message = Yii::$app->mailer->compose([
        'html' => 'generic-html',
        'text' => 'generic-text'
      ],
      [
        'meeting_id' => $mtg->id,
        'sender_id'=> $user_id,
        'user_id' => $a['user_id'],
        'auth_key' => $a['auth_key'],
        'links' => $links,
        'content'=>$content,
        'meetingSettings' => $mtg->meetingSettings,
    ]);
      // to do - add full name
    $message->setFrom(array('support@meetingplanner.com'=>$mtg->owner->email));
    $message->setReplyTo('mp_'.$mtg->id.'@meetingplanner.io');
    $message->setTo($a['email'])
        ->setSubject($content['subject'])
        ->send();
    }
  }
}

Esencialmente, el diseño de generic_html.php es basado en la simple textual plantilla de actualización que hable en nuestros tutoriales de plantillas de correo electrónico. Proporciona una forma bien formateada de actualizar a los participantes vía correo electrónico con unos pocos párrafos.

Aqui la vista de el archivo generic_html.php intengrando los datos de $contento y $button. Comprueba un segundo y tercer párrafo, $p2, $p3 y los datos de $button :

<tr>
  <td style="color:#777; font-family:Helvetica, Arial, sans-serif; font-size:14px; line-height:21px; text-align:center; border-collapse:collapse; padding:10px 60px 0; width:100%" align="center" width="100%">
    <p>Hi <?php echo Html::encode(MiscHelpers::getDisplayName($user_id)); ?>,</p>
    <p><?= Html::encode($content['p1']) ?></p>
    <?php if ($content['p2']<>'') {
    ?>
    <p><?= Html::encode($content['p2']); ?></p>
    <?php
      }
    ?>
    <?php if (isset($content['p3']) && $content['p3']<>'') {
    ?>
    <p><?= Html::encode($content['p3']); ?></p>
    <?php
      }
    ?>
  </td>
</tr>
<?php if ($links['button_url']!='') {
 ?>
<tr>
  <td style="color:#777; font-family:Helvetica, Arial, sans-serif; font-size:14px; line-height:21px; text-align:center; border-collapse:collapse; padding:30px 0 30px 0" align="center">
    <div>
<!--[if mso]>
      <v:roundrect xmlns:v="urn:schemas-microsoft-com:vml" xmlns:w="urn:schemas-microsoft-com:office:word" href="http://" style="height:45px;v-text-anchor:middle;width:155px;" arcsize="15%" strokecolor="#ffffff" fillcolor="#ff6f6f">
        <w:anchorlock/>
        <center style="color:#ffffff;font-family:Helvetica, Arial, sans-serif;font-size:14px;font-weight:regular;">My Account</center>
      </v:roundrect>
    <![endif]--><a href="<?php echo $links['button_url'] ?>" style='color:#fff; text-decoration:none; -webkit-text-size-adjust:none; background-color:#ff6f6f; border-radius:5px; display:inline-block; font-family:"Cabin", Helvetica, Arial, sans-serif; font-size:14px; font-weight:regular; line-height:45px; mso-hide:all; text-align:center; width:155px' bgcolor="#ff6f6f" align="center" width="155"><?= Html::encode($content['button_text']); ?></a>
  </div>
  </td>
</tr>
<?php } ?>

Aquí hay un ejemplo de una notificación que Rob Smith me pregunto para cambiar el tiempo y lugar de nuestra reunión (Generado con el codigo siguiente):

Build Your Startup Request Scheduling Changes - Email Notification of Requested Change

Respondiendo a Pedidos

Cuando hago click en "Responder A Pedido", me llevan al método actionCreate () del controlador RequestResponse:

Build Your Startup Request Scheduling Changes - Respond to Request Form - Accept or Decline

A través de la solicitud UX, incorporé la capacidad para que personas puedan escribir notas, proporcionando el contexto para las peticiones y respuestas.

Uno de los desafíos de este formulario fue determinar cómo dirigir las respuestas a los métodos de otro controlador en los cuales el boton enviar se hizo clic. En otras palabras, distinguir entre diferentes clics de botón de envío POST.

public function actionCreate($id)
{
  $request = Request::findOne($id);
  if (!Meeting::isAttendee($request->meeting_id,Yii::$app->user->getId())) {
    $this->redirect(['site/authfailure']);
  }
    // has this user already responded
    $check = RequestResponse::find()
      ->where(['request_id'=>$id])
      ->andWhere(['responder_id'=>Yii::$app->user->getId()])
      ->count();
    if ($check>0) {
      Yii::$app->getSession()->setFlash('error', Yii::t('frontend','Sorry, you already responded to this request.'));
      return $this->redirect(['meeting/view', 'id' => $request->meeting_id]);
    }
    if ($request->requestor_id == Yii::$app->user->getId()) {
      Yii::$app->getSession()->setFlash('error', Yii::t('frontend','Sorry, can not respond to your own request.'));
      return $this->redirect(['meeting/view', 'id' => $request->meeting_id]);
    }
    $subject = Request::buildSubject($id);
    $model = new RequestResponse();
    $model->request_id = $id;
    $model->responder_id = Yii::$app->user->getId();
    if ($model->load(Yii::$app->request->post()) ) {
      $posted = Yii::$app->request->post();
      if (isset($posted['accept'])) {
        // accept
        $model->response = RequestResponse::RESPONSE_ACCEPT;
        $model->save();
        $request->accept($model);
        Yii::$app->getSession()->setFlash('success', Yii::t('frontend','Request accepted. We will update the meeting details and inform other participants.'));
      } else {
        // reject
        $model->response = RequestResponse::RESPONSE_REJECT;
        $model->save();
        $request->reject($model);
        Yii::$app->getSession()->setFlash('success', Yii::t('frontend','Your decline has been recorded. We will let other participants know.'));
      }
      return $this->redirect(['/meeting/view', 'id' => $request->meeting_id]);
    } else {
        return $this->render('create', [
            'model' => $model,
            'subject' => $subject,
            'meeting_id' => $request->meeting_id,
        ]);
    }
}

Aqui esta /frontend/views/request-response/_form.php:

<div class="request-response-form">
    <?php $form = ActiveForm::begin(); ?>
      <?= BaseHtml::activeHiddenInput($model, 'responder_id'); ?>
        <?= BaseHtml::activeHiddenInput($model, 'request_id'); ?>
    <?= $form->field($model, 'note')->label(Yii::t('frontend','Include a note'))->textarea(['rows' => 6])->hint(Yii::t('frontend','optional')) ?>

<div class="form-group">
  <?= Html::submitButton(Yii::t('frontend', 'Accept Request'), 
        ['class' => 'btn btn-success','name'=>'accept',]) ?>
  <?= Html::submitButton(Yii::t('frontend', 'Decline Request'),
        ['class' => 'btn btn-danger','name'=>'reject',
      'data' => [
          'confirm' => Yii::t('frontend', 'Are you sure you want to decline this request?'),
          'method' => 'post',
      ],]) ?>

Esencialmente, agregue los valores 'accept' o 'reject' de name para cada boton. Entonces, esto es enviado como un valor publicado, como se mustra:

    if ($model->load(Yii::$app->request->post()) ) {
      $posted = Yii::$app->request->post();
      if (isset($posted['accept'])) {
        // accept
        $model->response = RequestResponse::RESPONSE_ACCEPT;
        $model->save();
        $request->accept($model);
        Yii::$app->getSession()->setFlash('success', Yii::t('frontend','Request accepted. We will update the meeting details and inform other participants.'));
      } else {
        // reject
        $model->response = RequestResponse::RESPONSE_REJECT;
        $model->save();
        $request->reject($model);
        Yii::$app->getSession()->setFlash('success', Yii::t('frontend','Your decline has been recorded. We will let other participants know.'));
      }
      return $this->redirect(['/meeting/view', 'id' => $request->meeting_id]);
    }

Cuando la persona a la cual se ha enviado, acepta o declina el pedido, se les muestra un mensaje y se les envia un correo electronico También, la reunión no tiene mas ningún pedido pendiente para mostrar:

Build Your Startup Request Scheduling Changes - Meeting page after Request accepted

Aqui esta la notificacion por email de Pedir Cambios Aceptado:

Build Your Startup Request Scheduling Changes - Email notification of requested change being accepted

Muchas cosas pasan en Request::accept() mira abajo:

public function accept($request_response) {
  // to do - this will need to change when there are multiple participants
  $this->status = Request::STATUS_ACCEPTED;
  $this->update();
  $m = Meeting::findOne($this->meeting_id);
  // is there a new time
  switch ($this->time_adjustment) {
    case Request::TIME_ADJUST_ABIT:
      // create a new meeting time with alternate_time
      $this->meeting_time_id = MeetingTime::addFromRequest($this->id);
      $this->update();
      // mark as selected
      MeetingTime::setChoice($this->meeting_id,$this->meeting_time_id,$request_response->responder_id);
    break;
    case Request::TIME_ADJUST_OTHER:
     // mark as selected
      MeetingTime::setChoice($this->meeting_id,$this->meeting_time_id,$request_response->responder_id);
    break;
  }
  // is there a different place
  if ($this->place_adjustment == Request::PLACE_ADJUST_OTHER || $this->meeting_place_id !=0 ) {
    MeetingPlace::setChoice($this->meeting_id,$this->meeting_place_id,$request_response->responder_id);
  }
  if ($m->isOwner($request_response->responder_id)) {
    // they are an organizer
    $this->completed_by =$request_response->responder_id;
    $this->update();
    MeetingLog::add($this->meeting_id,MeetingLog::ACTION_REQUEST_ORGANIZER_ACCEPT,$request_response->responder_id,$this->id);
  } else {
    // they are a participant
    MeetingLog::add($this->meeting_id,MeetingLog::ACTION_REQUEST_ACCEPT,$request_response->responder_id,$this->id);
  }
  $user_id = $request_response->responder_id;
  $subject = Request::buildSubject($this->id, true);
  $p1 = MiscHelpers::getDisplayName($user_id).Yii::t('frontend',' accepted the request: ').$subject;
  $p2 = $request_response->note;
  $p3 = Yii::t('frontend','You will receive an updated meeting confirmation reflecting these change(s). It will also include an updated attachment for your Calendar.');
  $content=[
    'subject' => Yii::t('frontend','Accepted Requested Change to Meeting'),
    'heading' => Yii::t('frontend','Requested Change Accepted'),
    'p1' => $p1,
    'p2' => $p2,
    'p3' => $p3,
    'plain_text' => $p1.' '.$p2.' '.$p3.'...'.Yii::t('frontend','View the meeting here: '),
  ];
  $button= [
    'text' => Yii::t('frontend','View the Meeting'),
    'command' => Meeting::COMMAND_VIEW,
    'obj_id' => 0,
  ];
  $this->notify($user_id,$this->meeting_id, $content,$button);
  // Make changes to the Meeting
  $m->increaseSequence();
  // resend the finalization - which also needs to be done for resend invitation
  $m->finalize($m->owner_id);
}

Antes de enviar el correo electrónico, el horario de la reunión se actualiza para reflejar cualquier nueva fecha / hora y / o lugar nuevo. Después de enviar el correo electrónico, la reunión se finaliza. Esto entrega una nueva actualización de reunión con el calendario actualizado a todos los participantes:

Build Your Startup Request Scheduling Changes - Updating Meeting Notice

¿Que sigue?

Espero que hayas disfrutado de este tutorial. Construir esta característica tardó más de lo que esperaba, pero resultó bastante bien. Creo que añade una dimensión a la programación con Meeting Planner incomparable por otros servicios.

Si aún no lo ha hecho, vaya a programar su primera reunión con Meeting Planner. He seguido haciendo progresos increíbles hacia la versión beta, a pesar de las distracciones (la programacion es difícil):

También estoy planeando escribir un tutorial sobre crowdfunding, así que considere seguir nuestra página de WeFunder Meeting Planner.

Por favor comparte tus comentarios abajo. Siempre estoy abierto a nuevas ideas de características y sugerencias de temas para futuros tutoriales. También puede contactar conmigo @reifman.

Manténgase en sintonía para todo esto y más en tutoriales próximos, echa un vistazo a la serie construya su startup con PHP. Y definitivamente echa un vistazo a nuestra Programación con la serie Yii2 (Envato Tuts +).