Crédit-bail

Étude de cas Leasing et recueil de recettes SQL

Activer Requête IoT avant d'utiliser les données pour construire des analyses complètes. Si vous ne l'avez pas encore, contactez‑nous pour les détails d'activation - [email protected]

Les sociétés de leasing (en particulier les banques et les prestataires de location longue durée de flotte) conservent la propriété du véhicule ou de l'équipement tandis que le client n'en loue que l'utilisation, elles absorbent donc le risque lié à l'actif pendant toute la durée du contrat. 

Pour protéger la valeur résiduelle, faire respecter les limites contractuelles (kilométrage, géographie, entretien) et rationaliser les obligations de service complet, elles s'appuient sur Navixy. Les données GPS en temps réel, le diagnostic basé sur les capteurs et l'analyse comportementale leur permettent de vérifier les conditions d'utilisation, d'automatiser la planification des services, de détecter précocement les problèmes mécaniques, de calculer les pénalités ou frais pour kilomètres excédentaires, et, si nécessaire, d'immobiliser ou récupérer l'actif — ce qui sécurise leur investissement, réduit les coûts opérationnels et améliore la transparence client tout au long du cycle de leasing.

Navixy Requête IoT aidera à organiser tout type d'analytique à chaque étape du contrat de leasing. Un contrat de leasing traverse plusieurs phases prévisibles : Intégration & Configuration de l'Actif → Phase Opérationnelle → Supervision du Risque & Conformité

Les recettes SQL suivantes dans votre livre surveillent collectivement chaque jalon critique de ce cycle de vie :

Phase du cycle de vie	Objectifs & Jalons	Cas d'utilisation / Recettes couvertes
Intégration & Configuration de l'Actif	• Enregistrer le véhicule, activer l'assurance et les identifiants du conducteur. • Importer les actifs dans le portail client avec la visibilité correcte.	Alertes d'expiration d'immatriculation/assurance – dates de référence capturées. Expiration du permis de conduire – validation des conducteurs avant mise en circulation.
Planification de la maintenance préventive	• Établir des calendriers de service récurrents basés sur le kilométrage et le temps. • Garantir les changements saisonniers de pneus.	Inspections de routine par intervalle – tâches pilotées par calendrier. Service par seuil de kilométrage – règles de révision mineure/majeure basées sur les km. Surveillance des heures moteur – maintenance horaire pour les machines.
Limites d'utilisation contractuelles	• Faire respecter les allocations de kilométrage et les plafonds financiers. • Détecter le sur‑usage tôt pour éviter les surprises en fin de contrat.	Plafond de kilométrage & pénalités – contrôle annuel / total du contrat en kilomètres.
Comportement en temps réel du conducteur & de l'actif	• Protéger la valeur de l'actif ; coacher les conducteurs. • Repérer les mauvais usages qui annulent la couverture « full‑service ».	Freinage brutal. Accélération brutale. Virages/survirages soudains.
Supervision du risque & conformité	• Maintenir les actifs à l'intérieur des limites géographiques et contractuelles. • Conserver le droit de désactiver ou de récupérer.	Sortie de géofence (frontière nationale) – alerte instantanée en cas de franchissement de territoire. Détection d'allumage & d'inactivité – suivi du gaspillage de carburant / mauvais usage.

Alertes d'expiration d'immatriculation / assurance

Les banques doivent suivre les prochaines expirations d'immatriculation et d'assurance car elles sont responsables des inspections techniques, de l'immatriculation et de l'assurance. Des alertes opportunes évitent les amendes et les immobilisations de véhicules.

SELECT v.vehicle_id,       v.vehicle_label,       v.registration_number,       v.free_insurance_valid_till_date,       v.liability_insurance_valid_tillFROM raw_business_data.vehicles vWHERE v.free_insurance_valid_till_date BETWEEN CURRENT_DATE AND CURRENT_DATE + (30 * INTERVAL '1 day')   OR v.liability_insurance_valid_till   BETWEEN CURRENT_DATE1 AND CURRENT_DATE + (30 * INTERVAL '1 day');

