761 lines
31 KiB
JavaScript
761 lines
31 KiB
JavaScript
// Module de gestion des boutons de la modale
|
|
// Contient les gestionnaires d'événements pour tous les boutons de la modale
|
|
|
|
import { deleteEvent, changeEventStatus, apiFetch } from './agenda-api.js';
|
|
import { notifyError, notifySuccess } from './agenda-notifications.js';
|
|
import { populateSelects } from './agenda-modal-select.js';
|
|
import { fillFormWithEvent, clearFormErrors, handleEventFormSubmit } from './agenda-modal-forms.js';
|
|
import { updateModalDisplay, fillViewBlock } from './agenda-modal-display.js';
|
|
|
|
/**
|
|
* Helper pour gérer l'overlay de chargement
|
|
* @param {Function} asyncAction - Action asynchrone à exécuter
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async function withLoadingOverlay(asyncAction) {
|
|
const overlayTarget = document.querySelector('#eventModal .modal-content') || document.getElementById('eventModal');
|
|
try {
|
|
if (window.CRVI_OVERLAY && overlayTarget) {
|
|
window.CRVI_OVERLAY.show(overlayTarget);
|
|
}
|
|
await asyncAction();
|
|
} finally {
|
|
if (window.CRVI_OVERLAY && overlayTarget) {
|
|
window.CRVI_OVERLAY.hide(overlayTarget);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper pour rafraîchir les calendriers
|
|
*/
|
|
function refreshCalendars() {
|
|
if (window.currentCalendar) {
|
|
window.currentCalendar.refetchEvents();
|
|
}
|
|
if (window.currentColleaguesCalendar) {
|
|
window.currentColleaguesCalendar.refetchEvents();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper pour fermer le modal
|
|
* @param {Function} onClosed - Callback après fermeture
|
|
*/
|
|
function closeModal(onClosed = null) {
|
|
const modal = document.getElementById('eventModal');
|
|
if (modal) {
|
|
const bsModal = bootstrap.Modal.getInstance(modal);
|
|
if (bsModal) {
|
|
if (onClosed) {
|
|
modal.addEventListener('hidden.bs.modal', onClosed, { once: true });
|
|
}
|
|
bsModal.hide();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vérifie les permissions utilisateur
|
|
* @param {string} permission - Type de permission ('can_edit', 'can_delete', 'can_create')
|
|
* @returns {boolean}
|
|
*/
|
|
function checkPermission(permission) {
|
|
const hasPermission = window.crviPermissions && window.crviPermissions[permission];
|
|
if (!hasPermission) {
|
|
console.warn(`Utilisateur non autorisé: ${permission}`);
|
|
}
|
|
return hasPermission;
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton de fermeture
|
|
* @param {string} buttonId - ID du bouton
|
|
*/
|
|
export function initializeCloseButton(buttonId) {
|
|
const button = document.getElementById(buttonId);
|
|
if (button) {
|
|
button.onclick = () => closeModal();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton de suppression
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} onDeleted - Callback après suppression
|
|
*/
|
|
export function initializeDeleteButton(getCurrentEventData, onDeleted = null) {
|
|
const deleteBtn = document.getElementById('deleteEvent');
|
|
if (!deleteBtn) return;
|
|
|
|
deleteBtn.onclick = async function() {
|
|
if (!checkPermission('can_delete')) return;
|
|
|
|
if (!confirm('Êtes-vous sûr de vouloir supprimer cet événement ?')) {
|
|
return;
|
|
}
|
|
|
|
const currentEventData = getCurrentEventData();
|
|
const eventId = currentEventData ? currentEventData.id : null;
|
|
|
|
if (!eventId) {
|
|
notifyError('ID d\'événement manquant');
|
|
return;
|
|
}
|
|
|
|
await withLoadingOverlay(async () => {
|
|
try {
|
|
await deleteEvent(eventId);
|
|
refreshCalendars();
|
|
closeModal(onDeleted);
|
|
} catch (error) {
|
|
console.error('Erreur lors de la suppression:', error);
|
|
notifyError('Erreur lors de la suppression de l\'événement');
|
|
}
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton de validation de présence
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} openCheckPresenceModal - Fonction pour ouvrir la modal de validation de présence de groupe
|
|
* @param {Function} onStatusChanged - Callback après changement de statut
|
|
*/
|
|
export function initializeMarkPresentButton(getCurrentEventData, openCheckPresenceModal, onStatusChanged = null) {
|
|
const markPresentBtn = document.getElementById('markPresentBtn');
|
|
if (!markPresentBtn) return;
|
|
|
|
markPresentBtn.onclick = async function() {
|
|
if (!checkPermission('can_edit')) return;
|
|
|
|
const currentEventData = getCurrentEventData();
|
|
const eventId = currentEventData ? currentEventData.id : null;
|
|
|
|
if (!eventId) {
|
|
notifyError('ID d\'événement manquant');
|
|
return;
|
|
}
|
|
|
|
// Vérifier le type d'événement
|
|
const eventType = currentEventData?.type || currentEventData?.extendedProps?.type || '';
|
|
const isGroupe = eventType === 'groupe';
|
|
|
|
if (isGroupe) {
|
|
// Pour les événements de groupe, ouvrir la modal de validation des présences
|
|
openCheckPresenceModal(currentEventData);
|
|
} else {
|
|
// Pour les événements individuels
|
|
if (!confirm('Confirmer la présence à cet événement ?')) {
|
|
return;
|
|
}
|
|
|
|
await withLoadingOverlay(async () => {
|
|
try {
|
|
await changeEventStatus(eventId, 'present');
|
|
notifySuccess('Présence validée');
|
|
refreshCalendars();
|
|
closeModal(onStatusChanged);
|
|
} catch (error) {
|
|
console.error('Erreur lors du changement de statut:', error);
|
|
notifyError('Erreur lors de la validation de présence');
|
|
}
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton pour marquer comme absent
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} onStatusChanged - Callback après changement de statut
|
|
*/
|
|
export function initializeMarkAbsentButton(getCurrentEventData, onStatusChanged = null) {
|
|
const markAbsentBtn = document.getElementById('markAbsentBtn');
|
|
if (!markAbsentBtn) return;
|
|
|
|
markAbsentBtn.onclick = async function() {
|
|
if (!checkPermission('can_edit')) return;
|
|
|
|
const currentEventData = getCurrentEventData();
|
|
const eventId = currentEventData ? currentEventData.id : null;
|
|
|
|
if (!eventId) {
|
|
notifyError('ID d\'événement manquant');
|
|
return;
|
|
}
|
|
|
|
if (!confirm('Marquer cet événement comme absent ?')) {
|
|
return;
|
|
}
|
|
|
|
await withLoadingOverlay(async () => {
|
|
try {
|
|
await changeEventStatus(eventId, 'absence');
|
|
notifySuccess('Événement marqué comme absent');
|
|
refreshCalendars();
|
|
closeModal(onStatusChanged);
|
|
} catch (error) {
|
|
console.error('Erreur lors du changement de statut:', error);
|
|
notifyError('Erreur lors du changement de statut');
|
|
}
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton d'annulation de rendez-vous
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} onCancelled - Callback après annulation
|
|
*/
|
|
export function initializeCancelAppointmentButton(getCurrentEventData, onCancelled = null) {
|
|
const cancelAppointmentBtn = document.getElementById('cancelAppointmentBtn');
|
|
if (!cancelAppointmentBtn) return;
|
|
|
|
cancelAppointmentBtn.onclick = async function() {
|
|
if (!checkPermission('can_edit')) return;
|
|
|
|
const currentEventData = getCurrentEventData();
|
|
const eventId = currentEventData ? currentEventData.id : null;
|
|
|
|
if (!eventId) {
|
|
notifyError('ID d\'événement manquant');
|
|
return;
|
|
}
|
|
|
|
const motif = prompt('Motif de l\'annulation (optionnel):');
|
|
if (motif === null) {
|
|
return; // L'utilisateur a cliqué sur Annuler
|
|
}
|
|
|
|
await withLoadingOverlay(async () => {
|
|
try {
|
|
await changeEventStatus(eventId, 'annule', motif);
|
|
notifySuccess('Rendez-vous annulé');
|
|
refreshCalendars();
|
|
closeModal(onCancelled);
|
|
} catch (error) {
|
|
console.error('Erreur lors de l\'annulation:', error);
|
|
notifyError('Erreur lors de l\'annulation du rendez-vous');
|
|
}
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton Edit
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} getCurrentMode - Fonction pour obtenir le mode actuel
|
|
* @param {Function} setCurrentMode - Fonction pour changer le mode
|
|
* @param {Function} enableDateSynchronization - Fonction pour activer la synchronisation des dates
|
|
*/
|
|
export function initializeEditButton(getCurrentEventData, getCurrentMode, setCurrentMode, enableDateSynchronization) {
|
|
const editBtn = document.getElementById('editEventBtn');
|
|
if (!editBtn) return;
|
|
|
|
editBtn.onclick = async function() {
|
|
if (!checkPermission('can_edit')) return;
|
|
|
|
const currentEventData = getCurrentEventData();
|
|
|
|
// Changer le mode
|
|
setCurrentMode('edit');
|
|
|
|
// Mettre à jour l'affichage
|
|
const userCanEdit = window.crviPermissions && window.crviPermissions.can_edit;
|
|
const userCanDelete = window.crviPermissions && window.crviPermissions.can_delete;
|
|
updateModalDisplay('edit', userCanEdit, userCanDelete, currentEventData);
|
|
|
|
// Remplir le formulaire avec les données actuelles
|
|
fillFormWithEvent(currentEventData);
|
|
|
|
// Peupler les selects avec overlay de chargement
|
|
await withLoadingOverlay(async () => {
|
|
try {
|
|
await populateSelects(currentEventData);
|
|
} catch (error) {
|
|
console.error('Erreur lors du peuplement des selects:', error);
|
|
}
|
|
});
|
|
|
|
clearFormErrors();
|
|
|
|
// Activer la synchronisation des dates
|
|
if (enableDateSynchronization) {
|
|
enableDateSynchronization();
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton Cancel
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} getCurrentMode - Fonction pour obtenir le mode actuel
|
|
* @param {Function} setCurrentMode - Fonction pour changer le mode
|
|
* @param {Function} disableDateSynchronization - Fonction pour désactiver la synchronisation des dates
|
|
*/
|
|
export function initializeCancelButton(getCurrentEventData, getCurrentMode, setCurrentMode, disableDateSynchronization) {
|
|
const cancelBtn = document.getElementById('cancelEditBtn');
|
|
if (!cancelBtn) return;
|
|
|
|
cancelBtn.onclick = function() {
|
|
const currentMode = getCurrentMode();
|
|
const currentEventData = getCurrentEventData();
|
|
|
|
if (currentMode === 'create') {
|
|
// En mode création, fermer le modal
|
|
closeModal();
|
|
} else if (currentMode === 'edit' && currentEventData) {
|
|
// En mode édition, retourner en mode vue
|
|
setCurrentMode('view');
|
|
|
|
const userCanEdit = window.crviPermissions && window.crviPermissions.can_edit;
|
|
const userCanDelete = window.crviPermissions && window.crviPermissions.can_delete;
|
|
updateModalDisplay('view', userCanEdit, userCanDelete, currentEventData);
|
|
|
|
// Réafficher les données en mode lecture
|
|
fillViewBlock(currentEventData);
|
|
clearFormErrors();
|
|
|
|
// Désactiver la synchronisation des dates
|
|
if (disableDateSynchronization) {
|
|
disableDateSynchronization();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton Save
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} getCurrentMode - Fonction pour obtenir le mode actuel
|
|
* @param {Function} disableDateSynchronization - Fonction pour désactiver la synchronisation des dates
|
|
*/
|
|
export function initializeSaveButton(getCurrentEventData, getCurrentMode, disableDateSynchronization) {
|
|
const saveBtn = document.getElementById('saveEvent');
|
|
if (!saveBtn) return;
|
|
|
|
saveBtn.onclick = async function() {
|
|
const currentMode = getCurrentMode();
|
|
const currentEventData = getCurrentEventData();
|
|
const eventId = currentEventData ? currentEventData.id : null;
|
|
|
|
await withLoadingOverlay(async () => {
|
|
await handleEventFormSubmit(currentMode, eventId, function() {
|
|
// Succès : fermer le modal et rafraîchir les calendriers
|
|
refreshCalendars();
|
|
closeModal();
|
|
|
|
// Désactiver la synchronisation des dates
|
|
if (disableDateSynchronization) {
|
|
disableDateSynchronization();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton "Signaler un incident"
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} openSubModal - Fonction pour ouvrir une sous-modale
|
|
*/
|
|
export function initializeReportIncidentButton(getCurrentEventData, openSubModal) {
|
|
const reportIncidentBtn = document.getElementById('reportIncidentBtn');
|
|
if (!reportIncidentBtn) return;
|
|
|
|
reportIncidentBtn.onclick = async function() {
|
|
const currentEventData = getCurrentEventData();
|
|
|
|
if (!currentEventData || !currentEventData.id) {
|
|
notifyError('Aucun événement sélectionné');
|
|
return;
|
|
}
|
|
|
|
// Récupérer le type d'événement
|
|
const eventType = currentEventData.type || currentEventData.extendedProps?.type || 'individuel';
|
|
const isGroupe = eventType === 'groupe';
|
|
|
|
// Ouvrir la sous-modale avec préparation des données
|
|
openSubModal(
|
|
'declarationIncidentModal',
|
|
(subModal) => {
|
|
// Pré-remplir le formulaire
|
|
const eventIdInput = document.getElementById('incident_event_id');
|
|
const eventTypeInput = document.getElementById('incident_event_type');
|
|
const sectionIndividuel = document.getElementById('incident_individuel_section');
|
|
const sectionGroupe = document.getElementById('incident_groupe_section');
|
|
|
|
if (eventIdInput) eventIdInput.value = currentEventData.id;
|
|
if (eventTypeInput) eventTypeInput.value = eventType;
|
|
|
|
// Afficher/masquer les sections selon le type
|
|
if (isGroupe) {
|
|
if (sectionIndividuel) sectionIndividuel.style.display = 'none';
|
|
if (sectionGroupe) sectionGroupe.style.display = 'block';
|
|
} else {
|
|
if (sectionIndividuel) sectionIndividuel.style.display = 'block';
|
|
if (sectionGroupe) sectionGroupe.style.display = 'none';
|
|
|
|
// Pré-remplir les infos du bénéficiaire
|
|
const beneficiaireId = currentEventData.id_beneficiaire || currentEventData.extendedProps?.id_beneficiaire;
|
|
const beneficiaireNom = currentEventData.beneficiaire?.nom_complet ||
|
|
currentEventData.extendedProps?.beneficiaire?.nom_complet ||
|
|
'Non spécifié';
|
|
|
|
const beneficiaireNomInput = document.getElementById('incident_beneficiaire_nom');
|
|
const beneficiaireIdInput = document.getElementById('incident_beneficiaire_id');
|
|
|
|
if (beneficiaireNomInput) beneficiaireNomInput.value = beneficiaireNom;
|
|
if (beneficiaireIdInput) beneficiaireIdInput.value = beneficiaireId || '';
|
|
}
|
|
}
|
|
);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Charge l'historique des 3 derniers rendez-vous d'un bénéficiaire
|
|
* @param {number} beneficiaireId - ID du bénéficiaire
|
|
* @returns {Promise<Array>} Tableau des rendez-vous avec leurs incidents
|
|
*/
|
|
async function loadBeneficiaireHistorique(beneficiaireId) {
|
|
try {
|
|
const historique = await apiFetch(`beneficiaires/${beneficiaireId}/historique`);
|
|
return historique || [];
|
|
} catch (error) {
|
|
console.error('Erreur lors du chargement de l\'historique:', error);
|
|
notifyError('Erreur lors du chargement de l\'historique du bénéficiaire');
|
|
return [];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Affiche l'historique sous forme de ligne du temps verticale
|
|
* @param {Array} historiqueData - Tableau des rendez-vous avec leurs incidents
|
|
*/
|
|
function displayHistoriqueTimeline(historiqueData) {
|
|
const timelineContainer = document.getElementById('historiqueTimeline');
|
|
if (!timelineContainer) {
|
|
console.error('Conteneur de timeline non trouvé');
|
|
return;
|
|
}
|
|
|
|
if (!historiqueData || historiqueData.length === 0) {
|
|
timelineContainer.innerHTML = `
|
|
<div class="alert alert-info text-center">
|
|
<i class="fas fa-info-circle me-2"></i>
|
|
Aucun rendez-vous trouvé pour ce bénéficiaire.
|
|
</div>
|
|
`;
|
|
return;
|
|
}
|
|
|
|
let html = '<div class="crvi-timeline">';
|
|
|
|
historiqueData.forEach((rdv, index) => {
|
|
const date = new Date(rdv.date_rdv + 'T' + rdv.heure_rdv);
|
|
const dateFormatted = date.toLocaleDateString('fr-FR', {
|
|
day: '2-digit',
|
|
month: '2-digit',
|
|
year: 'numeric'
|
|
});
|
|
const heureFormatted = date.toLocaleTimeString('fr-FR', {
|
|
hour: '2-digit',
|
|
minute: '2-digit'
|
|
});
|
|
|
|
const intervenantNom = rdv.intervenant
|
|
? `${rdv.intervenant.nom || ''} ${rdv.intervenant.prenom || ''}`.trim()
|
|
: 'Non renseigné';
|
|
|
|
const typeInterventionNom = rdv.type_intervention?.nom || 'Non renseigné';
|
|
|
|
// Déterminer le type d'événement et la couleur
|
|
const hasIncident = rdv.incident && rdv.incident.id;
|
|
const statutLower = rdv.statut ? rdv.statut.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "") : '';
|
|
|
|
let eventType = 'default';
|
|
let icon = 'fa-calendar-alt';
|
|
|
|
if (hasIncident || statutLower.includes('absence') || statutLower.includes('absent')) {
|
|
eventType = 'incident'; // Rouge
|
|
icon = 'fa-exclamation-triangle';
|
|
} else if (statutLower.includes('present')) {
|
|
eventType = 'present'; // Vert
|
|
icon = 'fa-check-circle';
|
|
} else if (statutLower.includes('prevu')) {
|
|
eventType = 'prevu'; // Bleu
|
|
icon = 'fa-clock';
|
|
} else {
|
|
eventType = 'default'; // Gris
|
|
icon = 'fa-calendar-alt';
|
|
}
|
|
|
|
const isLastItem = index === historiqueData.length - 1;
|
|
const eventNumber = index + 1;
|
|
|
|
html += `
|
|
<div class="crvi-timeline__event crvi-timeline__event--${eventType} ${isLastItem ? 'crvi-timeline__event--last' : ''}" data-number="${eventNumber}">
|
|
<div class="crvi-timeline__event__header">
|
|
<div class="crvi-timeline__event__date-wrapper">
|
|
<div class="crvi-timeline__event__date-icon">
|
|
<i class="fas ${icon}"></i>
|
|
</div>
|
|
<div class="crvi-timeline__event__date-info">
|
|
<div class="crvi-timeline__event__date">${dateFormatted}</div>
|
|
<div class="crvi-timeline__event__time">${heureFormatted}</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="crvi-timeline__event__title">
|
|
${hasIncident ? '<i class="fas fa-exclamation-triangle me-2"></i>' : ''}
|
|
${rdv.type || 'Rendez-vous'}
|
|
</div>
|
|
|
|
<div class="crvi-timeline__event__content">
|
|
${rdv.personne_en_liste_rouge ? `
|
|
<div class="alert alert-danger mb-2" style="font-size: 90%; padding: 8px;">
|
|
<i class="fas fa-exclamation-triangle me-2"></i>
|
|
<strong>Personne en liste rouge</strong>
|
|
</div>
|
|
` : ''}
|
|
<div class="mb-2">
|
|
<strong><i class="fas fa-user-md me-2"></i>Intervenant:</strong> ${intervenantNom}
|
|
</div>
|
|
<div class="mb-2">
|
|
<strong><i class="fas fa-tools me-2"></i>Type d'intervention:</strong> ${typeInterventionNom}
|
|
</div>
|
|
${rdv.statut ? `
|
|
<div class="mb-2">
|
|
<strong><i class="fas fa-info-circle me-2"></i>Statut:</strong>
|
|
<span class="badge bg-${eventType === 'present' ? 'success' : eventType === 'prevu' ? 'primary' : eventType === 'incident' ? 'danger' : 'secondary'}">${rdv.statut}</span>
|
|
</div>
|
|
` : ''}
|
|
${rdv.commentaire ? `
|
|
<div class="mb-2">
|
|
<strong><i class="fas fa-comment me-2"></i>Commentaire:</strong> ${rdv.commentaire}
|
|
</div>
|
|
` : ''}
|
|
${hasIncident ? `
|
|
<div class="alert alert-danger mt-3 mb-0" style="background-color: #fee; border-left: 4px solid #dc3545; padding: 12px;">
|
|
<strong><i class="fas fa-exclamation-triangle me-2"></i>Incident signalé</strong>
|
|
<div class="mt-2">
|
|
<strong>Résumé:</strong> ${rdv.incident.resume_incident || 'Non renseigné'}
|
|
</div>
|
|
${rdv.incident.commentaire_incident ? `
|
|
<div class="mt-2">
|
|
<strong>Commentaire:</strong> ${rdv.incident.commentaire_incident}
|
|
</div>
|
|
` : ''}
|
|
</div>
|
|
` : ''}
|
|
</div>
|
|
</div>
|
|
`;
|
|
});
|
|
|
|
html += '</div>';
|
|
timelineContainer.innerHTML = html;
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton "Historique bénéficiaire"
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} openSubModal - Fonction pour ouvrir une sous-modale
|
|
*/
|
|
export function initializeHistoriqueButton(getCurrentEventData, openSubModal) {
|
|
const historiqueBtn = document.getElementById('showBeneficiaireHistoriqueBtn');
|
|
if (!historiqueBtn) return;
|
|
|
|
historiqueBtn.onclick = async function() {
|
|
const currentEventData = getCurrentEventData();
|
|
const beneficiaireId = historiqueBtn.getAttribute('data-benef') ||
|
|
currentEventData?.id_beneficiaire ||
|
|
currentEventData?.extendedProps?.id_beneficiaire;
|
|
|
|
if (!beneficiaireId) {
|
|
notifyError('ID du bénéficiaire introuvable');
|
|
return;
|
|
}
|
|
|
|
// Ouvrir la sous-modale avec chargement des données
|
|
openSubModal(
|
|
'beneficiaireHistoriqueModal',
|
|
async (subModal) => {
|
|
// Afficher le spinner de chargement
|
|
const timelineContainer = document.getElementById('historiqueTimeline');
|
|
if (timelineContainer) {
|
|
timelineContainer.innerHTML = `
|
|
<div class="text-center py-4">
|
|
<div class="spinner-border text-primary" role="status">
|
|
<span class="visually-hidden">Chargement...</span>
|
|
</div>
|
|
</div>
|
|
`;
|
|
}
|
|
|
|
// Charger l'historique
|
|
try {
|
|
const historiqueData = await loadBeneficiaireHistorique(parseInt(beneficiaireId));
|
|
displayHistoriqueTimeline(historiqueData);
|
|
} catch (error) {
|
|
console.error('Erreur lors du chargement de l\'historique:', error);
|
|
if (timelineContainer) {
|
|
timelineContainer.innerHTML = `
|
|
<div class="alert alert-danger">
|
|
<i class="fas fa-exclamation-triangle me-2"></i>
|
|
Erreur lors du chargement de l'historique.
|
|
</div>
|
|
`;
|
|
}
|
|
}
|
|
},
|
|
(subModal) => {
|
|
// Nettoyer après fermeture
|
|
const timelineContainer = document.getElementById('historiqueTimeline');
|
|
if (timelineContainer) {
|
|
timelineContainer.innerHTML = '';
|
|
}
|
|
}
|
|
);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton "Debug SMS"
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
*/
|
|
export function initializeDebugSmsButton(getCurrentEventData) {
|
|
const debugSmsBtn = document.getElementById('debugSmsBtn');
|
|
if (!debugSmsBtn) return;
|
|
|
|
debugSmsBtn.onclick = function() {
|
|
const currentEventData = getCurrentEventData();
|
|
const eventId = currentEventData ? currentEventData.id : null;
|
|
|
|
console.log('[DEBUG_SMS] Données événement actuelles:', currentEventData);
|
|
|
|
// Construire un message simple pour le debug
|
|
const dateStr = (document.getElementById('date_rdv') && document.getElementById('date_rdv').value) || currentEventData?.date || '';
|
|
const timeStr = (document.getElementById('heure_rdv') && document.getElementById('heure_rdv').value) || currentEventData?.time || '';
|
|
const typeStr = (document.getElementById('type') && document.getElementById('type').value) || currentEventData?.type || '';
|
|
|
|
const msg = `Debug SMS - Event ${eventId ?? 'N/A'} - ${dateStr} ${timeStr} - type: ${typeStr}`;
|
|
const phone = '0485500723';
|
|
|
|
if (!window.crviAjax || !window.crviAjax.url || !window.crviAjax.nonce) {
|
|
alert('Debug SMS: configuration AJAX manquante.');
|
|
return;
|
|
}
|
|
|
|
const params = new URLSearchParams();
|
|
params.append('action', 'crvi_send_sms_debug');
|
|
params.append('nonce', window.crviAjax.nonce);
|
|
params.append('phone', phone);
|
|
params.append('message', msg);
|
|
if (eventId) {
|
|
params.append('id_event', String(eventId));
|
|
}
|
|
params.append('sujet', 'debug');
|
|
|
|
fetch(window.crviAjax.url, {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
|
|
},
|
|
body: params.toString()
|
|
}).then(async (res) => {
|
|
let json;
|
|
try { json = await res.json(); } catch (_) {}
|
|
if (!res.ok || !json?.success) {
|
|
const errMsg = json?.data?.message || 'Erreur lors de l\'envoi SMS (debug).';
|
|
throw new Error(errMsg);
|
|
}
|
|
alert('SMS de debug envoyé.');
|
|
}).catch((err) => {
|
|
console.error('[DEBUG_SMS] Échec envoi:', err);
|
|
alert('Échec envoi SMS de debug: ' + (err?.message || 'Erreur inconnue'));
|
|
});
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise le bouton "Voir les incidents"
|
|
* @param {Function} getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} openIncidentsViewModal - Fonction pour ouvrir la modal de visualisation des incidents
|
|
*/
|
|
export function initializeViewIncidentsButton(getCurrentEventData, openIncidentsViewModal) {
|
|
const viewIncidentsBtn = document.getElementById('viewIncidentsBtn');
|
|
if (!viewIncidentsBtn) return;
|
|
|
|
viewIncidentsBtn.onclick = async function() {
|
|
const currentEventData = getCurrentEventData();
|
|
const eventId = currentEventData?.id || currentEventData?.extendedProps?.id;
|
|
|
|
if (!eventId) {
|
|
notifyError('ID de l\'événement introuvable');
|
|
return;
|
|
}
|
|
|
|
await openIncidentsViewModal(eventId);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Initialise tous les boutons de la modale
|
|
* @param {Object} options - Options de configuration
|
|
* @param {Function} options.getCurrentEventData - Fonction pour obtenir les données de l'événement
|
|
* @param {Function} options.getCurrentMode - Fonction pour obtenir le mode actuel
|
|
* @param {Function} options.setCurrentMode - Fonction pour changer le mode
|
|
* @param {Function} options.openSubModal - Fonction pour ouvrir une sous-modale
|
|
* @param {Function} options.openCheckPresenceModal - Fonction pour ouvrir la modal de validation de présence
|
|
* @param {Function} options.openIncidentsViewModal - Fonction pour ouvrir la modal de visualisation des incidents
|
|
* @param {Function} options.enableDateSynchronization - Fonction pour activer la synchronisation des dates
|
|
* @param {Function} options.disableDateSynchronization - Fonction pour désactiver la synchronisation des dates
|
|
* @param {Function} options.onDeleted - Callback après suppression
|
|
* @param {Function} options.onStatusChanged - Callback après changement de statut
|
|
*/
|
|
export function initializeModalButtons(options = {}) {
|
|
const {
|
|
getCurrentEventData,
|
|
getCurrentMode,
|
|
setCurrentMode,
|
|
openSubModal,
|
|
openCheckPresenceModal,
|
|
openIncidentsViewModal,
|
|
enableDateSynchronization,
|
|
disableDateSynchronization,
|
|
onDeleted,
|
|
onStatusChanged
|
|
} = options;
|
|
|
|
// Boutons de fermeture
|
|
initializeCloseButton('closeModalBtn');
|
|
initializeCloseButton('closeViewBtn');
|
|
|
|
// Boutons d'action
|
|
if (getCurrentEventData) {
|
|
initializeEditButton(getCurrentEventData, getCurrentMode, setCurrentMode, enableDateSynchronization);
|
|
initializeCancelButton(getCurrentEventData, getCurrentMode, setCurrentMode, disableDateSynchronization);
|
|
initializeSaveButton(getCurrentEventData, getCurrentMode, disableDateSynchronization);
|
|
initializeDeleteButton(getCurrentEventData, onDeleted);
|
|
initializeMarkPresentButton(getCurrentEventData, openCheckPresenceModal, onStatusChanged);
|
|
initializeMarkAbsentButton(getCurrentEventData, onStatusChanged);
|
|
initializeCancelAppointmentButton(getCurrentEventData, onStatusChanged);
|
|
initializeDebugSmsButton(getCurrentEventData);
|
|
|
|
// Boutons spécifiques avec sous-modales
|
|
if (openSubModal) {
|
|
initializeReportIncidentButton(getCurrentEventData, openSubModal);
|
|
initializeHistoriqueButton(getCurrentEventData, openSubModal);
|
|
}
|
|
|
|
// Bouton de visualisation des incidents
|
|
if (openIncidentsViewModal) {
|
|
initializeViewIncidentsButton(getCurrentEventData, openIncidentsViewModal);
|
|
}
|
|
}
|
|
}
|