+
+
+
+ `;
+
+ this.shadowRoot.querySelectorAll('input').forEach(input => {
+ input.addEventListener('change', this.valueChanged.bind(this));
+ });
}
- createTrainSignature(trains) {
- return trains.map(train =>
- `${train.entity_id}:${train.attributes.departure_time}:${train.attributes.delay_minutes || 0}:${train.attributes.has_delay || false}`
- ).join('|');
+ valueChanged(ev) {
+ if (!this._config) return;
+ const target = ev.target;
+ let value = target.type === 'checkbox' ? target.checked : (target.type === 'number' ? Number(target.value) : target.value);
+ this._config = { ...this._config, [target.id]: value };
+ this.dispatchEvent(new CustomEvent('config-changed', { detail: { config: this._config }, bubbles: true, composed: true }));
}
+}
+customElements.define('sncf-train-card-editor', SncfTrainCardEditor);
- connectedCallback() {
- this.startUpdateTimer();
+// --- CARTE PRINCIPALE (LOGIQUE COMPLĂTE) ---
+class SncfTrainCard extends HTMLElement {
+ constructor() {
+ super();
+ this.attachShadow({ mode: 'open' });
+ this.updateInterval = null;
+ this.lastTrainSignature = null;
+ this._lastRenderTime = 0;
}
- disconnectedCallback() {
- this.stopUpdateTimer();
+ static getConfigElement() { return document.createElement("sncf-train-card-editor"); }
+
+ setConfig(config) {
+ if (!config.device_id) throw new Error('You need to define device_id');
+ this.config = {
+ title: "Trains SNCF",
+ train_emoji: "đ
",
+ train_station_emoji: "đ",
+ train_emoji_axial_symmetry: true,
+ animation_duration: 30,
+ use_real_duration: true,
+ speed_factor: 2,
+ update_interval: 30000,
+ show_real_stop_times: true,
+ ...config
+ };
+ this.render();
}
+ set hass(hass) {
+ this._hass = hass;
+ this.render();
+ }
+
+ connectedCallback() { this.startUpdateTimer(); }
+ disconnectedCallback() { this.stopUpdateTimer(); }
+
startUpdateTimer() {
this.stopUpdateTimer();
this.updateInterval = setInterval(async () => {
if (this._hass) {
- // Force un nouveau rendu à intervalles réguliers pour capturer les changements
- this._lastRenderTime = 0; // Reset du throttle
+ this._lastRenderTime = 0;
await this.render();
}
}, this.config.update_interval);
}
stopUpdateTimer() {
- if (this.updateInterval) {
- clearInterval(this.updateInterval);
- this.updateInterval = null;
- }
+ if (this.updateInterval) { clearInterval(this.updateInterval); this.updateInterval = null; }
}
async getTrainEntities() {
- if (!this._hass) return [];
-
+ if (!this._hass || !this.config.device_id) return [];
try {
- // Utiliser l'API Home Assistant pour récupérer toutes les entités
- const allEntityRegistry = await this._hass.callWS({
- type: 'config/entity_registry/list'
- });
-
- // Filtrer les entités par device_id
- const deviceEntities = allEntityRegistry.filter(entityInfo =>
- entityInfo.device_id === this.config.device_id
- );
-
- if (!deviceEntities || deviceEntities.length === 0) {
- console.warn('â ïž Aucune entitĂ© trouvĂ©e pour ce device_id dans le registre');
- return [];
- }
-
- // Récupérer les états des entités train trouvées avec données fraßches
- const trainEntities = deviceEntities
- .filter(entityInfo => entityInfo.entity_id.includes('train'))
- .map(entityInfo => {
- // Forcer la récupération de l'état frais
- const freshState = this._hass.states[entityInfo.entity_id];
- return freshState;
- })
- .filter(entity => entity && entity.attributes && entity.attributes.departure_time);
+ const allReg = await this._hass.callWS({ type: 'config/entity_registry/list' });
+ const deviceEntities = allReg.filter(e => e.device_id === this.config.device_id);
+ const trainEntities = deviceEntities.filter(e => e.entity_id.includes('train'))
+ .map(e => this._hass.states[e.entity_id])
+ .filter(e => e && e.attributes && e.attributes.departure_time);
- // Filtrer les trains qui ne sont pas encore passés
- const currentTime = new Date();
- const upcomingTrains = trainEntities.filter(entity => {
- const departureTime = this.parseTime(entity.attributes.departure_time);
- return departureTime >= currentTime;
- });
-
- const sortedEntities = upcomingTrains
- .sort((a, b) => {
- const aTime = this.parseTime(a.attributes.departure_time);
- const bTime = this.parseTime(b.attributes.departure_time);
- return aTime - bTime;
- })
- .slice(0, this.config.train_lines);
-
- return sortedEntities;
-
- } catch (error) {
- console.error('â Erreur lors de la rĂ©cupĂ©ration via API:', error);
- return [];
- }
- }
-
- // MĂ©thode pour parser correctement le format SNCF
- parseTime(departureTime) {
- if (!departureTime) {
- return new Date(0);
- }
-
- // Format SNCF: "19/11/2025 - 08:20"
- if (departureTime.includes('/') && departureTime.includes(' - ')) {
- const parts = departureTime.split(' - ');
- if (parts.length === 2) {
- const datePart = parts[0]; // "19/11/2025"
- const timePart = parts[1]; // "08:20"
-
- const dateComponents = datePart.split('/');
- if (dateComponents.length === 3) {
- const day = parseInt(dateComponents[0]);
- const month = parseInt(dateComponents[1]) - 1; // Mois 0-indexé
- const year = parseInt(dateComponents[2]);
-
- const timeComponents = timePart.split(':');
- if (timeComponents.length === 2) {
- const hour = parseInt(timeComponents[0]);
- const minute = parseInt(timeComponents[1]);
-
- return new Date(year, month, day, hour, minute);
- }
- }
- }
- }
-
- // Fallback vers Date classique
- return new Date(departureTime);
- }
-
- calculateTrainPosition(departureTime, currentTime) {
- if (!departureTime) {
- return -10;
- }
-
- const departure = this.parseTime(departureTime);
-
- if (isNaN(departure.getTime())) {
- return -10;
- }
-
- const now = currentTime || new Date();
- const diffMinutes = (departure - now) / (1000 * 60);
-
- // Train apparaĂźt 30 minutes avant l'heure
- const maxMinutes = this.config.animation_duration;
-
- if (diffMinutes > maxMinutes) {
- return -10; // Hors de la barre
- }
- if (diffMinutes <= 0) {
- return 100; // Arrivé à la gare
- }
-
- // Position sur la barre (0% = gauche, 100% = droite)
- return ((maxMinutes - diffMinutes) / maxMinutes) * 100;
- }
-
- formatTime(timeString) {
- if (!timeString) {
- return 'N/A';
- }
-
- const time = this.parseTime(timeString);
-
- if (isNaN(time.getTime())) {
- return 'Format invalide';
- }
-
- const result = time.toLocaleTimeString('fr-FR', {
- hour: '2-digit',
- minute: '2-digit'
- });
-
- return result;
- }
-
- calculateRealArrivalTime(departureTime, delayMinutes) {
- if (!departureTime || !delayMinutes || delayMinutes === 0) {
- return null;
- }
-
- const originalTime = this.parseTime(departureTime);
- const realTime = new Date(originalTime.getTime() + (delayMinutes * 60000)); // Ajouter les minutes de retard
-
- return realTime.toLocaleTimeString('fr-FR', {
- hour: '2-digit',
- minute: '2-digit'
- });
+ const now = new Date();
+ return trainEntities.filter(e => this.parseTime(e.attributes.departure_time) >= now)
+ .sort((a, b) => this.parseTime(a.attributes.departure_time) - this.parseTime(b.attributes.departure_time))
+ .slice(0, this.config.train_lines || 3);
+ } catch (e) { return []; }
}
- getTrainColor(delayMinutes, hasDelay) {
- if (!hasDelay || delayMinutes === 0) return '#4caf50'; // Vert Ă l'heure
- return '#f44336'; // Rouge en retard (peu importe le nombre de minutes)
+ parseTime(t) {
+ if (!t || !t.includes(' - ')) return new Date(0);
+ const p = t.split(' - '), d = p[0].split('/'), h = p[1].split(':');
+ return new Date(d[2], d[1]-1, d[0], h[0], h[1]);
}
- async render() {
- if (!this._hass || !this.config) {
- return;
- }
-
- // Ăviter les rendus trop frĂ©quents (max 1 par seconde)
- const now = Date.now();
- if (now - this._lastRenderTime < 1000) {
- return;
- }
- this._lastRenderTime = now;
-
- const trains = await this.getTrainEntities();
+ render() {
+ if (!this._hass || !this.config) return;
- if (trains.length === 0) {
- this.shadowRoot.innerHTML = `
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
- Aucun train trouvé pour ce device. Vérifiez la configuration.
-
-
-
-
-
- ${trainLinesHTML}
-
- ${this.config.title}
-
-
- ${position >= 0 && position <= 100 ? `
-
- ${this.config.train_emoji}
+ let timelineHTML = '';
+ if (this.config.show_route_details && attrs.stops_schedule) {
+ timelineHTML = `
+
+
+
-
-
+ ${attrs.stops_schedule.map(s => {
+ const isDeleted = s.effect === 'deleted';
+ const isAdded = s.effect === 'added';
+ const isStopDelayed = this.config.show_real_stop_times && s.amended_time && s.base_time && (s.amended_time !== s.base_time);
+
+ const displayTime = isStopDelayed ?
+ `${s.base_time}${s.amended_time}` :
+ `${s.base_time || s.time}`;
+
+ let statusBadge = "";
+ if (isDeleted) statusBadge = ' SUPPRIMĂ';
+ else if (isAdded) statusBadge = ' RAJOUTĂ';
+
+ return `
+
- ` : `
-
- `}
-
+
+
`;
+ }).join('')}
${displayTime}
+
+ ${s.name}${statusBadge}
+
+
-
+ `;
+ });
}
}
-
-// Définir l'élément custom
customElements.define('sncf-train-card', SncfTrainCard);
\ No newline at end of file
diff --git a/tests/test_config_flow.py b/tests/test_config_flow.py
new file mode 100644
index 0000000..43578bf
--- /dev/null
+++ b/tests/test_config_flow.py
@@ -0,0 +1,90 @@
+import pytest
+from unittest.mock import AsyncMock, patch
+
+from homeassistant import config_entries
+from custom_components.sncf_trains.const import DOMAIN, CONF_API_KEY
+
+
+@pytest.mark.asyncio
+async def test_config_flow_happy_path(hass):
+ """Test config flow with valid API key and stations."""
+ mock_api = AsyncMock()
+ mock_api.search_stations = AsyncMock(
+ side_effect=[
+ [{"id": "stop_area:dep", "name": "Paris Gare de Lyon"}], # departure city
+ [{"id": "stop_area:arr", "name": "Lyon Part Dieu"}], # arrival city
+ ]
+ )
+
+ with patch(
+ "custom_components.sncf_trains.config_flow.SncfApiClient", return_value=mock_api
+ ):
+ # Step 1: saisie API key
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN, context={"source": config_entries.SOURCE_USER}
+ )
+ assert result["type"] == "form"
+ assert result["step_id"] == "user"
+
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"], {CONF_API_KEY: "valid_key"}
+ )
+ assert result["type"] == "form"
+ assert result["step_id"] == "departure_city"
+
+ # Step 2: ville départ
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"], {"departure_city": "Paris"}
+ )
+ assert result["type"] == "form"
+ assert result["step_id"] == "departure_station"
+
+ # Step 3: station départ
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"], {"departure_station": "stop_area:dep"}
+ )
+ assert result["type"] == "form"
+ assert result["step_id"] == "arrival_city"
+
+ # Step 4: ville arrivée
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"], {"arrival_city": "Lyon"}
+ )
+ assert result["type"] == "form"
+ assert result["step_id"] == "arrival_station"
+
+ # Step 5: station arrivée
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"], {"arrival_station": "stop_area:arr"}
+ )
+ assert result["type"] == "form"
+ assert result["step_id"] == "time_range"
+
+ # Step 6: plage horaire + finalisation
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"], {"time_start": "07:00", "time_end": "10:00"}
+ )
+ assert result["type"] == "create_entry"
+ assert result["title"] == "SNCF: Paris Gare de Lyon â Lyon Part Dieu"
+ assert result["data"]["departure_name"] == "Paris Gare de Lyon"
+
+
+@pytest.mark.asyncio
+async def test_config_flow_invalid_api_key(hass):
+ """Test config flow with invalid API key."""
+ mock_api = AsyncMock()
+ mock_api.search_stations = AsyncMock(return_value=None)
+
+ with patch(
+ "custom_components.sncf_trains.config_flow.SncfApiClient", return_value=mock_api
+ ):
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN, context={"source": config_entries.SOURCE_USER}
+ )
+
+ result = await hass.config_entries.flow.async_configure(
+ result["flow_id"], {CONF_API_KEY: "bad_key"}
+ )
+
+ assert result["type"] == "form"
+ assert result["errors"]["base"] == "invalid_api_key"
diff --git a/tests/test_coordinator.py b/tests/test_coordinator.py
new file mode 100644
index 0000000..1e233f1
--- /dev/null
+++ b/tests/test_coordinator.py
@@ -0,0 +1,78 @@
+import pytest
+from unittest.mock import AsyncMock
+from datetime import timedelta
+from homeassistant.helpers.update_coordinator import UpdateFailed
+
+from custom_components.sncf_trains.coordinator import SncfUpdateCoordinator
+
+
+@pytest.mark.asyncio
+async def test_coordinator_success(hass):
+ """Test coordinator fetches journeys successfully."""
+ mock_api = AsyncMock()
+ mock_api.fetch_journeys = AsyncMock(return_value=[{"id": "j1"}])
+
+ coordinator = SncfUpdateCoordinator(
+ hass=hass,
+ api_client=mock_api,
+ departure="stop_area:dep",
+ arrival="stop_area:arr",
+ time_start="06:00",
+ time_end="09:00",
+ update_interval=5,
+ outside_interval=30,
+ )
+
+ data = await coordinator._async_update_data()
+ assert data == [{"id": "j1"}]
+ mock_api.fetch_journeys.assert_called_once()
+ assert isinstance(coordinator.update_interval, timedelta)
+
+
+@pytest.mark.asyncio
+async def test_coordinator_api_failure(hass):
+ """Test coordinator raises UpdateFailed when API fails."""
+ mock_api = AsyncMock()
+ mock_api.fetch_journeys = AsyncMock(side_effect=Exception("API error"))
+
+ coordinator = SncfUpdateCoordinator(
+ hass=hass,
+ api_client=mock_api,
+ departure="stop_area:dep",
+ arrival="stop_area:arr",
+ time_start="06:00",
+ time_end="09:00",
+ )
+
+ with pytest.raises(UpdateFailed):
+ await coordinator._async_update_data()
+
+
+@pytest.mark.asyncio
+async def test_coordinator_adjust_interval(hass):
+ """Test that update interval adjusts inside and outside time range."""
+
+ mock_api = AsyncMock()
+ mock_api.fetch_journeys = AsyncMock(return_value=[{"id": "j1"}])
+
+ coordinator = SncfUpdateCoordinator(
+ hass=hass,
+ api_client=mock_api,
+ departure="stop_area:dep",
+ arrival="stop_area:arr",
+ time_start="00:00",
+ time_end="23:59",
+ update_interval=5,
+ outside_interval=30,
+ )
+
+ # Forcing inside time range (always true here)
+ await coordinator._async_update_data()
+ assert coordinator.update_interval == timedelta(minutes=5)
+
+ # Fake outside range by setting opposite times
+ coordinator.time_start = "23:59"
+ coordinator.time_end = "00:00"
+
+ await coordinator._async_update_data()
+ assert coordinator.update_interval == timedelta(minutes=30)
${this.config.train_station_emoji}
-
-
`;
+ }).join('');
- getCardSize() {
- return Math.max(3, this.config.train_lines + 1);
+ this.shadowRoot.innerHTML = `
+
+
- ${hasDelay && realArrivalTime ? `
-
`;
+ }
+
+ const timeOnly = (t) => t ? t.split(' - ')[1] : "--:--";
+
+ return `
+ ${formattedTime}
- ${realArrivalTime}
- ` : `
- ${formattedTime}
- `}
+
+
- `;
-
- return html;
- }).join('');
- }
+ ${timelineHTML}
+
+
-
+ ${pos >= 0 && pos <= 100 ? `
+
-
+ ${isCanceled ? 'â' : this.config.train_emoji}
+
+ ` : ''}
- ${hasDelay ? `+${delayMinutes}min` : 'Ă l\'heure'}
+
-
+
${this.config.train_station_emoji}
+
+
${hasDelay ? `${timeOnly(attrs.base_departure_time)}${timeOnly(attrs.departure_time)}` : timeOnly(attrs.departure_time)}
+
+ ${isCanceled ? 'ANNULĂ' : (hasDelay ? `+${attrs.delay_minutes}min` : 'Ă l\'heure')}
+
+ ${attrs.delay_cause ? `${attrs.delay_cause}
` : ''}
+ ${this.config.title}
+ ${trainLinesHTML}
+