Expiration du permis de conduire

Bien que ce ne soit pas toujours obligatoire, proposer des alertes proactives d'expiration de permis est un service à valeur ajoutée. Les avertissements précoces permettent aux clients de renouveler les permis avant leur expiration. Veuillez noter que vous

SELECT e.employee_id,
       e.first_name || ' ' || e.last_name AS driver_name,
       e.driver_license_number,
       e.driver_license_valid_till
FROM raw_business_data.employees e
WHERE e.driver_license_valid_till BETWEEN CURRENT_DATE AND CURRENT_DATE + (30 * INTERVAL '1 day');

Sortie de géofence (frontière nationale)

Les contrats peuvent restreindre le mouvement du véhicule à un territoire spécifique (par ex., Serbie). La sortie de cette zone doit alerter instantanément la banque afin qu'elle puisse agir (par ex., contacter le client, immobiliser l'actif).

Cette requête SQL est conçue pour surveiller et identifier lorsqu'un appareil sort d'une zone géographique prédéfinie étiquetée "Tallaght Depot Geofences." Le processus commence par la collecte et l'ordonnancement des points géographiques qui définissent la frontière de la zone. Pour garantir que la frontière forme un polygone valide, le premier point est ajouté à la fin de la liste, fermant ainsi la forme. Cet ensemble fermé de points est ensuite utilisé pour créer un polygone représentant la zone géographique, qui est converti en objet geography pour l'analyse spatiale.

La requête récupère ensuite les données de suivi des appareils dans une plage temporelle spécifiée, convertissant les valeurs brutes de latitude et de longitude en points géographiques. Elle calcule si chaque point d'appareil est à l'intérieur ou à l'extérieur de la zone prédéfinie en utilisant la fonction ST_Contains, qui vérifie l'inclusion spatiale. Le paramètre calculé pos indique « inside » si le point est à l'intérieur de la zone et « outside » sinon. Enfin, la requête filtre ces résultats pour détecter les transitions où un appareil passe de l'intérieur vers l'extérieur de la zone, en utilisant une fonction fenêtre pour comparer la position actuelle avec la précédente. Cette logique aide à surveiller les mouvements des appareils et à détecter les événements de sortie de zones géographiques spécifiques. Assurez‑vous d'ajouter la valeur correcte pour le paramètre : z.zone_label = 'your_zone_label'.

WITH zone AS (
  SELECT z.zone_id,
         ST_MakePolygon(ST_MakeLine(ARRAY_AGG(ST_MakePoint(g.longitude, g.latitude) ORDER BY g.number)))::geography AS geog
  FROM raw_business_data.zones z
  JOIN raw_business_data.geofence_points g ON g.zone_id = z.zone_id
  WHERE z.zone_label = 'your_zone_label'
  GROUP BY z.zone_id
),
pts AS (
  SELECT device_id,
         device_time,
         ST_SetSRID(ST_MakePoint(longitude/1e7::numeric, latitude/1e7::numeric), 4326)::geography AS geog
  FROM raw_telematics_data.tracking_data_core
  WHERE device_time BETWEEN '2025-07-27 00:00:00' AND '2025-07-28 23:59:59'
),
states AS (
  SELECT p.*,
         CASE WHEN ST_Contains(z.geog::geometry, p.geog::geometry) THEN 'inside' ELSE 'outside' END AS pos
  FROM pts p CROSS JOIN zone z
),
filtered_states AS (
  SELECT
    device_id,
    device_time,
    pos,
    LAG(pos) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_pos
  FROM states
)
SELECT device_id, device_time, pos
FROM filtered_states
WHERE prev_pos = 'inside' AND pos = 'outside';

Inspections de routine par intervalle de temps

Certaines tâches de maintenance se répètent selon des calendriers fixes. Le système doit signaler les véhicules dont la prochaine inspection/vérification est due dans un intervalle défini.

