<?php

namespace v1\controllers;

use app\models\Folio;
use app\modules\mail\models\NotificacionCorreo;
use common\data\Respuesta;
use common\rest\AuthController;
use DateTime;
use DateTimeZone;
use v1\models\Aclaracion;
use v1\models\AclaracionMedia;
use v1\models\BitacoraEstatus;
use v1\models\Estatus;
use v1\models\Media;
use v1\models\MediaBitacoraEstatus;
use v1\models\Permiso;
use v1\models\PermisoUsuario;
use v1\models\Solicitud;
use v1\models\SolicitudMedia;
use v1\models\SujetoObligado;
use v1\models\Usuario;
use yii\db\Expression;

class SolicitudController extends AuthController {

  public $modelClass = "v1\models\Solicitud";
  public $permisos = [
    Permiso::PERFIL_SOLICITANTE,
    Permiso::PERFIL_COMISIONADO,
    Permiso::PERFIL_UNIDAD_TRANSPARENCIA,
    Permiso::PERFIL_PONENCIA,
    Permiso::PERFIL_PROYECTISTA,
    Permiso::SOLICITUD_VER_TODO,
  ];

  public function actionIndex() {
    $id = trim($this->req->get("id", ""));
    $buscar = trim($this->req->get("q", ""));
    $idSujetoObligado = intval($this->req->get('idSujetoObligado', ''));
    $idEstatus = trim($this->req->get('idEstatus', ''));
    $fechaInicio = trim($this->req->get("fechaInicio", ""));
    $fechaFin = trim($this->req->get("fechaFin", ""));

    $usuario = $this->usuario;
    if (!$usuario->validarPerfilPermisos()) {
      return (new Respuesta())
        ->esError(403)
        ->mensaje('No cuentas con los permisos para consultar esta información.');
    }

    $query = $this->queryInicial
      ->innerJoin('SujetoObligado', '{{SujetoObligado}}.id = {{Solicitud}}.[[idSujetoObligado]]')
      ->leftJoin('RecursoRevision', '{{RecursoRevision}}.[[idSolicitud]] = {{Solicitud}}.id')
      ->distinct();

    if ($usuario->tienePermiso(Permiso::PERFIL_SOLICITANTE)) {
      $query->andWhere(['{{Solicitud}}.[[idUsuario]]' => $usuario->id]);
    }

    if (!$usuario->tienePermiso(Permiso::SOLICITUD_VER_TODO)) {
      if ($usuario->tienePermiso(Permiso::PERFIL_UNIDAD_TRANSPARENCIA)) {
        $estatusNuevoRR = Estatus::find()
          ->select('id')
          ->andWhere(['nombre' => Estatus::ESTATUS_RR_NUEVO])
          ->andWhere(['eliminado' => null]);
        
        $query->andWhere(['{{Solicitud}}.[[idSujetoObligado]]' => $usuario->idSujetoObligado])
          ->andWhere([
            'OR',
            '{{RecursoRevision}}.[[id]] is null',
            [
              'AND',
              '{{RecursoRevision}}.[[idPonencia]] is not null',
              ['!=', '{{RecursoRevision}}.[[idEstatus]]', $estatusNuevoRR]
            ]
          ]);
      }

      if ($usuario->tienePermiso(Permiso::PERFIL_PONENCIA) || $usuario->tienePermiso(Permiso::PERFIL_PROYECTISTA)) {
        $query->andWhere(['{{RecursoRevision}}.[[idPonencia]]' => $usuario->idPonencia]);
      }
    }


    /* if ($usuario->tienePermiso(Permiso::PERFIL_UNIDAD_TRANSPARENCIA)) {
      $query->andWhere(['idUsuario' => $usuario->id]);
    } */

    if ($id !== "") {
      $query->andWhere(["{{Solicitud}}.id" => $id]);
    }

    if ($idSujetoObligado > 0) {
      $query->andWhere(['{{Solicitud}}.[[idSujetoObligado]]' => $idSujetoObligado]);
    }

    if ($idEstatus !== '') {
      $query
        ->andWhere([
          'OR',
          ['{{Solicitud}}.[[idEstatus]]' => $idEstatus],
          ['{{RecursoRevision}}.[[idEstatus]]' => $idEstatus]
        ]);
    }

    if ($fechaInicio !== "" && $fechaFin !== "") {
      $query->andWhere([
        "AND",
        [">=", "{{Solicitud}}.recepcion", $fechaInicio],
        ["<=", "{{Solicitud}}.recepcion", $fechaFin],
      ]);
    }

    if ($buscar) {
      $query->andWhere([
        "OR",
        "f_unaccent({{Solicitud}}.[[folio]]) ilike f_unaccent(:q)",
        "f_unaccent({{SujetoObligado}}.[[nombre]]) ilike f_unaccent(:q)",
      ])->addParams([':q' => "%{$buscar}%"]);
    }

    return new Respuesta($query, $this->limite, $this->pagina, $this->ordenar);
  }

