<?php

namespace v1\controllers;

use app\models\Folio;
use app\models\Permiso;
use app\models\RecursoRevision;
use app\models\Solicitud;
use app\modules\mail\models\NotificacionCorreo;
use common\data\Respuesta;
use common\rest\AuthController;
use v1\models\BitacoraEstatus;
use v1\models\Estatus;
use v1\models\Media;
use v1\models\MediaBitacoraEstatus;
use v1\models\RecursoManifestacion;
use v1\models\RecursoManifestacionMedia;
use v1\models\RecursoRevisionMedia;
use v1\models\Solicitud as ModelsSolicitud;
use v1\models\SujetoObligado;
use v1\models\Usuario;
use yii\db\Expression;

class RecursoRevisionController extends AuthController {

	public $modelClass = "v1\models\RecursoRevision";
	public $permisos = [
		Permiso::RR_VER_DETALLE
	];

	public function actionIndex() {
		$id = trim($this->req->get("id", ""));
		$idSolicitud = trim($this->req->get("idSolicitud", ""));
		$buscar = trim($this->req->get("q", ""));

		$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;

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

		if (!$usuario->tienePermiso(Permiso::RR_VER_DETALLE)) {
			return (new Respuesta())
				->esError(401)
				->mensaje('No cuentas con los permisos para consultar esta información.');
		}

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

		if ($buscar) {
			$query->andWhere([
				"OR",
				"f_unaccent([[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", ""));
		$idSolicitud = trim($this->req->getBodyParam("idSolicitud", ""));
		$archivos = $this->req->getBodyParam("archivos", []);
		$esNuevo = false;

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

		$tran = \Yii::$app->getDb()->beginTransaction();
		try {
			if ($modelo === null) {
				$esNuevo = true;
				$modelo = new $this->modelClass();
				$modelo->uuid();
				$modelo->creado = new Expression('now()');
			} else {
				$modelo->modificado = new Expression('now()');
			}
			$modelo->load($this->req->getBodyParams(), '');

			$solicitud = Solicitud::findOne($idSolicitud);

			if ($modelo->isNewRecord) {
				$modelo->diasTranscurridos = 0;
				$modelo->diasRestantes = 40;
				$modelo->diasAmpliacion = 0;
				$modelo->tipo = RecursoRevision::TIPO_CON_SOLICITUD;
				$folio = '';
				$folioRR = null;
				$ano = date('Y');
				$folioRR = Folio::find()
					->andWhere(['tipo' => Folio::TIPO_RECURSO_REVISION])
					->andWhere(['ano' => $ano])
					->andWhere(['eliminado' => null])
					->one();

				if ($folioRR === null) {
					$tran->rollBack();
					return (new Respuesta())
						->esError()
						->mensaje("Hubo un problema al guardar el recurso. Folio no encontrado");
				}

				$incremental = $folioRR->incremental;

				$folioPrefijo = $solicitud->folio;

				// $folio = $solicitud->folio . '' . $folioRR->letra . '-' . $incremental;
				$folio = Folio::obtenerSiguienteRR($folioPrefijo);

				$modelo->folio = $folio;

				$folioRR->incremental = $incremental + 1;

				if (!$folioRR->save()) {
					$tran->rollBack();
					return (new Respuesta($folioRR))
						->mensaje("Hubo un problema al guardar el recurso");
				}

				$estatus = Estatus::find()
					->andWhere(['nombre' => 'Nuevo'])
					->andWhere(['tipo' => Estatus::TIPO_RECURSO_REVISION])
					->andWhere(['eliminado' => null])
					->one();

				$modelo->idEstatus = $estatus->id;

				$estatusBitacora = Estatus::find()
					->andWhere(['nombre' => Estatus::ESTATUS_RR])
					->andWhere(['eliminado' => null])
					->one();
				$solicitud->idEstatus = $estatusBitacora->id;
				if (!$solicitud->save()) {
					$tran->rollBack();
					return (new Respuesta($solicitud))
						->mensaje("Hubo un problema al guardar el recurso");
				}
				$bitacora = new BitacoraEstatus();
				$bitacora->uuid();
				$bitacora->idSolicitud = $idSolicitud;
				$bitacora->idUsuario = $this->usuario->id;
				$bitacora->estatusInicial = $solicitud->idEstatus;
				$bitacora->estatusFinal = $estatusBitacora->id;
				$bitacora->fechaCambio = new Expression('now()');
				$bitacora->idSujetoObligado = $solicitud->idSujetoObligado;
				$bitacora->creado = new Expression('now()');
				$bitacora->comentario = Estatus::ESTATUS_RR;
				if (!$bitacora->save()) {
					$tran->rollBack();
					return (new Respuesta($bitacora))
						->mensaje("Hubo un problema al guardar el recurso");
				}

				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");
					}
				}
			}

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

			$archivosAnteriores = RecursoRevisionMedia::find()
				->where(["idRecursoRevision" => $modelo->id])
				->all();

			foreach ($archivos as $archivo) {
				$archivoRecurso = null;
				$archivoRecurso = RecursoRevisionMedia::find()
					->andWhere(["idRecursoRevision" => $modelo->id])
					->andWhere(["idMedia" => $archivo['id']])
					->one();
				if ($archivoRecurso === null) {
					$archivoRecurso = new RecursoRevisionMedia();
					$archivoRecurso->creado = new Expression('now()');
				} else {
					$archivoRecurso->modificado = new Expression('now()');
					if ($archivoRecurso->eliminado) {
						$archivoRecurso->eliminado = null;
					}
				}

				$archivoRecurso->uuid();
				$archivoRecurso->idRecursoRevision = $modelo->id;
				$archivoRecurso->idMedia = $archivo['id'];

				if (!$archivoRecurso->save()) {
					$tran->rollBack();
					return (new Respuesta($archivoRecurso))
						->mensaje("Hubo un problema al guardar el archivo");
				}
			}

			foreach ($archivosAnteriores as $archivoAnterior) {
				if (!in_array($archivoAnterior->idMedia, $archivos)) {
					$archivoAnterior->eliminado = new Expression('now()');
					if (!$archivoAnterior->save()) {
						return (new Respuesta($archivoAnterior))
							->mensaje("Hubo un problema al eliminar el archivo");
					}
				}
			}
			$modelo->refresh();
			if ($esNuevo) {
				$correos = [];
				$correos[] = $modelo->solicitud->correo;
				$sujetoObligado = SujetoObligado::findOne($modelo->solicitud->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);

				$fechaNotificacion = date('d/m/Y H:m:s');
				$parametros = [
					"prioridad" => NotificacionCorreo::PRIORIDAD_2,
					"asunto" => "Notificación SIISTAI Recurso Revisión: {$modelo->folio} {$fechaNotificacion}",
					"cuerpo" => $this->render("acuse", ["recurso" => $modelo, "usuario" => $modelo->solicitud->usuario]),
					"receptores" => $correosFiltrados,
					"adjuntos" => [],
				];

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

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

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

	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("Recurso no encontrado");
		}

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

		return (new Respuesta())
			->mensaje("Recurso de revisión eliminado");
	}