SELECT vehicle_id,       description,       start_date,       date_repeat_interval,       start_date + date_repeat_interval * floor(EXTRACT(EPOCH FROM (CURRENT_DATE - start_date)) /                                                 EXTRACT(EPOCH FROM date_repeat_interval)) AS last_due,       start_date + date_repeat_interval * (floor(EXTRACT(EPOCH FROM (CURRENT_DATE - start_date)) /                                                  EXTRACT(EPOCH FROM date_repeat_interval)) + 1) AS next_dueFROM raw_business_data.vehicle_service_tasksWHERE date_repeat_interval IS NOT NULL  AND start_date + date_repeat_interval * (floor(EXTRACT(EPOCH FROM (CURRENT_DATE - start_date)) /                                                 EXTRACT(EPOCH FROM date_repeat_interval)) + 1)      BETWEEN CURRENT_DATE AND CURRENT_DATE + (30 * INTERVAL '1 day');

Service par seuil de kilométrage (mineur/majeur)

Les révisions mineures et majeures sont déclenchées par le kilométrage depuis le dernier service. Lorsque les kilomètres accumulés dépassent le seuil, le service approprié doit être planifié.

Veuillez noter que le champ vst.description doit contenir des commentaires / descriptions pertinents pour l'utiliser dans les filtres du code SQL ci‑dessous.

SELECT
  v.vehicle_id,
  v.vehicle_label,
  km.km_since_service,
  vst.mileage_limit
FROM
  raw_business_data.vehicles v
  JOIN LATERAL (
    SELECT MAX(vst.completion_date) AS last_service_date
    FROM raw_business_data.vehicle_service_tasks vst
    WHERE vst.vehicle_id = v.vehicle_id
      AND (vst.description ILIKE '%minor%' OR vst.description ILIKE '%major%')
      AND vst.completion_date IS NOT NULL
  ) ls ON TRUE
  JOIN raw_business_data.objects o ON o.object_id = v.vehicle_id
  JOIN LATERAL (
    SELECT SUM(t.track_distance_meters) / 1000.0 AS km_since_service
    FROM business_data.tracks t
    WHERE t.device_id = o.device_id
      AND t.track_start_time > ls.last_service_date
  ) km ON TRUE
  JOIN raw_business_data.vehicle_service_tasks vst
    ON vst.vehicle_id = v.vehicle_id
    AND vst.completion_date = ls.last_service_date
    AND (vst.description ILIKE '%minor%' OR vst.description ILIKE '%major%')

Plafond de kilométrage & pénalités

Les contrats de leasing plafonnent souvent le kilométrage (par ex., 25 000 km/an). Si la limite est dépassée, des clauses pénales s'appliquent. Le système doit comparer le kilométrage réel sur la période du contrat avec la limite convenue et calculer les frais.

WITH driven AS (
  SELECT
    o.object_id,
    DATE_TRUNC('year', t.track_start_time) AS year,
    SUM(t.track_distance_meters) / 1000.0 AS km_year
  FROM
    business_data.tracks t
    JOIN raw_business_data.objects o ON o.device_id = t.device_id
  WHERE
    t.track_start_time >= '2023-01-01'::date
    AND t.track_start_time < '2024-01-01'::date
  GROUP BY
    o.object_id, DATE_TRUNC('year', t.track_start_time)
),
limits AS (
  SELECT
    object_id,
    10000 AS km_limit,
    0.5 AS penalty_rate
  FROM
    raw_business_data.objects
)
SELECT
  d.object_id,
  d.year,
  d.km_year,
  l.km_limit,
  GREATEST(d.km_year - l.km_limit, 0) AS km_over,
  GREATEST(d.km_year - l.km_limit, 0) * l.penalty_rate AS penalty_amount
FROM
  driven d
  JOIN limits l ON d.object_id = l.object_id;

Surveillance des heures moteur

Pour la machinerie et les équipements agricoles, ce sont les heures de fonctionnement — et non le kilométrage — qui déterminent la maintenance et la facturation. Les données d'heures moteur (par ex., depuis le CAN‑Bus) doivent être surveillées et synthétisées.