  public function actionGuardar() {
    $id = trim($this->req->getBodyParam("id", ""));
    $idSujetoObligado = intval($this->req->getBodyParam('idSujetoObligado', ''));
    $archivos = $this->req->getBodyParam("archivos", []);

    $usuario = $this->usuario;
    $esNuevo = false;

    $modelo = null;
    if ($id !== "") {
      $modelo = $this->modelClass::findOne($id);
    }

    $tran = \Yii::$app->getDb()->beginTransaction();
    try {
      if ($modelo === null) {
        $modelo = new $this->modelClass();
        $modelo->uuid();
        $modelo->creado = new Expression('now()');
        $modelo->recepcion = new Expression('now()');
        $modelo->recepcionSistema = new Expression('now()');
      } else {
        $modelo->modificado = new Expression('now()');
      }

      $modelo->load($this->req->getBodyParams(), '');
      $modelo->idUsuario = $usuario->id;

      $folio = '';

      $modeloFolio = Folio::find()
        ->andWhere(['tipo' => 'Solicitud'])
        ->one();

      if ($modelo->isNewRecord) {
        $esNuevo = true;
      }

      if ($esNuevo) {

        $modelo->diasTranscurridos = 0;
        $modelo->diasRestantes = 15;
        $modelo->diasAtencion = 0;
        $estatus = Estatus::findOne(["nombre" => Estatus::ESTATUS_INICIAL]);
        $modelo->idEstatus = $estatus->id;
        $modelo->idSujetoObligadoInicial = $idSujetoObligado;
        $sujetoObligado = SujetoObligado::findOne($modelo->idSujetoObligado);
        $tipo = '';
        if ($modelo->tipoSolicitud === 1) {
          $tipo = 'IP';
        }

        $ano = date('y');
        $claveEstado = '';
        $claveSujetoObligado = '';
        if (isset($sujetoObligado->estado->clave)) {
          $claveEstado = $sujetoObligado->estado->clave;
        }
        if (isset($sujetoObligado->clave)) {
          $claveSujetoObligado = $sujetoObligado->clave;
        }

        if ($sujetoObligado->secuencialSolicitud === null) {
          $sujetoObligado->secuencialSolicitud = 1;
          $sujetoObligado->save();
        }

        $folio = $claveEstado . '' . $claveSujetoObligado . '' . $ano . '' . str_pad($sujetoObligado->secuencialSolicitud, 6, '0', 0);

        // $folio = str_pad($modeloFolio->incremental, 3, '0', 0) . '/' . $sujetoObligado->sigla . '/' . $tipo . '/' . $modeloFolio->ano;

        $modelo->folio = $folio;

        $sujetoObligado->secuencialSolicitud = $sujetoObligado->secuencialSolicitud + 1;
        $sujetoObligado->save();
      }

      if (!$modelo->save()) {
        return (new Respuesta($modelo))
          ->mensaje("Hubo un problema al guardar el registro de la solicitud");
      }

      if ($esNuevo) {
        $bitacora = new BitacoraEstatus();
        $bitacora->uuid();
        $bitacora->idSolicitud = $modelo->id;
        $bitacora->idUsuario = $usuario->id;
        $bitacora->estatusFinal = $estatus->id;
        $bitacora->fechaCambio = $modelo->creado;
        $bitacora->idSujetoObligado = $modelo->idSujetoObligado;
        $bitacora->creado = new Expression('now()');
        $bitacora->comentario = 'Nueva solicitud';
        if (!$bitacora->save()) {
          $tran->rollBack();
          return (new Respuesta($bitacora))
            ->mensaje("Hubo un problema al guardar el folio del registro de la solicitud");
        }

        foreach ($archivos as $archivo) {
          $media = new MediaBitacoraEstatus();

          $media->idMedia = $archivo['id'];
          $media->idBitacoraEstatus = $bitacora->id;
          $media->uuid();
          $media->creado = new Expression('now()');

          if (!$media->save()) {
            $tran->rollBack();
            return (new Respuesta($media))
              ->mensaje("Hubo un problema al guardar el registro de la solicitud");
          }
        }
      }

      // $modeloFolio->incremental = $modeloFolio->incremental + 1;

      /* if (!$modeloFolio->save()) {
        return (new Respuesta($modeloFolio))
          ->mensaje("Hubo un problema al guardar el folio del registro de la solicitud");
      } */

      foreach ($archivos as $archivo) {
        $media = new SolicitudMedia();

        $media->idMedia = $archivo['id'];
        $media->idSolicitud = $modelo->id;
        $media->uuid();
        $media->creado = new Expression('now()');

        if (!$media->save()) {
          $tran->rollBack();
          return (new Respuesta($media))
            ->mensaje("Hubo un problema al guardar el registro de la solicitud");
        }
      }

      $modelo->refresh();
      /* Guardado de notificación de correo */
      if ($esNuevo) {
        $correos = [];
        $correos[] = $modelo->correo;
        $sujetoObligado = SujetoObligado::findOne($modelo->idSujetoObligado);
        $usuariosSujetoObligado = $sujetoObligado->usuarios;
        if (isset($sujetoObligado->correoInstitucional)) {
          $correos[] = $sujetoObligado->correoInstitucional;
        }

        foreach ($usuariosSujetoObligado as $usrSO) {
          if ($usrSO['verificarCorreo'] !== null) {
            $correos[] = $usrSO['correo'];
          }
        }

        $correosFiltrados = array_unique($correos);

        $tz = new DateTimeZone('America/Hermosillo');
        $fechaNotificacion = new DateTime();
        $fechaNotificacion->setTimezone($tz);
        $fechaNotificacion = $fechaNotificacion->format('d/m/Y H:i a');

        $parametros = [
          "prioridad" => NotificacionCorreo::PRIORIDAD_2,
          "asunto" => "Notificación SIISTAI Solicitud: {$modelo->folio} {$fechaNotificacion}",
          "cuerpo" => $this->render("acuse", ["solicitud" => $modelo, "usuario" => $modelo->usuario]),
          "receptores" => $correosFiltrados,
          "adjuntos" => [],
        ];

        $resultado = NotificacionCorreo::enviarMultiple($parametros);
      }
      $tran->commit();

      return (new Respuesta($modelo))
        ->mensaje("Registro de solicitud guardado con éxito.");
    } catch (\Exception $e) {
      $tran->rollBack();
      return (new Respuesta())
        ->esError()
        ->mensaje("Hubo un error en el servidor");
    }
  }