	public function actionActualizarEstatus() {
		$idSolicitud = trim($this->req->getBodyParam('id', ''));
		$idRecurso = trim($this->req->getBodyParam('idRecurso', ''));
		$tipo = trim($this->req->getBodyParam('tipo', ''));
		$mensaje = trim($this->req->getBodyParam('comentario', ''));
		$referenciasEstatus = $this->req->getBodyParam('referenciasEstatus', []);
		$idEstatus = trim($this->req->getBodyParam('idEstatus', ''));
		$idPonencia = trim($this->req->getBodyParam('idPonencia', ''));
		$modelo = null;

		$usuario = $this->usuario;

		$transaccion = \Yii::$app->db->beginTransaction();

		try {
			if ($idRecurso === '') {
				$transaccion->rollBack();
				return (new Respuesta())
					->esError()
					->mensaje('No se enconró el recurso.');
			}

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

			if ($modelo === null) {
				$transaccion->rollBack();
				return (new Respuesta())
					->esError()
					->mensaje('No se enconró el recurso.');
			}

			$estatusActual = $modelo->idEstatus;

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

			if ($idPonencia !== '') {
				if ($modelo->idPonencia !== $idPonencia) {
					$usuarioPonencia = null;

					$usuarioPonencia = Usuario::find()
						->andWhere(['idPonencia' => $idPonencia])
						->andWhere(['is not', 'verificarCorreo', null])
						->andWhere(['eliminado' => null])
						->one();

					if ($usuarioPonencia !== null) {
						$fechaNotificacion = date('d/m/Y H:m:s');

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

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

					// turnado de ponencia
					
				}

				$modelo->idPonencia = $idPonencia;
			}
			$modelo->save();

			$recursoManifestacion = new RecursoManifestacion();

			$recursoManifestacion->uuid();
			$recursoManifestacion->idEmisor = $usuario->id;
			$recursoManifestacion->idSolicitud = $idSolicitud;
			$recursoManifestacion->idRecurso = $idRecurso;
			$recursoManifestacion->tipo = $tipo;
			$recursoManifestacion->idEstatusActualRecurso = $estatusActual;
			if ($idPonencia !== '') {
				$recursoManifestacion->idPonencia = $idPonencia;
			}
			$recursoManifestacion->mensaje = $mensaje;
			if ($idEstatus !== '') {
				$recursoManifestacion->idEstatusNuevoRecurso = $idEstatus;
			} else {
				$recursoManifestacion->idEstatusNuevoRecurso = $estatusActual;
			}
			$recursoManifestacion->creado = new Expression('now()');

			if (!$recursoManifestacion->save()) {
				$transaccion->rollBack();
				return (new Respuesta($recursoManifestacion))
					->mensaje("Hubo un problema al guardar el recurso de manifestación");
			}

			$recursoManifestacion->refresh();

			foreach ($referenciasEstatus as $archivo) {
				$media = new RecursoManifestacionMedia();
				$media->uuid();
				$media->idRecursoManifestacion = $recursoManifestacion->id;
				$media->idMedia = $archivo['id'];
				$media->creado = new Expression('now()');

				if (!$media->save()) {
					$transaccion->rollBack();
					return (new Respuesta($media))
						->mensaje("Hubo un problema al guardar el recurso de manifestación");
				}
			}

			$correos = [];
			$correos[] = $modelo->solicitud->correo;
			$sujetoObligado = SujetoObligado::findOne($modelo->solicitud->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);

			$fechaNotificacion = date('d/m/Y H:m:s');
			$parametros = [
				"prioridad" => NotificacionCorreo::PRIORIDAD_2,
				"asunto" => "Notificación SIISTAI Recurso Revisión: {$modelo->folio} {$fechaNotificacion}",
				"cuerpo" => $this->render("acuse", ["recurso" => $modelo, "usuario" => $modelo->solicitud->usuario]),
				"receptores" => $correosFiltrados,
				"adjuntos" => [],
			];

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

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

			return (new Respuesta($recursoManifestacion))
				->mensaje("Recurso manifestación guardado con éxito.");
		} catch (\Exception $e) {
			$transaccion->rollBack();
			return (new Respuesta())
				->esError($e)
				->mensaje("Hubo un error en el servidor");
		}
	}

	public function actionAmpliacion() {
		$id = trim($this->req->getBodyParam('id', ''));
		$modelo = null;

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

		if ($modelo === null) {
			return (new Respuesta())
				->esError()
				->mensaje('No se encontró el recurso.');
		}

		$modelo->diasAmpliacion = 20;
		$modelo->fechaAmpliacion = new Expression('now()');

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

		$modelo->refresh();
		return (new Respuesta($modelo))
			->mensaje("Recurso guardado con éxito.");
	}

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

		if ($idRecurso === "") {
			return (new Respuesta())
				->esError()
				->mensaje("Es necesario proporcionar un identificador de recurso de revisión");
		}

		$recursoManifestacion = RecursoManifestacion::find()
			->andWhere(['{{RecursoManifestacion}}.[[idRecurso]]' => $idRecurso]);

		$detalle = [];

		foreach ($recursoManifestacion->each() as $rm) {
			if (!isset($rm->media)) {
				continue;
			}
			$estatusAnterior = Estatus::find()
				->andWhere(['id' => $rm->idEstatusActualRecurso])
				->one();
			$estatusNuevo = Estatus::find()
				->andWhere(['id' => $rm->idEstatusNuevoRecurso])
				->one();
			foreach ($rm->media as $archivo) {
				$nombreUsuario = '';
				$usuario = Usuario::findOne($archivo->idUsuario);
				$nombreUsuario = $usuario->nombre;
			}
			$detalle[] = [
				'nombreUsuario' => $nombreUsuario,
				'estatusAnterior' => $estatusAnterior->nombre,
				'estatusNuevo' => $estatusNuevo->nombre,
				'mensaje' => $rm->mensaje,
				'media' => $archivo
			];
		}

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

	public function actionSolicitud() {
		$fechaSolicitud = trim($this->req->getBodyParam('fechaSSolicitud', ''));
		$correo = trim(($this->req->getBodyParam('correo', '')));
		$descripcion = trim(($this->req->getBodyParam('descripcion', '')));
		$idModalidadEntrega = intval(($this->req->getBodyParam('idModalidadEntrega', '')));
		$idSujetoObligado = intval(($this->req->getBodyParam('idSujetoObligado', '')));
		$telefono = trim(($this->req->getBodyParam('telefono', '')));
		// $telefonoMovil = trim(($this->req->getBodyParam('telefonoMovil', '')));
		$tipoSolicitud = intval($this->req->getBodyParam('tipoSolicitud', ''));
		$razonesMotivos = trim($this->req->getBodyParam('razonesMotivos', ''));
		$idMotivoIncoformidad = trim($this->req->getBodyParam('idMotivoIncoformidad', ''));
		$documentoAnexo = trim($this->req->getBodyParam('documentoAnexo', ''));
		$documentoAnexoOtro = trim($this->req->getBodyParam('documentoAnexoOtro', ''));
		$archivos = $this->req->getBodyParam('archivos', []);

		$usuario = $this->usuario;

		$modeloSolicitud = null;
		$modeloRecurso = null;

		$transaccion = \Yii::$app->getDb()->beginTransaction();
		try {
			$modeloSolicitud = new ModelsSolicitud();
			$modeloSolicitud->uuid();
			$modeloSolicitud->creado = new Expression('now()');
			$modeloSolicitud->recepcion = $fechaSolicitud;
			$modeloSolicitud->recepcionSistema = new Expression('now()');
			$modeloSolicitud->idUsuario = $usuario->id;
			$modeloSolicitud->idSujetoObligado = $idSujetoObligado;
			$modeloSolicitud->correo = $correo;
			$modeloSolicitud->descripcion = $descripcion;
			$modeloSolicitud->idModalidadEntrega = $idModalidadEntrega;
			$modeloSolicitud->telefono = $telefono;
			// $modeloSolicitud->telefonoMovil = $telefonoMovil;
			$modeloSolicitud->tipoSolicitud = $tipoSolicitud;

			$folioSolicitud = '';

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

			$estatusSolicitud = Estatus::findOne(['nombre' => Estatus::ESTATUS_RR]);
			$modeloSolicitud->idEstatus = $estatusSolicitud->id;
			$modeloSolicitud->idSujetoObligadoInicial = $idSujetoObligado;
			$tipo = '';
			if ($tipoSolicitud === 1) {
				$tipo = 'IP';
			}

			$sujetoObligado = SujetoObligado::findOne($idSujetoObligado);
			$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);

			$modeloSolicitud->folio = $folio;

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

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

			$bitacora = new BitacoraEstatus();
			$bitacora->uuid();
			$bitacora->idSolicitud = $modeloSolicitud->id;
			$bitacora->idUsuario = $usuario->id;
			$bitacora->estatusFinal = $estatusSolicitud->id;
			$bitacora->fechaCambio = $modeloSolicitud->creado;
			$bitacora->idSujetoObligado = $modeloSolicitud->idSujetoObligado;
			$bitacora->creado = new Expression('now()');
			$bitacora->comentario = 'Recurso de revisión con solicitud existente';
			if (!$bitacora->save()) {
				$transaccion->rollBack();
				return (new Respuesta($bitacora))
					->mensaje("Hubo un problema al guardar el folio del registro de la solicitud");
			}

			$modeloSolicitud->refresh();

			$modeloRecurso = new $this->modelClass();
			$modeloRecurso->uuid();
			$modeloRecurso->creado = new Expression('now()');
			$modeloRecurso->tipo = RecursoRevision::TIPO_SIN_SOLICITUD;
			$modeloRecurso->idSolicitud = $modeloSolicitud->id;

			$modeloRecurso->actoImpugnado = $descripcion;
			$modeloRecurso->razonesMotivos = $razonesMotivos;
			$modeloRecurso->idMotivoIncoformidad = $idMotivoIncoformidad;

			$prefijoFolioRR = $modeloSolicitud->folio;
			$folioRecurso = Folio::obtenerSiguienteRR($prefijoFolioRR);
			$modeloRecurso->folio = $folioRecurso;

			$estatusRR = Estatus::find()
				->andWhere(['nombre' => 'Nuevo'])
				->andWhere(['tipo' => Estatus::TIPO_RECURSO_REVISION])
				->andWhere(['eliminado' => null])
				->one();

			$modeloRecurso->idEstatus = $estatusRR->id;
			$modeloRecurso->documentoAnexo = $documentoAnexo;

			if ($documentoAnexo === 'Otro') {
				$modeloRecurso->documentoAnexoOtro = $documentoAnexoOtro;
			}

			if (!$modeloRecurso->save()) {
				$transaccion->rollBack();
				return (new Respuesta($modeloRecurso))
					->mensaje("Hubo un problema al guardar el recurso");
			}

			$modeloRecurso->refresh();

			foreach ($archivos as $archivo) {
				$archivoRecurso = new RecursoRevisionMedia();
				$archivoRecurso->creado = new Expression('now()');

				$archivoRecurso->uuid();
				$archivoRecurso->idRecursoRevision = $modeloRecurso->id;
				$archivoRecurso->idMedia = $archivo['id'];

				if (!$archivoRecurso->save()) {
					$transaccion->rollBack();
					return (new Respuesta($archivoRecurso))
						->mensaje("Hubo un problema al guardar el archivo");
				}

				//**************************
				$mediaBitacora = new MediaBitacoraEstatus();

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

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

			$correos = [];
			$correos[] = $correo;
			$sujetoObligado = SujetoObligado::findOne($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);

			$fechaNotificacion = date('d/m/Y H:m:s');
			$parametros = [
				"prioridad" => NotificacionCorreo::PRIORIDAD_2,
				"asunto" => "Notificación SIISTAI Recurso Revisión: {$modeloRecurso->folio} {$fechaNotificacion}",
				"cuerpo" => $this->render("acuse", ["recurso" => $modeloRecurso, "usuario" => $modeloSolicitud->usuario]),
				"receptores" => $correosFiltrados,
				"adjuntos" => [],
			];

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

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

			return (new Respuesta($modeloRecurso))
				->mensaje("Recurso guardado con éxito.");
		} catch (\Exception $e) {
			$transaccion->rollBack();
			return (new Respuesta())
				->esError()
				->mensaje("Hubo un error en el servidor: " . $e->getMessage());
		}
	}
}