WITH last_service AS (
  SELECT
    vst.vehicle_id,
    MAX(vst.completion_date) AS last_service_date,
    MAX(vst.completion_engine_hours) AS last_service_engine_hours
  FROM
    raw_business_data.vehicle_service_tasks vst
  GROUP BY
    vst.vehicle_id
),
engine_hours_since_service AS (
  SELECT
    v.vehicle_id,
    SUM(t.track_duration_seconds) / 3600.0 AS engine_hours_since_service
  FROM
    raw_business_data.vehicles v
    JOIN raw_business_data.objects o ON o.object_id = v.object_id
    JOIN business_data.tracks t ON t.device_id = o.device_id
    JOIN last_service ls ON ls.vehicle_id = v.vehicle_id
  WHERE
    t.track_start_time > ls.last_service_date
  GROUP BY
    v.vehicle_id
)
SELECT
  v.vehicle_id,
  v.vehicle_label,
  ls.last_service_engine_hours,
  ehs.engine_hours_since_service,
  (COALESCE(ehs.engine_hours_since_service,0) + COALESCE(ls.last_service_engine_hours,0)) AS current_engine_hours,
  vst.engine_hours_limit
FROM
  raw_business_data.vehicles v
  JOIN last_service ls ON ls.vehicle_id = v.vehicle_id
  LEFT JOIN engine_hours_since_service ehs ON ehs.vehicle_id = v.vehicle_id
  JOIN raw_business_data.vehicle_service_tasks vst
    ON vst.vehicle_id = v.vehicle_id
    AND vst.completion_date = ls.last_service_date

Événements de freinage brutal

Le comportement de conduite affecte l'usure et la conformité au contrat. La détection du freinage brutal aide la banque à attribuer l'usure prématurée des freins/des pneus à un mauvais usage par le conducteur et, si nécessaire, à transférer les coûts.

La requête SQL ci‑dessous calcule d'abord la vitesse en kilomètres par heure et la différence de temps entre points de données consécutifs pour chaque appareil. À partir de ces informations, elle calcule ensuite le taux de décélération en kilomètres par heure par seconde. Enfin, elle filtre et renvoie les enregistrements où le taux de décélération est supérieur ou égal à 20 km/h par seconde, indiquant des événements de décélération significatifs.

WITH spd AS (
  SELECT
    device_id,
    device_time,
    speed/100.0 AS kmh,
    LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh,
    EXTRACT(EPOCH FROM (device_time - LAG(device_time) OVER (PARTITION BY device_id ORDER BY device_time))) AS dt_sec
  FROM
    raw_telematics_data.tracking_data_core
  WHERE
    device_time BETWEEN '2025-07-24 00:00:00' AND '2025-07-24 23:59:59'
),
decels AS (
  SELECT
    device_id,
    device_time,
    (prev_kmh - kmh) / NULLIF(dt_sec, 0) AS decel_kmh_per_sec
  FROM
    spd
  WHERE
    prev_kmh IS NOT NULL
)
SELECT *
FROM decels
WHERE decel_kmh_per_sec >= 20;

Événements d'accélération brutale

Une accélération agressive augmente l'usure des pneus, des transmissions, des trains motrices et des supports moteur. Identifier ces événements favorise le coaching et une éventuelle récupération des coûts.

La requête SQL ci‑dessous est conçue pour identifier des événements d'accélération significatifs à partir d'un jeu de données de suivi. Elle calcule d'abord la vitesse en kilomètres par heure et la différence de temps entre points consécutifs pour chaque appareil. En utilisant ces informations, elle calcule ensuite le taux d'accélération en kilomètres par heure par seconde. Enfin, elle filtre et renvoie les enregistrements où le taux d'accélération atteint ou dépasse un seuil spécifié, indiquant des événements d'accélération significatifs.