  public function actionEliminar() {
    $id = intval($this->req->getBodyParam("id", null));
    $modelo = null;

    if ($id !== "") {
      $modelo = $this->modelClass::findOne(["id" => $id]);
    }
    if ($modelo === null) {
      return (new Respuesta())
        ->esError()
        ->mensaje("Registro de solicitud no encontrado");
    }

    $modelo->eliminado = new Expression('now()');
    if (!$modelo->save()) {
      return (new Respuesta($modelo))
        ->mensaje("No se pudo eliminar el registro del solicitud");
    }

    return (new Respuesta())
      ->mensaje("Registro de solicitud eliminado");
  }

  public function actionActualizarEstatus() {
    $id = trim($this->req->getBodyParam("id", ""));
    $idEstatusInicial = trim($this->req->getBodyParam("idEstatusInicial", ''));
    $idEstatusFinal = trim($this->req->getBodyParam("idEstatusFinal", ''));
    $idTema = trim($this->req->getBodyParam("idTema", ''));
    $idSubtema = trim($this->req->getBodyParam("idSubtema", ''));
    $idEstatusIncompetencia = trim($this->req->getBodyParam("idEstatusIncompetencia", ''));
    $idEstatusNegativa = trim($this->req->getBodyParam("idEstatusNegativa", ''));
    $comentarios = trim($this->req->getBodyParam("comentario", ''));
    $idSujetoObligado = intval($this->req->getBodyParam("idSujetoObligado", ''));
    $referenciasEstatus = $this->req->getBodyParam("referenciasEstatus", []);
    $tipoAclaracion = trim($this->req->getBodyParam("tipoAclaracion", ''));

    $usuario = $this->usuario;

    $modelo = null;

    $tran = \Yii::$app->db->beginTransaction();
    try {
      if ($id === "") {
        $tran->rollBack();
        return (new Respuesta())
          ->esError()
          ->mensaje('No fue posible encontrar la solucitud seleccionada');
      }

      $modelo = $this->modelClass::findOne($id);

      $modelo->modificado = new Expression('now()');

      $nombreEstatusFinal = Estatus::findOne($idEstatusFinal);

      if ($idTema !== '') {
        $modelo->idTema = $idTema;
      }

      if ($idSubtema !== '') {
        $modelo->idSubtema = $idSubtema;
      }

      if ($idEstatusFinal !== '') {
        $modelo->idEstatus = $idEstatusFinal;
      }

      if (!$modelo->save()) {
        $tran->rollBack();
        return (new Respuesta($modelo))
          ->mensaje("Hubo un problema al guardar el registro de la solicitud");
      }

      if ($idEstatusFinal !== '') {
        $bitacora = new BitacoraEstatus();
        $bitacora->uuid();
        $bitacora->idSolicitud = $modelo->id;
        $bitacora->comentario = $comentarios;
        if ($idEstatusInicial !== '') {
          $bitacora->estatusInicial = $idEstatusInicial;
        }
        if ($idEstatusFinal !== '') {
          $bitacora->estatusFinal = $idEstatusFinal;
        }
        $bitacora->fechaCambio = new Expression('now()');
        $bitacora->creado = new Expression('now()');
        $bitacora->idUsuario = $usuario->id;

        if ($idEstatusIncompetencia !== '') {
          $bitacora->idEstatusIncompetencia = $idEstatusIncompetencia;
          $bitacora->declinado = new Expression('now()');
          $bitacora->idUsuarioDeclina = $usuario->id;
          $bitacora->idSujetoObligado = $idSujetoObligado;

          $solicitudDerivada = new Solicitud();
          $solicitudDerivada->load($modelo, "");
          $solicitudDerivada->uuid();
          $solicitudDerivada->creado = new Expression('now()');
          $solicitudDerivada->recepcion = new Expression('now()');
          $solicitudDerivada->recepcionSistema = new Expression('now()');
          $estatus = Estatus::findOne(["nombre" => Estatus::ESTATUS_INICIAL]);
          $solicitudDerivada->idEstatus = $estatus->id;
          $solicitudDerivada->idSujetoObligadoInicial = $idSujetoObligado;
          $solicitudDerivada->idSujetoObligado = $idSujetoObligado;
          $sujetoObligadoModelo = SujetoObligado::findOne($idSujetoObligado);
          $ano = date('y');
          $claveEstado = '26';
          $claveSujetoObligado = '05024';
          if (isset($sujetoObligadoModelo->estado->clave)) {
            $claveEstado = $sujetoObligadoModelo->estado->clave;
          }
          if (isset($sujetoObligadoModelo->clave)) {
            $claveSujetoObligado = $sujetoObligadoModelo->clave;
          }

          if ($sujetoObligadoModelo->secuencialSolicitud === null) {
            $sujetoObligadoModelo->secuencialSolicitud = 1;
            $sujetoObligadoModelo->save();
          }

          $folio = $claveEstado . '' . $claveSujetoObligado . '' . $ano . '' . str_pad($sujetoObligadoModelo->secuencialSolicitud, 6, '0', 0);

          $solicitudDerivada->folio = $folio;

          if (!$solicitudDerivada->save()) {
            $tran->rollBack();
            return (new Respuesta($solicitudDerivada))
              ->mensaje("Hubo un problema al guardar el folio del registro de la solicitud");
          }

          $bitacoraDerivada = new BitacoraEstatus();
          $bitacoraDerivada->uuid();
          $bitacoraDerivada->idSolicitud = $solicitudDerivada->id;
          $bitacoraDerivada->idUsuario = $usuario->id;
          $bitacoraDerivada->estatusFinal = $estatus->id;
          $bitacoraDerivada->fechaCambio = $solicitudDerivada->creado;
          $bitacoraDerivada->idSujetoObligado = $solicitudDerivada->idSujetoObligado;
          $bitacoraDerivada->creado = new Expression('now()');
          $bitacoraDerivada->comentario = 'Nueva solicitud';
          if (!$bitacoraDerivada->save()) {
            $tran->rollBack();
            return (new Respuesta($bitacoraDerivada))
              ->mensaje("Hubo un problema al guardar el folio del registro de la solicitud");
          }

          $archivos = $modelo->media;

          if ($archivos && count($archivos) > 0) {
            foreach ($archivos as $archivo) {
              $media = new SolicitudMedia();

              $media->idMedia = $archivo['id'];
              $media->idSolicitud = $solicitudDerivada->id;
              // $media->uuid();
              $media->creado = new Expression('now()');

              if (!$media->save()) {
                $tran->rollBack();
                return (new Respuesta($media))
                  ->mensaje("Hubo un problema al guardar el registro de la solicitud");
              }
            }
          }

          $modelo->idSolicitudDerivada = $solicitudDerivada->id;
          $modelo->idSujetoObligado = $idSujetoObligado;
          $modelo->motivoDeclinacion = $comentarios;
          $modelo->declinado = new Expression('now()');
          $modelo->idUsuarioDeclina = $usuario->id;

          if (!$modelo->save()) {
            $tran->rollBack();
            return (new Respuesta($modelo))
              ->mensaje("Hubo un problema al guardar el registro de la solicitud");
          }
        }

        if ($idEstatusNegativa !== '') {
          $bitacora->idEstatusNegativa = $idEstatusNegativa;
        }

        if ($nombreEstatusFinal->nombre === Estatus::ESTATUS_ACLARACION) {
          $aclaracion = new Aclaracion();

          $aclaracion->uuid();
          $aclaracion->idSolicitud = $modelo->id;
          $aclaracion->idSolicitaAclaracion = $usuario->id;
          $aclaracion->solicitado = new Expression('now()');
          $aclaracion->tipo = 'solicitud';
          $aclaracion->tipoAclaracion = $tipoAclaracion;
          $aclaracion->solicitudAclaracion = $comentarios;
          $aclaracion->creado = new Expression('now()');

          if (!$aclaracion->save()) {
            $tran->rollBack();
            return (new Respuesta($aclaracion))
              ->mensaje("Hubo un problema al guardar el registro de la solicitud");
          }

          foreach ($referenciasEstatus as $archivo) {
            $media = new AclaracionMedia();

            $media->idMedia = $archivo['id'];
            $media->idAclaracion = $aclaracion->id;
            $media->tipo = 'solicitud';
            $media->creado = new Expression('now()');

            if (!$media->save()) {
              $tran->rollBack();
              return (new Respuesta($media))
                ->mensaje("Hubo un problema al guardar el registro de la solicitud");
            }
          }
        }

        if (!$bitacora->save()) {
          $tran->rollBack();
          return (new Respuesta($bitacora))
            ->mensaje("Hubo un problema al guardar el registro de la solicitud");
        }

        $bitacora->refresh();

        foreach ($referenciasEstatus as $archivo) {
          $media = new MediaBitacoraEstatus();

          $media->uuid();
          $media->idMedia = $archivo['id'];
          $media->idBitacoraEstatus = $bitacora->id;
          $media->creado = new Expression('now()');

          if (!$media->save()) {
            $tran->rollBack();
            return (new Respuesta($media))
              ->mensaje("Hubo un problema al guardar el registro de la solicitud");
          }
        }
      }

      //Enviar correo con cambio de solicitud
      $correos = [];
      $correos[] = $modelo->correo;
      $sujetoObligado = SujetoObligado::findOne($modelo->idSujetoObligado);
      $usuariosSujetoObligado = $sujetoObligado->usuarios;
      if (isset($sujetoObligado->correoInstitucional)) {
        $correos[] = $sujetoObligado->correoInstitucional;
      }

      foreach ($usuariosSujetoObligado as $usrSO) {
        if ($usrSO['verificarCorreo'] !== null) {
          $correos[] = $usrSO['correo'];
        }
      }

      $correosFiltrados = array_unique($correos);

      $tz = new DateTimeZone('America/Hermosillo');
      $fechaNotificacion = new DateTime();
      $fechaNotificacion->setTimezone($tz);
      $fechaNotificacion = $fechaNotificacion->format('d/m/Y H:i a');

      $parametros = [
        "prioridad" => NotificacionCorreo::PRIORIDAD_2,
        "asunto" => "Notificación SIISTAI Solicitud: {$modelo->folio} {$fechaNotificacion}",
        "cuerpo" => $this->render("acuse", ["solicitud" => $modelo, "usuario" => $modelo->usuario]),
        "receptores" => $correosFiltrados,
        "adjuntos" => [],
      ];

      $resultado = NotificacionCorreo::enviarMultiple($parametros);

      $tran->commit();
      $modelo->refresh();

      return (new Respuesta($modelo))
        ->mensaje("Solicitud guardada con éxito.");
    } catch (\Exception $e) {
      $tran->rollBack();
      return (new Respuesta())
        ->esError($e)
        ->mensaje("Hubo un error en el servidor");
    }
  }

