AdminGit
36b0c00cbc
-> Refonte du système de login -> Récupération du MDP -> Refonte imports d'horaires + Modale de gestion d'horaires
1165 lines
40 KiB
JavaScript
1165 lines
40 KiB
JavaScript
import supabase, { isSupabaseConfigured } from '../supabaseClient';
|
|
|
|
const normalizeGareName = (value) => String(value || '').trim().toLowerCase();
|
|
|
|
const isSameGare = (row, refId, refNom) => {
|
|
if (!row) return false;
|
|
const rowId = row.gare_id || row.id || null;
|
|
if (refId && rowId && String(rowId) === String(refId)) return true;
|
|
const refName = normalizeGareName(refNom);
|
|
return refName && normalizeGareName(row.gare_nom || row.nom) === refName;
|
|
};
|
|
|
|
const propagateQuaisByNumeroTrain = (horaires) => {
|
|
if (!horaires || horaires.length === 0) return horaires;
|
|
|
|
// 1. S'assurer que tous les horaires ont leur départ/arrivée dans gares_desservies
|
|
horaires.forEach(h => {
|
|
if (!Array.isArray(h.gares_desservies)) {
|
|
h.gares_desservies = [];
|
|
}
|
|
|
|
const snapshot = Array.isArray(h.snapshot_gares_desservies) ? h.snapshot_gares_desservies : [];
|
|
|
|
const hasDepart = h.gares_desservies.some(gd => Number(gd.ordre) === 0 || isSameGare(gd, h.gare_depart_id, h.gare_depart_nom));
|
|
if (!hasDepart && h.gare_depart_nom) {
|
|
const snapDepart = snapshot.find(s => Number(s.ordre) === 0 || s.is_depart || isSameGare(s, h.gare_depart_id, h.gare_depart_nom));
|
|
h.gares_desservies.push({
|
|
horaire_id: h.id,
|
|
gare_id: h.gare_depart_id,
|
|
gare_nom: h.gare_depart_nom,
|
|
heure_arrivee: null,
|
|
heure_depart: h.heure_depart,
|
|
ordre: 0,
|
|
quai: snapDepart ? (snapDepart.quai || null) : null,
|
|
quai_reel: snapDepart ? (snapDepart.quai_reel || null) : null,
|
|
is_depart: true
|
|
});
|
|
}
|
|
|
|
const hasArrivee = h.gares_desservies.some(gd => isSameGare(gd, h.gare_arrivee_id, h.gare_arrivee_nom));
|
|
if (!hasArrivee && h.gare_arrivee_nom) {
|
|
const snapArrivee = snapshot.find(s => s.is_arrivee || isSameGare(s, h.gare_arrivee_id, h.gare_arrivee_nom));
|
|
h.gares_desservies.push({
|
|
horaire_id: h.id,
|
|
gare_id: h.gare_arrivee_id,
|
|
gare_nom: h.gare_arrivee_nom,
|
|
heure_arrivee: h.heure_arrivee,
|
|
heure_depart: null,
|
|
ordre: snapArrivee ? (snapArrivee.ordre || 9999) : 9999,
|
|
quai: snapArrivee ? (snapArrivee.quai || null) : null,
|
|
quai_reel: snapArrivee ? (snapArrivee.quai_reel || null) : null,
|
|
is_arrivee: true
|
|
});
|
|
}
|
|
});
|
|
|
|
const groups = {};
|
|
horaires.forEach(h => {
|
|
if (h.numero_train) {
|
|
if (!groups[h.numero_train]) groups[h.numero_train] = [];
|
|
groups[h.numero_train].push(h);
|
|
}
|
|
});
|
|
|
|
Object.keys(groups).forEach(numTrain => {
|
|
const group = groups[numTrain];
|
|
if (group.length <= 1) return;
|
|
|
|
const gareQuais = {};
|
|
|
|
group.forEach(h => {
|
|
if (Array.isArray(h.gares_desservies)) {
|
|
h.gares_desservies.forEach(gd => {
|
|
const key = normalizeGareName(gd.gare_nom);
|
|
if (key) {
|
|
if (!gareQuais[key]) {
|
|
gareQuais[key] = { quai: null, quai_reel: null };
|
|
}
|
|
if (gd.quai && !gareQuais[key].quai) {
|
|
gareQuais[key].quai = gd.quai;
|
|
}
|
|
if (gd.quai_reel && !gareQuais[key].quai_reel) {
|
|
gareQuais[key].quai_reel = gd.quai_reel;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
const hasAnyQuai = Object.values(gareQuais).some(q => q.quai || q.quai_reel);
|
|
if (!hasAnyQuai) return;
|
|
|
|
group.forEach(h => {
|
|
if (Array.isArray(h.gares_desservies)) {
|
|
h.gares_desservies.forEach(gd => {
|
|
const key = normalizeGareName(gd.gare_nom);
|
|
if (key && gareQuais[key]) {
|
|
if (!gd.quai && gareQuais[key].quai) {
|
|
gd.quai = gareQuais[key].quai;
|
|
}
|
|
if (!gd.quai_reel && gareQuais[key].quai_reel) {
|
|
gd.quai_reel = gareQuais[key].quai_reel;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
// Trier de nouveau si on a inséré des gares de départ/arrivée
|
|
horaires.forEach(h => {
|
|
if (Array.isArray(h.gares_desservies)) {
|
|
h.gares_desservies.sort((a, b) => (Number(a.ordre) || 0) - (Number(b.ordre) || 0));
|
|
}
|
|
});
|
|
|
|
return horaires;
|
|
};
|
|
|
|
// ============================================================================
|
|
// API HORAIRES (SILLONS)
|
|
// ============================================================================
|
|
/**
|
|
* Récupère tous les horaires avec leurs gares desservies et matériel roulant
|
|
* @param {string} [regionId] - Filtrer par région (optionnel)
|
|
*/
|
|
export async function getAllHoraires(regionId = null) {
|
|
if (!isSupabaseConfigured) return { data: [], error: null };
|
|
|
|
try {
|
|
// Si on demande un filtrage par région, récupérer d'abord les lignes associées
|
|
let ligneIds = null;
|
|
if (regionId) {
|
|
try {
|
|
const { data: lignesData, error: lignesError } = await supabase
|
|
.from('lignes')
|
|
.select('id')
|
|
.eq('region_id', regionId);
|
|
|
|
if (lignesError) {
|
|
// Log the error but don't throw, as we can still filter by horaires.region_id
|
|
console.error('Error fetching lignes by region:', lignesError);
|
|
ligneIds = [];
|
|
} else if (Array.isArray(lignesData)) {
|
|
ligneIds = lignesData.map(l => l.id).filter(Boolean);
|
|
} else {
|
|
ligneIds = [];
|
|
}
|
|
} catch (e) {
|
|
console.error('Exception while fetching ligneIds:', e);
|
|
ligneIds = [];
|
|
}
|
|
}
|
|
|
|
const SELECT_QUERY = `
|
|
*,
|
|
materiel_roulant:materiel-roulant(id, nom, nom_technique, image_url)
|
|
`;
|
|
|
|
let orConditions = [];
|
|
if (regionId) {
|
|
if (ligneIds && ligneIds.length > 0) {
|
|
orConditions.push(`ligne_id.in.(${ligneIds.join(',')})`);
|
|
}
|
|
orConditions.push(`region_id.eq.${regionId}`);
|
|
}
|
|
|
|
let allData = [];
|
|
let start = 0;
|
|
const limit = 1000;
|
|
let hasMore = true;
|
|
let currentSelect = SELECT_QUERY;
|
|
|
|
while (hasMore) {
|
|
let query = supabase
|
|
.from('horaires')
|
|
.select(currentSelect)
|
|
.order('created_at', { ascending: false })
|
|
.range(start, start + limit - 1);
|
|
|
|
if (regionId) {
|
|
query = query.or(orConditions.join(','));
|
|
}
|
|
|
|
const { data, error } = await query;
|
|
|
|
if (error) {
|
|
if (currentSelect !== '*' && (error.message?.includes('materiel-roulant') || error.message?.includes('relationship') || error.code === 'PGRST200')) {
|
|
console.warn('Relation materiel-roulant absente du cache de schéma PostgREST, repli sur SELECT *.');
|
|
currentSelect = '*';
|
|
allData = [];
|
|
start = 0;
|
|
continue;
|
|
}
|
|
console.error('Erreur getAllHoraires fetch:', error);
|
|
return { data: [], error };
|
|
}
|
|
|
|
if (data && data.length > 0) {
|
|
allData = allData.concat(data);
|
|
start += limit;
|
|
}
|
|
|
|
if (!data || data.length < limit) {
|
|
hasMore = false;
|
|
}
|
|
}
|
|
|
|
// Normaliser gares_desservies depuis la colonne JSONB unique
|
|
const normalizedData = (allData || []).map(h => {
|
|
const gares = Array.isArray(h.gares_desservies) ? [...h.gares_desservies] : [];
|
|
gares.sort((a, b) => (Number(a.ordre) || 0) - (Number(b.ordre) || 0));
|
|
return {
|
|
...h,
|
|
gares_desservies: gares
|
|
};
|
|
});
|
|
|
|
const propagatedData = propagateQuaisByNumeroTrain(normalizedData);
|
|
return { data: propagatedData, error: null };
|
|
} catch (err) {
|
|
console.error('Erreur getAllHoraires:', err);
|
|
return { data: [], error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupère un horaire par son ID depuis la table unique horaires
|
|
*/
|
|
export async function getHoraireById(id) {
|
|
if (!isSupabaseConfigured) return { data: null, error: { message: 'Supabase non configuré' } };
|
|
|
|
try {
|
|
let { data, error } = await supabase
|
|
.from('horaires')
|
|
.select(`
|
|
*,
|
|
materiel_roulant:materiel-roulant(id, nom, nom_technique, image_url)
|
|
`)
|
|
.eq('id', id)
|
|
.single();
|
|
|
|
if (error && (error.message?.includes('materiel-roulant') || error.message?.includes('relationship') || error.code === 'PGRST200')) {
|
|
const fallback = await supabase
|
|
.from('horaires')
|
|
.select('*')
|
|
.eq('id', id)
|
|
.single();
|
|
data = fallback.data;
|
|
error = fallback.error;
|
|
}
|
|
|
|
if (error) return { data: null, error };
|
|
|
|
if (data) {
|
|
const gares = Array.isArray(data.gares_desservies) ? [...data.gares_desservies] : [];
|
|
gares.sort((a, b) => (Number(a.ordre) || 0) - (Number(b.ordre) || 0));
|
|
const hCopy = { ...data, gares_desservies: gares };
|
|
const propagated = propagateQuaisByNumeroTrain([hCopy]);
|
|
return { data: propagated[0], error: null };
|
|
}
|
|
|
|
return { data: null, error: null };
|
|
} catch (err) {
|
|
console.error('Erreur getHoraireById:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Crée un nouvel horaire avec ses gares desservies
|
|
* @param {Object} payload - Données de l'horaire
|
|
* @param {Array} garesDesservies - Liste des gares desservies [{gare_nom, heure_arrivee, heure_depart, ordre}, ...]
|
|
* @param {Object|null} currentUser - L'utilisateur actuellement connecté
|
|
*/
|
|
export async function createHoraire(payload, garesDesservies = [], currentUser = null) {
|
|
if (!isSupabaseConfigured) {
|
|
const fakeId = `local-${Date.now()}`;
|
|
return { data: { id: fakeId, ...payload, gares_desservies: garesDesservies }, error: null };
|
|
}
|
|
|
|
try {
|
|
// Si l'utilisateur est un exploitant, pré-attribuer sa région
|
|
if (currentUser && currentUser.role === 'exploitant' && currentUser.region_id) {
|
|
payload.region_id = currentUser.region_id;
|
|
}
|
|
|
|
// Construire le snapshot JSON des gares desservies
|
|
const garesDesserviesJson = (garesDesservies || []).map((g, idx) => ({
|
|
gare_id: g.gare_id || null,
|
|
gare_nom: g.gare_nom || '',
|
|
heure_arrivee: g.heure_arrivee || null,
|
|
heure_depart: g.heure_depart || null,
|
|
ordre: g.ordre ?? idx + 1,
|
|
quai: g.quai || null,
|
|
quai_reel: g.quai_reel || null
|
|
}));
|
|
|
|
// Ajouter les entrées départ et arrivée
|
|
const departEntry = {
|
|
gare_id: payload.gare_depart_id || null,
|
|
gare_nom: payload.gare_depart_nom || '',
|
|
heure_arrivee: null,
|
|
heure_depart: payload.heure_depart || null,
|
|
ordre: 0,
|
|
quai: null,
|
|
quai_reel: null,
|
|
is_depart: true
|
|
};
|
|
const maxOrd = garesDesserviesJson.reduce((m, e) => Math.max(m, Number(e.ordre || 0)), 0);
|
|
const arriveeEntry = {
|
|
gare_id: payload.gare_arrivee_id || null,
|
|
gare_nom: payload.gare_arrivee_nom || '',
|
|
heure_arrivee: payload.heure_arrivee || null,
|
|
heure_depart: null,
|
|
ordre: maxOrd + 1,
|
|
quai: null,
|
|
quai_reel: null,
|
|
is_arrivee: true
|
|
};
|
|
|
|
const fullGaresDesserviesJson = [departEntry, ...garesDesserviesJson, arriveeEntry];
|
|
|
|
// Construire le dictionnaire O(1) attributions_quais
|
|
const attributionsQuais = {};
|
|
fullGaresDesserviesJson.forEach(g => {
|
|
const key = g.gare_id || g.gare_nom;
|
|
if (key && (g.quai || g.quai_reel)) {
|
|
attributionsQuais[key] = {
|
|
quai: g.quai || null,
|
|
quai_reel: g.quai_reel || null,
|
|
ordre: g.ordre
|
|
};
|
|
}
|
|
});
|
|
|
|
// Insérer de manière atomique dans la table unique horaires
|
|
let { data: horaire, error: horaireError } = await supabase
|
|
.from('horaires')
|
|
.insert([{
|
|
...payload,
|
|
gares_desservies: fullGaresDesserviesJson,
|
|
attributions_quais: attributionsQuais,
|
|
created_at: new Date(),
|
|
updated_at: new Date()
|
|
}])
|
|
.select(`
|
|
*,
|
|
materiel_roulant:materiel-roulant(id, nom, nom_technique, image_url)
|
|
`)
|
|
.single();
|
|
|
|
if (horaireError && (horaireError.message?.includes('materiel-roulant') || horaireError.message?.includes('relationship') || horaireError.code === 'PGRST200')) {
|
|
const fallback = await supabase
|
|
.from('horaires')
|
|
.insert([{
|
|
...payload,
|
|
gares_desservies: fullGaresDesserviesJson,
|
|
attributions_quais: attributionsQuais,
|
|
created_at: new Date(),
|
|
updated_at: new Date()
|
|
}])
|
|
.select('*')
|
|
.single();
|
|
horaire = fallback.data;
|
|
horaireError = fallback.error;
|
|
}
|
|
|
|
if (horaireError) {
|
|
console.error('Erreur création horaire:', horaireError);
|
|
return { data: null, error: horaireError };
|
|
}
|
|
|
|
return { data: horaire, error: null };
|
|
|
|
} catch (err) {
|
|
console.error('Exception createHoraire:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
export async function updateHorairesLigneBatch(ids, ligne_id, ligne_nom) {
|
|
if (!isSupabaseConfigured) return { error: null };
|
|
try {
|
|
const { error } = await supabase
|
|
.from('horaires')
|
|
.update({ ligne_id, ligne_nom, updated_at: new Date() })
|
|
.in('id', ids);
|
|
return { error };
|
|
} catch (err) {
|
|
console.error('Exception updateHorairesLigneBatch:', err);
|
|
return { error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Met à jour un horaire existant et ses gares desservies dans la table unique
|
|
* @param {number|string} id - ID de l'horaire
|
|
* @param {Object} payload - Données à mettre à jour
|
|
* @param {Array} garesDesservies - Nouvelle liste des gares desservies (remplace l'existante)
|
|
*/
|
|
export async function updateHoraire(id, payload, garesDesservies = null) {
|
|
if (!isSupabaseConfigured) {
|
|
return { data: { id, ...payload }, error: null };
|
|
}
|
|
|
|
try {
|
|
let updateFields = {
|
|
...payload,
|
|
updated_at: new Date()
|
|
};
|
|
|
|
if (garesDesservies !== null) {
|
|
const garesDesserviesJson = (garesDesservies || []).map((g, idx) => ({
|
|
gare_id: g.gare_id || null,
|
|
gare_nom: g.gare_nom || '',
|
|
heure_arrivee: g.heure_arrivee || null,
|
|
heure_depart: g.heure_depart || null,
|
|
ordre: g.ordre ?? idx + 1,
|
|
quai: g.quai || null,
|
|
quai_reel: g.quai_reel || null
|
|
}));
|
|
|
|
const hasDepart = garesDesserviesJson.some(g => Number(g.ordre) === 0 || g.is_depart);
|
|
const departEntry = hasDepart ? null : {
|
|
gare_id: payload.gare_depart_id || null,
|
|
gare_nom: payload.gare_depart_nom || '',
|
|
heure_arrivee: null,
|
|
heure_depart: payload.heure_depart || null,
|
|
ordre: 0,
|
|
quai: null,
|
|
quai_reel: null,
|
|
is_depart: true
|
|
};
|
|
|
|
const maxOrd = garesDesserviesJson.reduce((m, e) => Math.max(m, Number(e.ordre || 0)), 0);
|
|
const hasArrivee = garesDesserviesJson.some(g => g.is_arrivee);
|
|
const arriveeEntry = hasArrivee ? null : {
|
|
gare_id: payload.gare_arrivee_id || null,
|
|
gare_nom: payload.gare_arrivee_nom || '',
|
|
heure_arrivee: payload.heure_arrivee || null,
|
|
heure_depart: null,
|
|
ordre: maxOrd + 1,
|
|
quai: null,
|
|
quai_reel: null,
|
|
is_arrivee: true
|
|
};
|
|
|
|
const fullList = [
|
|
...(departEntry ? [departEntry] : []),
|
|
...garesDesserviesJson,
|
|
...(arriveeEntry ? [arriveeEntry] : [])
|
|
].sort((a, b) => (Number(a.ordre) || 0) - (Number(b.ordre) || 0));
|
|
|
|
const attributionsQuais = {};
|
|
fullList.forEach(g => {
|
|
const key = g.gare_id || g.gare_nom;
|
|
if (key && (g.quai || g.quai_reel)) {
|
|
attributionsQuais[key] = {
|
|
quai: g.quai || null,
|
|
quai_reel: g.quai_reel || null,
|
|
ordre: g.ordre
|
|
};
|
|
}
|
|
});
|
|
|
|
updateFields.gares_desservies = fullList;
|
|
updateFields.attributions_quais = attributionsQuais;
|
|
}
|
|
|
|
// Mettre à jour l'horaire de manière atomique
|
|
let { data: updated, error: updateError } = await supabase
|
|
.from('horaires')
|
|
.update(updateFields)
|
|
.eq('id', id)
|
|
.select(`
|
|
*,
|
|
materiel_roulant:materiel-roulant(id, nom, nom_technique, image_url)
|
|
`)
|
|
.single();
|
|
|
|
if (updateError && (updateError.message?.includes('materiel-roulant') || updateError.message?.includes('relationship') || updateError.code === 'PGRST200')) {
|
|
const fallback = await supabase
|
|
.from('horaires')
|
|
.update(updateFields)
|
|
.eq('id', id)
|
|
.select('*')
|
|
.single();
|
|
updated = fallback.data;
|
|
updateError = fallback.error;
|
|
}
|
|
|
|
if (updateError) {
|
|
console.error('Erreur mise à jour horaire:', updateError);
|
|
return { data: null, error: updateError };
|
|
}
|
|
|
|
return { data: updated, error: null };
|
|
|
|
} catch (err) {
|
|
console.error('Exception updateHoraire:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Met à jour uniquement la composition du train pour un horaire.
|
|
* Utilisé par la page d'attribution du matériel roulant.
|
|
*/
|
|
export async function updateHoraireComposition(id, compositionTrain = []) {
|
|
if (!isSupabaseConfigured) {
|
|
return { data: { id, composition_train: compositionTrain }, error: null };
|
|
}
|
|
|
|
try {
|
|
const normalized = (compositionTrain || []).map((item, idx) => ({
|
|
materiel_id: item?.materiel_id,
|
|
materiel_nom: item?.materiel_nom || '',
|
|
materiel_nom_technique: item?.materiel_nom_technique || '',
|
|
materiel_image_url: item?.materiel_image_url || null,
|
|
position: idx + 1
|
|
}));
|
|
|
|
const { data, error } = await supabase
|
|
.from('horaires')
|
|
.update({ composition_train: normalized, updated_at: new Date() })
|
|
.eq('id', id)
|
|
.select('*')
|
|
.single();
|
|
|
|
return { data, error };
|
|
} catch (err) {
|
|
console.error('Exception updateHoraireComposition:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Supprime un horaire (hard delete)
|
|
* @param {number|string} id - ID de l'horaire
|
|
*/
|
|
export async function deleteHoraire(id) {
|
|
if (!isSupabaseConfigured) return { error: null };
|
|
|
|
try {
|
|
const { error } = await supabase
|
|
.from('horaires')
|
|
.delete()
|
|
.eq('id', id);
|
|
return { error };
|
|
} catch (err) {
|
|
console.error('Exception deleteHoraire:', err);
|
|
return { error: err };
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// API GARES DESSERVIES (GESTION DANS LA TABLE UNIQUE HORAIRES)
|
|
// ============================================================================
|
|
/**
|
|
* Ajoute une gare desservie directement dans l'horaire (colonne JSONB gares_desservies)
|
|
*/
|
|
export async function addGareDesservie(horaireId, gareData) {
|
|
if (!isSupabaseConfigured) {
|
|
return { data: { id: `local-${Date.now()}`, horaire_id: horaireId, ...gareData }, error: null };
|
|
}
|
|
|
|
try {
|
|
const { data: horaire, error: readErr } = await supabase
|
|
.from('horaires')
|
|
.select('gares_desservies, attributions_quais')
|
|
.eq('id', horaireId)
|
|
.single();
|
|
|
|
if (readErr) return { data: null, error: readErr };
|
|
|
|
const gares = Array.isArray(horaire?.gares_desservies) ? [...horaire.gares_desservies] : [];
|
|
const newGare = {
|
|
gare_id: gareData.gare_id || null,
|
|
gare_nom: gareData.gare_nom || '',
|
|
heure_arrivee: gareData.heure_arrivee || null,
|
|
heure_depart: gareData.heure_depart || null,
|
|
ordre: gareData.ordre ?? gares.length + 1,
|
|
quai: gareData.quai || null,
|
|
quai_reel: gareData.quai_reel || null
|
|
};
|
|
gares.push(newGare);
|
|
gares.sort((a, b) => (Number(a.ordre) || 0) - (Number(b.ordre) || 0));
|
|
|
|
const attributionsQuais = { ...(horaire?.attributions_quais || {}) };
|
|
const key = newGare.gare_id || newGare.gare_nom;
|
|
if (key && (newGare.quai || newGare.quai_reel)) {
|
|
attributionsQuais[key] = {
|
|
quai: newGare.quai || null,
|
|
quai_reel: newGare.quai_reel || null,
|
|
ordre: newGare.ordre
|
|
};
|
|
}
|
|
|
|
const { error: updateErr } = await supabase
|
|
.from('horaires')
|
|
.update({
|
|
gares_desservies: gares,
|
|
attributions_quais: attributionsQuais,
|
|
updated_at: new Date()
|
|
})
|
|
.eq('id', horaireId);
|
|
|
|
return { data: newGare, error: updateErr };
|
|
} catch (err) {
|
|
console.error('Exception addGareDesservie:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Met à jour une gare desservie dans l'horaire
|
|
*/
|
|
export async function updateGareDesservie(horaireId, gareData) {
|
|
if (!isSupabaseConfigured) {
|
|
return { data: gareData, error: null };
|
|
}
|
|
|
|
try {
|
|
const { data: horaire, error: readErr } = await supabase
|
|
.from('horaires')
|
|
.select('gares_desservies, attributions_quais')
|
|
.eq('id', horaireId)
|
|
.single();
|
|
|
|
if (readErr) return { data: null, error: readErr };
|
|
|
|
const gares = Array.isArray(horaire?.gares_desservies) ? [...horaire.gares_desservies] : [];
|
|
const idx = gares.findIndex(g => (g.gare_id && g.gare_id === gareData.gare_id) || Number(g.ordre) === Number(gareData.ordre));
|
|
if (idx !== -1) {
|
|
gares[idx] = { ...gares[idx], ...gareData };
|
|
} else {
|
|
gares.push(gareData);
|
|
}
|
|
gares.sort((a, b) => (Number(a.ordre) || 0) - (Number(b.ordre) || 0));
|
|
|
|
const attributionsQuais = { ...(horaire?.attributions_quais || {}) };
|
|
const key = gareData.gare_id || gareData.gare_nom;
|
|
if (key && (gareData.quai || gareData.quai_reel)) {
|
|
attributionsQuais[key] = {
|
|
quai: gareData.quai || null,
|
|
quai_reel: gareData.quai_reel || null,
|
|
ordre: gareData.ordre
|
|
};
|
|
}
|
|
|
|
const { error } = await supabase
|
|
.from('horaires')
|
|
.update({
|
|
gares_desservies: gares,
|
|
attributions_quais: attributionsQuais,
|
|
updated_at: new Date()
|
|
})
|
|
.eq('id', horaireId);
|
|
|
|
return { data: gareData, error };
|
|
} catch (err) {
|
|
console.error('Exception updateGareDesservie:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Supprime une gare desservie de l'horaire
|
|
*/
|
|
export async function deleteGareDesservie(horaireId, target) {
|
|
if (!isSupabaseConfigured) return { error: null };
|
|
|
|
try {
|
|
const { data: horaire, error: readErr } = await supabase
|
|
.from('horaires')
|
|
.select('gares_desservies, attributions_quais')
|
|
.eq('id', horaireId)
|
|
.single();
|
|
|
|
if (readErr) return { error: readErr };
|
|
|
|
let gares = Array.isArray(horaire?.gares_desservies) ? [...horaire.gares_desservies] : [];
|
|
gares = gares.filter(g => g.gare_id !== target && Number(g.ordre) !== Number(target));
|
|
|
|
const { error } = await supabase
|
|
.from('horaires')
|
|
.update({ gares_desservies: gares, updated_at: new Date() })
|
|
.eq('id', horaireId);
|
|
|
|
return { error };
|
|
} catch (err) {
|
|
console.error('Exception deleteGareDesservie:', err);
|
|
return { error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Met à jour les quais directement dans la table unique horaires
|
|
*
|
|
* @param {string|number} horaireId - ID de l'horaire
|
|
* @param {Object} quaisParOrdre - Map { ordre -> quai_nom } pour les gares intermédiaires
|
|
* + clés spéciales "depart" et "arrivee"
|
|
*/
|
|
export async function updateQuaisHoraire(horaireId, quaisParOrdre, isPropagation = false) {
|
|
if (!isSupabaseConfigured) {
|
|
return { data: null, error: null };
|
|
}
|
|
|
|
try {
|
|
// 1. Lire directement depuis la table unique horaires
|
|
const { data: horaire, error: readErr } = await supabase
|
|
.from('horaires')
|
|
.select('numero_train, gares_desservies, attributions_quais, gare_depart_id, gare_depart_nom, gare_arrivee_id, gare_arrivee_nom, heure_depart, heure_arrivee')
|
|
.eq('id', horaireId)
|
|
.single();
|
|
|
|
if (readErr) {
|
|
console.error('Erreur lecture horaire:', readErr);
|
|
return { data: null, error: readErr };
|
|
}
|
|
|
|
const baseRows = Array.isArray(horaire.gares_desservies) ? [...horaire.gares_desservies] : [];
|
|
|
|
const existingDepartRow = baseRows.find(r => Number(r.ordre) === 0 || r.is_depart)
|
|
|| baseRows.find(r => isSameGare(r, horaire.gare_depart_id, horaire.gare_depart_nom) && r.heure_depart);
|
|
const rowsSansDepart = baseRows.filter(r => r !== existingDepartRow);
|
|
const maxOrdreBase = rowsSansDepart.reduce((m, e) => Math.max(m, Number(e.ordre || 0)), 0);
|
|
const existingArriveeRow = rowsSansDepart.find(r => r.is_arrivee)
|
|
|| rowsSansDepart.find(r => Number(r.ordre) === maxOrdreBase && isSameGare(r, horaire.gare_arrivee_id, horaire.gare_arrivee_nom))
|
|
|| rowsSansDepart.find(r => isSameGare(r, horaire.gare_arrivee_id, horaire.gare_arrivee_nom) && (r.heure_arrivee || !r.heure_depart));
|
|
|
|
const updatedIntermediaires = rowsSansDepart
|
|
.filter(r => r !== existingArriveeRow)
|
|
.map((g, idx) => ({
|
|
...g,
|
|
quai: (quaisParOrdre[g.ordre ?? idx + 1] !== undefined)
|
|
? (quaisParOrdre[g.ordre ?? idx + 1] || null)
|
|
: (g.quai || null)
|
|
}));
|
|
|
|
const maxOrdre = updatedIntermediaires.reduce((m, e) => Math.max(m, Number(e.ordre || 0)), 0);
|
|
const arriveeOrdre = maxOrdre + 1;
|
|
|
|
// Construire les entrées départ et arrivée avec les quais mis à jour
|
|
const departEntry = {
|
|
...(existingDepartRow || {}),
|
|
gare_id: existingDepartRow?.gare_id || horaire.gare_depart_id || null,
|
|
gare_nom: existingDepartRow?.gare_nom || horaire.gare_depart_nom || '',
|
|
heure_arrivee: null,
|
|
heure_depart: existingDepartRow?.heure_depart || horaire.heure_depart || null,
|
|
ordre: 0,
|
|
quai: (quaisParOrdre && Object.prototype.hasOwnProperty.call(quaisParOrdre, 'depart'))
|
|
? (quaisParOrdre.depart || null)
|
|
: (existingDepartRow?.quai || null),
|
|
quai_reel: existingDepartRow?.quai_reel || null,
|
|
is_depart: true
|
|
};
|
|
|
|
const arriveeEntry = {
|
|
...(existingArriveeRow || {}),
|
|
gare_id: existingArriveeRow?.gare_id || horaire.gare_arrivee_id || null,
|
|
gare_nom: existingArriveeRow?.gare_nom || horaire.gare_arrivee_nom || '',
|
|
heure_arrivee: existingArriveeRow?.heure_arrivee || horaire.heure_arrivee || null,
|
|
heure_depart: null,
|
|
ordre: arriveeOrdre,
|
|
quai: (quaisParOrdre && Object.prototype.hasOwnProperty.call(quaisParOrdre, 'arrivee'))
|
|
? (quaisParOrdre.arrivee || null)
|
|
: (existingArriveeRow?.quai || null),
|
|
quai_reel: existingArriveeRow?.quai_reel || null,
|
|
is_arrivee: true
|
|
};
|
|
|
|
const fullSnapshot = [departEntry, ...updatedIntermediaires, arriveeEntry];
|
|
|
|
// Mettre à jour attributions_quais O(1)
|
|
const attributionsQuais = { ...(horaire.attributions_quais || {}) };
|
|
fullSnapshot.forEach(g => {
|
|
const key = g.gare_id || g.gare_nom;
|
|
if (key) {
|
|
attributionsQuais[key] = {
|
|
quai: g.quai || null,
|
|
quai_reel: g.quai_reel || null,
|
|
ordre: g.ordre
|
|
};
|
|
}
|
|
});
|
|
|
|
// Sauvegarder dans la table unique horaires en UNE SEULE requête
|
|
const { data: saved, error: saveErr } = await supabase
|
|
.from('horaires')
|
|
.update({
|
|
gares_desservies: fullSnapshot,
|
|
attributions_quais: attributionsQuais,
|
|
updated_at: new Date()
|
|
})
|
|
.eq('id', horaireId)
|
|
.select('gares_desservies')
|
|
.single();
|
|
|
|
if (saveErr) {
|
|
console.error('Erreur sauvegarde quais dans horaires:', saveErr);
|
|
return { data: null, error: saveErr };
|
|
}
|
|
|
|
// Propager aux autres horaires ayant le même numéro de train si applicable
|
|
if (!isPropagation && horaire.numero_train) {
|
|
try {
|
|
const { data: others } = await supabase
|
|
.from('horaires')
|
|
.select('id')
|
|
.eq('numero_train', horaire.numero_train)
|
|
.neq('id', horaireId);
|
|
|
|
if (others && others.length > 0) {
|
|
for (const other of others) {
|
|
await updateQuaisHoraire(other.id, quaisParOrdre, true);
|
|
}
|
|
}
|
|
} catch (propErr) {
|
|
console.error('Erreur propagation updateQuaisHoraire:', propErr);
|
|
}
|
|
}
|
|
|
|
return { data: saved?.gares_desservies || fullSnapshot, error: null };
|
|
} catch (err) {
|
|
console.error('Exception updateQuaisHoraire:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Mise à jour groupée des quais pour plusieurs horaires.
|
|
* @param {Array<{horaireId: string|number, payload: Object}>} updates
|
|
*/
|
|
export async function updateQuaisBatch(updates) {
|
|
if (!isSupabaseConfigured) return { error: null };
|
|
try {
|
|
const results = [];
|
|
// Groupe les payloads par horaireId pour minimiser les appels
|
|
const byHoraire = {};
|
|
updates.forEach(u => {
|
|
if (!byHoraire[u.horaireId]) byHoraire[u.horaireId] = {};
|
|
Object.assign(byHoraire[u.horaireId], u.payload);
|
|
});
|
|
|
|
// On traite par paquets de 5 pour ne pas saturer Supabase tout en restant rapide
|
|
const horaireIds = Object.keys(byHoraire);
|
|
const CHUNK_SIZE = 5;
|
|
|
|
for (let i = 0; i < horaireIds.length; i += CHUNK_SIZE) {
|
|
const chunk = horaireIds.slice(i, i + CHUNK_SIZE);
|
|
await Promise.all(chunk.map(async (hid) => {
|
|
const { data, error } = await updateQuaisHoraire(hid, byHoraire[hid]);
|
|
results.push({ horaireId: hid, data, error });
|
|
}));
|
|
}
|
|
|
|
return { data: results, error: null };
|
|
} catch (err) {
|
|
console.error('Exception updateQuaisBatch:', err);
|
|
return { error: err };
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// UTILITAIRES
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Récupère tous les types de trains disponibles (pour le select)
|
|
*/
|
|
export function getTypesTrains() {
|
|
return [
|
|
{ value: 'TER', label: 'TER' },
|
|
{ value: 'TGV', label: 'TGV' },
|
|
{ value: 'Intercités', label: 'Intercités' },
|
|
{ value: 'Ouigo', label: 'Ouigo' },
|
|
{ value: 'Transilien', label: 'Transilien' },
|
|
{ value: 'RER', label: 'RER' },
|
|
{ value: 'Autocar', label: 'Autocar de substitution' },
|
|
{ value: 'Autre', label: 'Autre' }
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Formate une heure pour l'affichage (HH:MM)
|
|
*/
|
|
export function formatHeure(time) {
|
|
if (!time) return '-';
|
|
// Si c'est déjà au format HH:MM ou HH:MM:SS
|
|
if (typeof time === 'string') {
|
|
const parts = time.split(':');
|
|
if (parts.length >= 2) {
|
|
return `${parts[0].padStart(2, '0')}:${parts[1].padStart(2, '0')}`;
|
|
}
|
|
}
|
|
return time;
|
|
}
|
|
|
|
/**
|
|
* Récupère le nom des jours de circulation d'un horaire
|
|
*/
|
|
export function getJoursCirculation(horaire) {
|
|
if (!horaire) return [];
|
|
|
|
const parseBool = (v) => {
|
|
if (typeof v === 'boolean') return v;
|
|
if (typeof v === 'number') return v === 1;
|
|
if (typeof v === 'string') {
|
|
const s = v.trim().toLowerCase();
|
|
return s === 'true' || s === 't' || s === '1' || s === 'oui' || s === 'yes' || s === 'y';
|
|
}
|
|
return false;
|
|
};
|
|
|
|
const jours = [];
|
|
if (parseBool(horaire.circule_lundi)) jours.push('Lun');
|
|
if (parseBool(horaire.circule_mardi)) jours.push('Mar');
|
|
if (parseBool(horaire.circule_mercredi)) jours.push('Mer');
|
|
if (parseBool(horaire.circule_jeudi)) jours.push('Jeu');
|
|
if (parseBool(horaire.circule_vendredi)) jours.push('Ven');
|
|
if (parseBool(horaire.circule_samedi)) jours.push('Sam');
|
|
if (parseBool(horaire.circule_dimanche)) jours.push('Dim');
|
|
|
|
if (jours.length > 0) return jours;
|
|
|
|
// Fallback si formaté en chaîne de caractères
|
|
const txt = String(horaire.jours_circulation || horaire.frequence || horaire.periodicite || '').toLowerCase();
|
|
if (txt) {
|
|
if (txt.includes('tous') || txt.includes('quotidien') || txt.includes('7j')) {
|
|
return ['Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam', 'Dim'];
|
|
}
|
|
if (txt.includes('lun') && txt.includes('ven')) {
|
|
return ['Lun', 'Mar', 'Mer', 'Jeu', 'Ven'];
|
|
}
|
|
if (txt.includes('lun') && txt.includes('sam')) {
|
|
return ['Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'];
|
|
}
|
|
if (txt.includes('sam') && txt.includes('dim')) {
|
|
return ['Sam', 'Dim'];
|
|
}
|
|
if (txt.includes('dim')) return ['Dim'];
|
|
if (txt.includes('sam')) return ['Sam'];
|
|
if (txt.includes('ven')) return ['Ven'];
|
|
}
|
|
|
|
// Fallback jours personnalisés
|
|
if (Array.isArray(horaire.jours_personnalises) && horaire.jours_personnalises.length > 0) {
|
|
const dows = new Set();
|
|
const mapDow = ['Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'];
|
|
horaire.jours_personnalises.forEach(j => {
|
|
if (j && j.circule !== false && j.date) {
|
|
const d = new Date(j.date).getDay();
|
|
if (!isNaN(d)) dows.add(mapDow[d]);
|
|
}
|
|
});
|
|
if (dows.size > 0) {
|
|
return ['Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam', 'Dim'].filter(d => dows.has(d));
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
export async function updateQuaisReelsHoraire(horaireId, quaisParOrdre, isPropagation = false) {
|
|
if (!isSupabaseConfigured) {
|
|
return { data: null, error: null };
|
|
}
|
|
|
|
try {
|
|
// 1. Lire le JSONB actuel depuis horaires
|
|
const { data: horaire, error: readErr } = await supabase
|
|
.from('horaires')
|
|
.select('numero_train, gares_desservies, gare_depart_id, gare_depart_nom, gare_arrivee_id, gare_arrivee_nom, heure_depart, heure_arrivee')
|
|
.eq('id', horaireId)
|
|
.single();
|
|
|
|
if (readErr) {
|
|
console.error('Erreur lecture horaire:', readErr);
|
|
return { data: null, error: readErr };
|
|
}
|
|
|
|
// 2. Utiliser directement le snapshot JSONB existant
|
|
const baseRows = Array.isArray(horaire.gares_desservies) ? [...horaire.gares_desservies] : [];
|
|
|
|
const existingDepartRow = baseRows.find(r => Number(r.ordre) === 0 || r.is_depart)
|
|
|| baseRows.find(r => isSameGare(r, horaire.gare_depart_id, horaire.gare_depart_nom) && r.heure_depart);
|
|
const rowsSansDepart = baseRows.filter(r => r !== existingDepartRow);
|
|
const maxOrdreBase = rowsSansDepart.reduce((m, e) => Math.max(m, Number(e.ordre || 0)), 0);
|
|
const existingArriveeRow = rowsSansDepart.find(r => r.is_arrivee)
|
|
|| rowsSansDepart.find(r => Number(r.ordre) === maxOrdreBase && isSameGare(r, horaire.gare_arrivee_id, horaire.gare_arrivee_nom))
|
|
|| rowsSansDepart.find(r => isSameGare(r, horaire.gare_arrivee_id, horaire.gare_arrivee_nom) && (r.heure_arrivee || !r.heure_depart));
|
|
|
|
const updatedIntermediaires = rowsSansDepart
|
|
.filter(r => r !== existingArriveeRow)
|
|
.map((g, idx) => ({
|
|
...g,
|
|
quai_reel: (quaisParOrdre[g.ordre ?? idx + 1] !== undefined)
|
|
? (quaisParOrdre[g.ordre ?? idx + 1] || null)
|
|
: (g.quai_reel || null)
|
|
}));
|
|
|
|
const maxOrdre = updatedIntermediaires.reduce((m, e) => Math.max(m, Number(e.ordre || 0)), 0);
|
|
const arriveeOrdre = maxOrdre + 1;
|
|
|
|
// 3. Construire les entrées spéciales pour départ et arrivée (si présentes)
|
|
const departEntry = {
|
|
id: existingDepartRow?.id || null,
|
|
gare_id: existingDepartRow?.gare_id || horaire.gare_depart_id || null,
|
|
gare_nom: existingDepartRow?.gare_nom || horaire.gare_depart_nom || '',
|
|
heure_arrivee: null,
|
|
heure_depart: existingDepartRow?.heure_depart || horaire.heure_depart || null,
|
|
ordre: 0,
|
|
quai: existingDepartRow?.quai || null,
|
|
quai_reel: (quaisParOrdre && Object.prototype.hasOwnProperty.call(quaisParOrdre, 'depart'))
|
|
? (quaisParOrdre.depart || null)
|
|
: (existingDepartRow?.quai_reel || null),
|
|
is_depart: true
|
|
};
|
|
|
|
const arriveeEntry = {
|
|
id: existingArriveeRow?.id || null,
|
|
gare_id: existingArriveeRow?.gare_id || horaire.gare_arrivee_id || null,
|
|
gare_nom: existingArriveeRow?.gare_nom || horaire.gare_arrivee_nom || '',
|
|
heure_arrivee: existingArriveeRow?.heure_arrivee || horaire.heure_arrivee || null,
|
|
heure_depart: null,
|
|
ordre: arriveeOrdre,
|
|
quai: existingArriveeRow?.quai || null,
|
|
quai_reel: (quaisParOrdre && Object.prototype.hasOwnProperty.call(quaisParOrdre, 'arrivee'))
|
|
? (quaisParOrdre.arrivee || null)
|
|
: (existingArriveeRow?.quai_reel || null),
|
|
is_arrivee: true
|
|
};
|
|
|
|
// 4. Construire le snapshot complet : départ + intermédiaires + arrivée
|
|
const fullSnapshot = [departEntry, ...updatedIntermediaires, arriveeEntry];
|
|
|
|
// 5. Écrire le JSONB mis à jour dans horaires.gares_desservies
|
|
const { data: saved, error: saveErr } = await supabase
|
|
.from('horaires')
|
|
.update({ gares_desservies: fullSnapshot, updated_at: new Date() })
|
|
.eq('id', horaireId)
|
|
.select('gares_desservies')
|
|
.single();
|
|
|
|
if (saveErr) {
|
|
console.error('Erreur sauvegarde quais dans horaires.gares_desservies:', saveErr);
|
|
return { data: null, error: saveErr };
|
|
}
|
|
|
|
// 6. Propager aux autres horaires ayant le même numéro de train
|
|
if (!isPropagation && horaire.numero_train) {
|
|
try {
|
|
const { data: others } = await supabase
|
|
.from('horaires')
|
|
.select('id')
|
|
.eq('numero_train', horaire.numero_train)
|
|
.neq('id', horaireId);
|
|
|
|
if (others && others.length > 0) {
|
|
for (const other of others) {
|
|
await updateQuaisReelsHoraire(other.id, quaisParOrdre, true);
|
|
}
|
|
}
|
|
} catch (propErr) {
|
|
console.error('Erreur lors de la propagation de updateQuaisReelsHoraire:', propErr);
|
|
}
|
|
}
|
|
|
|
return { data: saved.gares_desservies, error: null };
|
|
} catch (err) {
|
|
console.error('Exception updateQuaisReelsHoraire:', err);
|
|
return { data: null, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupère le nombre d'horaires attribués à chaque quai d'une gare depuis la table unique horaires.
|
|
* @param {string} gareId
|
|
* @param {string} gareNom
|
|
* @returns {Promise<{data: Object<string, number>, error: any}>} Map de nom de quai -> compte
|
|
*/
|
|
export async function getHorairesCountByQuai(gareId, gareNom) {
|
|
if (!isSupabaseConfigured) return { data: {}, error: null };
|
|
try {
|
|
const { data, error } = await supabase
|
|
.from('horaires')
|
|
.select('gares_desservies, attributions_quais');
|
|
if (error) return { data: {}, error };
|
|
|
|
const counts = {};
|
|
if (data) {
|
|
data.forEach(h => {
|
|
if (h.attributions_quais && gareId && h.attributions_quais[gareId]?.quai) {
|
|
const q = h.attributions_quais[gareId].quai;
|
|
counts[q] = (counts[q] || 0) + 1;
|
|
} else if (Array.isArray(h.gares_desservies)) {
|
|
const match = h.gares_desservies.find(g =>
|
|
(gareId && g.gare_id === gareId) ||
|
|
(gareNom && normalizeGareName(g.gare_nom) === normalizeGareName(gareNom))
|
|
);
|
|
if (match?.quai) {
|
|
counts[match.quai] = (counts[match.quai] || 0) + 1;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return { data: counts, error: null };
|
|
} catch (err) {
|
|
return { data: {}, error: err };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Réassigne une gare source vers une gare cible directement dans la table unique horaires.
|
|
*/
|
|
export async function reassignGareInHoraires(sourceId, targetId, targetNom) {
|
|
if (!isSupabaseConfigured) return { error: null };
|
|
try {
|
|
// 1. Mettre à jour les colonnes d'origine et destination dans horaires
|
|
await supabase.from('horaires').update({ gare_depart_id: targetId, gare_depart_nom: targetNom }).eq('gare_depart_id', sourceId);
|
|
await supabase.from('horaires').update({ gare_arrivee_id: targetId, gare_arrivee_nom: targetNom }).eq('gare_arrivee_id', sourceId);
|
|
|
|
// 2. Mettre à jour le JSONB gares_desservies et attributions_quais
|
|
const { data: horaires } = await supabase
|
|
.from('horaires')
|
|
.select('id, gares_desservies, attributions_quais');
|
|
|
|
if (horaires) {
|
|
for (const h of horaires) {
|
|
if (Array.isArray(h.gares_desservies)) {
|
|
let modified = false;
|
|
const newGaresDesservies = h.gares_desservies.map(gd => {
|
|
if (gd.gare_id === sourceId) {
|
|
modified = true;
|
|
return { ...gd, gare_id: targetId, gare_nom: targetNom };
|
|
}
|
|
return gd;
|
|
});
|
|
if (modified) {
|
|
const attributionsQuais = { ...(h.attributions_quais || {}) };
|
|
if (attributionsQuais[sourceId]) {
|
|
attributionsQuais[targetId] = attributionsQuais[sourceId];
|
|
delete attributionsQuais[sourceId];
|
|
}
|
|
await supabase
|
|
.from('horaires')
|
|
.update({
|
|
gares_desservies: newGaresDesservies,
|
|
attributions_quais: attributionsQuais,
|
|
updated_at: new Date()
|
|
})
|
|
.eq('id', h.id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return { error: null };
|
|
} catch (err) {
|
|
console.error('Exception reassignGareInHoraires:', err);
|
|
return { error: err };
|
|
}
|
|
}
|