WITH spd AS (
  SELECT
    device_id,
    device_time,
    speed/100.0 AS kmh,
    LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh,
    EXTRACT(EPOCH FROM (device_time - LAG(device_time) OVER (PARTITION BY device_id ORDER BY device_time))) AS dt_sec
  FROM
    raw_telematics_data.tracking_data_core
  WHERE
    device_time BETWEEN '2025-07-28 00:00:00' AND '2025-07-28 23:59:59'
)
SELECT
  device_id,
  device_time,
  (kmh - prev_kmh) / NULLIF(dt_sec, 0) AS accel_kmh_per_sec
FROM
  spd
WHERE
  prev_kmh IS NOT NULL
  AND (kmh - prev_kmh) / NULLIF(dt_sec, 0) >= 20;

Virages soudains / Prises de tournant

Les virages brusques combinés à des changements de vitesse abrupts indiquent une conduite à risque. Le suivi de ce comportement aide à détecter une utilisation inappropriée du véhicule.

Cette requête SQL est conçue pour identifier des changements significatifs de direction et de vitesse à partir des données de suivi sur une période spécifiée. Elle convertit d'abord les valeurs brutes de latitude et de longitude en degrés décimaux et calcule la vitesse en kilomètres par heure. En utilisant la fonction LAG, elle récupère les données de position et de vitesse précédentes pour chaque appareil, permettant le calcul des changements dans le temps. La requête calcule ensuite le changement d'azimut en degrés à l'aide de fonctions trigonométriques pour déterminer le relèvement entre points consécutifs. Elle calcule également le changement de vitesse entre ces points. Enfin, la requête filtre les résultats pour n'inclure que les enregistrements où la variation absolue d'azimut est de 10 degrés ou plus et la variation absolue de vitesse est de 5 km/h ou plus, identifiant ainsi des manœuvres ou événements significatifs dans les données de suivi.

WITH pts AS (
  SELECT
    device_id,
    device_time,
    latitude/1e7::numeric AS lat,
    longitude/1e7::numeric AS lon,
    LAG(latitude/1e7::numeric) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_lat,
    LAG(longitude/1e7::numeric) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_lon,
    speed/100.0 AS kmh,
    LAG(speed/100.0) OVER (PARTITION BY device_id ORDER BY device_time) AS prev_kmh
  FROM
    raw_telematics_data.tracking_data_core
  WHERE
    device_time BETWEEN '2025-07-28 00:00:00' AND '2025-07-28 23:59:59'
),
bearing AS (
  SELECT *,
         atan2(
           sin(radians(lon-prev_lon))*cos(radians(lat)),
           cos(radians(prev_lat))*sin(radians(lat)) -
           sin(radians(prev_lat))*cos(radians(lat))*cos(radians(lon-prev_lon))
         ) * 180/pi() AS heading_change,
         (kmh - prev_kmh) AS delta_speed
  FROM pts
)
SELECT *
FROM bearing
WHERE abs(heading_change) >= 10
  AND abs(delta_speed) >= 5;

Détection d'allumage & d'inactivité

Mesurer le temps d'inactivité (allumage, faible/aucune vitesse) aide à réduire le gaspillage de carburant et à identifier les mauvais usages. Les longues périodes d'inactivité doivent être signalées et gérées.

WITH ign AS (  SELECT device_id,         device_time,         value::int AS ign_on  FROM raw_telematics_data.states  WHERE state_name = 'ignition'    AND device_time BETWEEN :from_ts AND :to_ts),spd AS (  SELECT device_id, device_time, speed/100.0 AS kmh  FROM raw_telematics_data.tracking_data_core  WHERE device_time BETWEEN :from_ts AND :to_ts),merged AS (  SELECT i.device_id,         i.device_time,         i.ign_on,         s.kmh,         LEAD(i.device_time) OVER (PARTITION BY i.device_id ORDER BY i.device_time) AS next_time  FROM ign i  LEFT JOIN spd s USING (device_id, device_time))SELECT device_id,       device_time AS idle_start,       next_time   AS idle_end,       EXTRACT(EPOCH FROM (next_time - device_time))/60 AS idle_minutesFROM mergedWHERE ign_on = 1 AND kmh < :idle_speed AND next_time - device_time >= INTERVAL ':idle_min minutes';