  public function actionExpediente() {
    $idSolicitud = trim($this->req->get("idSolicitud", ""));

    if ($idSolicitud === "") {
      return (new Respuesta())
        ->esError()
        ->mensaje("Es necesario proporcionar un identificador de solicitud");
    }

    $bitacoraSolicitud = BitacoraEstatus::find()
      ->andWhere(['{{BitacoraEstatus}}.[[idSolicitud]]' => $idSolicitud]);

    $detalle = [];

    foreach ($bitacoraSolicitud->each() as $bs) {
      if (!isset($bs->media)) {
        continue;
      }
      $estatusAnterior = null;
      $estatusAnterior = Estatus::find()
        ->andWhere(['id' => $bs->estatusInicial])
        ->one();
      $estatusInicial = '';
      if ($estatusAnterior !== null) {
        $estatusInicial = $estatusAnterior->nombre;
      }
      $estatusNuevo = Estatus::find()
        ->andWhere(['id' => $bs->estatusFinal])
        ->one();
      foreach ($bs->media as $archivo) {
        $nombreUsuario = '';
        $usuario = Usuario::findOne($archivo->idUsuario);
        $nombreUsuario = $usuario->nombre;
      }
      $detalle[] = [
        'nombreUsuario' => $nombreUsuario,
        'estatusAnterior' => $estatusInicial,
        'estatusNuevo' => $estatusNuevo->nombre,
        'mensaje' => $bs->comentario,
        'media' => $archivo
      ];
    }

    return (new Respuesta())
      ->detalle($detalle);
  }

  public function actionDeclinar() {
    $id = trim($this->req->getBodyParam("id", ""));
    $idSujetoObligado = intval($this->req->getBodyParam("idSujetoObligado", ''));
    $motivoDeclinacion = trim($this->req->getBodyParam("motivoDeclinacion", ''));

    $usuario = $this->usuario;

    $modelo = null;

    // $tran = \Yii::$app->db()->beginTransaction();
    $transaccion = \Yii::$app->db->beginTransaction();
    try {
      if ($id === "") {
        $transaccion->rollBack();
        return (new Respuesta())
          ->esError()
          ->mensaje('No fue posible encontrar la solucitud seleccionada');
      }

      $modelo = $this->modelClass::findOne($id);

      $modelo->modificado = new Expression('now()');
      $modelo->idSujetoObligado = $idSujetoObligado;
      $modelo->motivoDeclinacion = $motivoDeclinacion;
      $modelo->declinado = new Expression('now()');
      $modelo->idUsuarioDeclina = $usuario->id;

      if (!$modelo->save()) {
        $transaccion->rollBack();
        return (new Respuesta($modelo))
          ->mensaje("Hubo un problema al guardar el registro de la solicitud");
      }

      $bitacora = new BitacoraEstatus();
      $bitacora->uuid();
      $bitacora->idSolicitud = $modelo->id;
      $bitacora->estatusInicial = $modelo->idEstatus;
      $bitacora->estatusFinal = $modelo->idEstatus;
      $bitacora->fechaCambio = new Expression('now()');
      $bitacora->creado = new Expression('now()');
      $bitacora->idUsuario = $usuario->id;
      $bitacora->idSujetoObligado = $idSujetoObligado;
      $bitacora->motivoDeclinacion = $motivoDeclinacion;
      $bitacora->declinado = new Expression('now()');
      $bitacora->idUsuarioDeclina = $usuario->id;

      if (!$bitacora->save()) {
        $transaccion->rollBack();
        return (new Respuesta($bitacora))
          ->mensaje("Hubo un problema al guardar el registro de la solicitud");
      }

      $transaccion->commit();
      $modelo->refresh();

      return (new Respuesta($modelo))
        ->mensaje("Solicitud guardada con éxito.");
    } catch (\Exception $e) {
      $transaccion->rollBack();
      return (new Respuesta())
        ->esError($e)
        ->mensaje("Hubo un error en el servidor");
    }
  }
}