carconnectivity-plugin-database 0.1a16__py3-none-any.whl → 0.1a21__py3-none-any.whl

carconnectivity_plugins/database/agents/charging_agent.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING
 import threading
 
 import logging
-from datetime import timedelta
+from datetime import timedelta, datetime, timezone
 
 from sqlalchemy.exc import DatabaseError
 
@@ -27,8 +27,9 @@ if TYPE_CHECKING:
     from sqlalchemy.orm import scoped_session
     from sqlalchemy.orm.session import Session
 
-    from carconnectivity.attributes import EnumAttribute, SpeedAttribute, PowerAttribute
+    from carconnectivity.attributes import EnumAttribute, SpeedAttribute, PowerAttribute, FloatAttribute
 
+    from carconnectivity_plugins.database.plugin import Plugin
     from carconnectivity_plugins.database.model.vehicle import Vehicle
     from carconnectivity.drive import ElectricDrive
 
@@ -37,13 +38,16 @@ LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents
 
 class ChargingAgent(BaseAgent):
 
-    def __init__(self, session_factory: scoped_session[Session], vehicle: Vehicle) -> None:
-        if vehicle is None or vehicle.carconnectivity_vehicle is None:
+    def __init__(self, database_plugin: Plugin, session_factory: scoped_session[Session], vehicle: Vehicle,
+                 carconnectivity_vehicle: ElectricVehicle) -> None:
+        if vehicle is None or carconnectivity_vehicle is None:
             raise ValueError("Vehicle or its carconnectivity_vehicle attribute is None")
-        if not isinstance(vehicle.carconnectivity_vehicle, ElectricVehicle):
+        if not isinstance(carconnectivity_vehicle, ElectricVehicle):
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is not an ElectricVehicle")
+        self.database_plugin: Plugin = database_plugin
         self.session_factory: scoped_session[Session] = session_factory
         self.vehicle: Vehicle = vehicle
+        self.carconnectivity_vehicle: ElectricVehicle = carconnectivity_vehicle
 
         with self.session_factory() as session:
             self.last_charging_session: Optional[ChargingSession] = session.query(ChargingSession).filter(ChargingSession.vehicle == vehicle) \
@@ -52,24 +56,22 @@ class ChargingAgent(BaseAgent):
                           ChargingSession.plug_connected_date.desc().nulls_first()).first()
 
             self.last_charging_session_lock: threading.RLock = threading.RLock()
-            self.carconnectivity_last_charging_state: Optional[Charging.ChargingState] = vehicle.carconnectivity_vehicle.charging.state.value
-            self.carconnectivity_last_connector_state: Optional[ChargingConnector.ChargingConnectorConnectionState] = vehicle.carconnectivity_vehicle.charging\
+            self.carconnectivity_last_charging_state: Optional[Charging.ChargingState] = self.carconnectivity_vehicle.charging.state.value
+            self.carconnectivity_last_connector_state: Optional[ChargingConnector.ChargingConnectorConnectionState] = self.carconnectivity_vehicle.charging\
                 .connector.connection_state.value
-            self.carconnectivity_last_connector_lock_state: Optional[ChargingConnector.ChargingConnectorLockState] = vehicle.carconnectivity_vehicle.charging\
+            self.carconnectivity_last_connector_lock_state: Optional[ChargingConnector.ChargingConnectorLockState] = self.carconnectivity_vehicle.charging\
                 .connector.lock_state.value
             if self.last_charging_session is not None and not self.last_charging_session.is_closed():
-                if vehicle.carconnectivity_vehicle.charging.state.value in (Charging.ChargingState.CHARGING, Charging.ChargingState.CONSERVATION) \
-                    or (vehicle.carconnectivity_vehicle.charging.connector.connection_state.enabled
-                        and vehicle.carconnectivity_vehicle.charging.connector.connection_state.value ==
+                if self.carconnectivity_vehicle.charging.state.value in (Charging.ChargingState.CHARGING, Charging.ChargingState.CONSERVATION) \
+                    or (self.carconnectivity_vehicle.charging.connector.connection_state.enabled
+                        and self.carconnectivity_vehicle.charging.connector.connection_state.value ==
                         ChargingConnector.ChargingConnectorConnectionState.CONNECTED) \
-                    or (vehicle.carconnectivity_vehicle.charging.connector.lock_state.enabled
-                        and vehicle.carconnectivity_vehicle.charging.connector.lock_state.value == ChargingConnector.ChargingConnectorLockState.LOCKED):
+                    or (self.carconnectivity_vehicle.charging.connector.lock_state.enabled
+                        and self.carconnectivity_vehicle.charging.connector.lock_state.value == ChargingConnector.ChargingConnectorLockState.LOCKED):
                     LOG.info("Last charging session for vehicle %s is still open during startup, will continue this session", vehicle.vin)
                 else:
                     LOG.info("Last charging session for vehicle %s is still open during startup, but we are not charging, ignoring it", vehicle.vin)
                     self.last_charging_session = None
-            else:
-                self.last_charging_session = None
 
             self.last_charging_state: Optional[ChargingState] = session.query(ChargingState).filter(ChargingState.vehicle == vehicle)\
                 .order_by(ChargingState.first_date.desc()).first()
@@ -83,30 +85,36 @@ class ChargingAgent(BaseAgent):
                 .order_by(ChargingPower.first_date.desc()).first()
             self.last_charging_power_lock: threading.RLock = threading.RLock()
 
-            vehicle.carconnectivity_vehicle.charging.connector.connection_state.add_observer(self.__on_connector_state_change, Observable.ObserverEvent.UPDATED)
-            if vehicle.carconnectivity_vehicle.charging.connector.connection_state.enabled:
-                self.__on_connector_state_change(vehicle.carconnectivity_vehicle.charging.connector.connection_state, Observable.ObserverEvent.UPDATED)
+            self.carconnectivity_vehicle.charging.connector.connection_state.add_observer(self.__on_connector_state_change, Observable.ObserverEvent.UPDATED)
+            if self.carconnectivity_vehicle.charging.connector.connection_state.enabled:
+                self.__on_connector_state_change(self.carconnectivity_vehicle.charging.connector.connection_state, Observable.ObserverEvent.UPDATED)
 
-            vehicle.carconnectivity_vehicle.charging.connector.lock_state.add_observer(self.__on_connector_lock_state_change, Observable.ObserverEvent.UPDATED)
-            if vehicle.carconnectivity_vehicle.charging.connector.lock_state.enabled:
-                self.__on_connector_lock_state_change(vehicle.carconnectivity_vehicle.charging.connector.lock_state, Observable.ObserverEvent.UPDATED)
+            self.carconnectivity_vehicle.charging.connector.lock_state.add_observer(self.__on_connector_lock_state_change, Observable.ObserverEvent.UPDATED)
+            if self.carconnectivity_vehicle.charging.connector.lock_state.enabled:
+                self.__on_connector_lock_state_change(self.carconnectivity_vehicle.charging.connector.lock_state, Observable.ObserverEvent.UPDATED)
 
-            vehicle.carconnectivity_vehicle.charging.state.add_observer(self.__on_charging_state_change, Observable.ObserverEvent.UPDATED)
-            if vehicle.carconnectivity_vehicle.charging.state.enabled:
-                self.__on_charging_state_change(vehicle.carconnectivity_vehicle.charging.state, Observable.ObserverEvent.UPDATED)
+            self.carconnectivity_vehicle.charging.state.add_observer(self.__on_charging_state_change, Observable.ObserverEvent.UPDATED)
+            if self.carconnectivity_vehicle.charging.state.enabled:
+                self.__on_charging_state_change(self.carconnectivity_vehicle.charging.state, Observable.ObserverEvent.UPDATED)
 
-            vehicle.carconnectivity_vehicle.charging.rate.add_observer(self.__on_charging_rate_change, Observable.ObserverEvent.UPDATED)
-            if vehicle.carconnectivity_vehicle.charging.rate.enabled:
-                self.__on_charging_rate_change(vehicle.carconnectivity_vehicle.charging.rate, Observable.ObserverEvent.UPDATED)
+            self.carconnectivity_vehicle.charging.rate.add_observer(self.__on_charging_rate_change, Observable.ObserverEvent.UPDATED)
+            if self.carconnectivity_vehicle.charging.rate.enabled:
+                self.__on_charging_rate_change(self.carconnectivity_vehicle.charging.rate, Observable.ObserverEvent.UPDATED)
 
-            vehicle.carconnectivity_vehicle.charging.power.add_observer(self.__on_charging_power_change, Observable.ObserverEvent.UPDATED)
-            if vehicle.carconnectivity_vehicle.charging.power.enabled:
-                self.__on_charging_power_change(vehicle.carconnectivity_vehicle.charging.power, Observable.ObserverEvent.UPDATED)
+            self.carconnectivity_vehicle.charging.power.add_observer(self.__on_charging_power_change, Observable.ObserverEvent.UPDATED)
+            if self.carconnectivity_vehicle.charging.power.enabled:
+                self.__on_charging_power_change(self.carconnectivity_vehicle.charging.power, Observable.ObserverEvent.UPDATED)
+
+            self.carconnectivity_vehicle.charging.type.add_observer(self._on_charging_type_change, Observable.ObserverEvent.VALUE_CHANGED)
+
+            electric_drive: Optional[ElectricDrive] = self.carconnectivity_vehicle.get_electric_drive()
+            if electric_drive is not None:
+                electric_drive.level.add_observer(self._on_battery_level_change, Observable.ObserverEvent.VALUE_CHANGED)
         self.session_factory.remove()
 
     def __on_charging_state_change(self, element: EnumAttribute[Charging.ChargingState], flags: Observable.ObserverEvent) -> None:
         del flags
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
 
         if element.enabled:
@@ -115,8 +123,9 @@ class ChargingAgent(BaseAgent):
                     if self.last_charging_state is not None:
                         self.last_charging_state = session.merge(self.last_charging_state)
                         session.refresh(self.last_charging_state)
-                    if (self.last_charging_state is None or self.last_charging_state.state != element.value) \
-                            and element.last_updated is not None:
+                    if element.last_updated is not None \
+                            and (self.last_charging_state is None or (self.last_charging_state.state != element.value
+                                                                      and element.last_updated > self.last_charging_state.last_date)):
                         new_charging_state: ChargingState = ChargingState(vin=self.vehicle.vin, first_date=element.last_updated,
                                                                           last_date=element.last_updated, state=element.value)
                         try:
@@ -127,6 +136,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while adding charging state for vehicle %s to database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
 
                     elif self.last_charging_state is not None and self.last_charging_state.state == element.value and element.last_updated is not None:
                         if self.last_charging_state.last_date is None or element.last_updated > self.last_charging_state.last_date:
@@ -137,6 +147,7 @@ class ChargingAgent(BaseAgent):
                             except DatabaseError as err:
                                 session.rollback()
                                 LOG.error('DatabaseError while updating charging state for vehicle %s in database: %s', self.vehicle.vin, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
 
                     with self.last_charging_session_lock:
                         if self.last_charging_session is not None:
@@ -161,10 +172,12 @@ class ChargingAgent(BaseAgent):
                                     try:
                                         self.last_charging_session.session_end_date = None
                                         self.last_charging_session.end_level = None
+                                        self._update_session_charging_type(session, self.last_charging_session)
                                         session.commit()
                                     except DatabaseError as err:
                                         session.rollback()
                                         LOG.error('DatabaseError while updating charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                                 else:
                                     LOG.info("Starting new charging session for vehicle %s", self.vehicle.vin)
                                     new_session: ChargingSession = ChargingSession(vin=self.vehicle.vin, session_start_date=element.last_changed)
@@ -179,6 +192,7 @@ class ChargingAgent(BaseAgent):
                                     except DatabaseError as err:
                                         session.rollback()
                                         LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                             else:
                                 if self.last_charging_session.was_started():
                                     LOG.debug("Continuing existing charging session for vehicle %s", self.vehicle.vin)
@@ -193,9 +207,10 @@ class ChargingAgent(BaseAgent):
                                     except DatabaseError as err:
                                         session.rollback()
                                         LOG.error('DatabaseError while starting charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                             # Update startlevel at beginning of charging
-                            if self.last_charging_session is not None and isinstance(self.vehicle.carconnectivity_vehicle, ElectricVehicle):
-                                electric_drive: Optional[ElectricDrive] = self.vehicle.carconnectivity_vehicle.get_electric_drive()
+                            if self.last_charging_session is not None and isinstance(self.carconnectivity_vehicle, ElectricVehicle):
+                                electric_drive: Optional[ElectricDrive] = self.carconnectivity_vehicle.get_electric_drive()
                                 if electric_drive is not None and electric_drive.level.enabled and electric_drive.level.value is not None:
                                     try:
                                         self.last_charging_session.start_level = electric_drive.level.value
@@ -203,6 +218,7 @@ class ChargingAgent(BaseAgent):
                                     except DatabaseError as err:
                                         session.rollback()
                                         LOG.error('DatabaseError while setting start level for vehicle %s in database: %s', self.vehicle.vin, err)
+                                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                         elif element.value not in (Charging.ChargingState.CHARGING, Charging.ChargingState.CONSERVATION) \
                                 and self.carconnectivity_last_charging_state in (Charging.ChargingState.CHARGING, Charging.ChargingState.CONSERVATION):
                             if self.last_charging_session is not None and not self.last_charging_session.was_ended():
@@ -213,8 +229,9 @@ class ChargingAgent(BaseAgent):
                                 except DatabaseError as err:
                                     session.rollback()
                                     LOG.error('DatabaseError while ending charging session for vehicle %s in database: %s', self.vehicle.vin, err)
-                                if isinstance(self.vehicle.carconnectivity_vehicle, ElectricVehicle):
-                                    electric_drive: Optional[ElectricDrive] = self.vehicle.carconnectivity_vehicle.get_electric_drive()
+                                    self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                                if isinstance(self.carconnectivity_vehicle, ElectricVehicle):
+                                    electric_drive: Optional[ElectricDrive] = self.carconnectivity_vehicle.get_electric_drive()
                                     if electric_drive is not None and electric_drive.level.enabled and electric_drive.level.value is not None:
                                         try:
                                             self.last_charging_session.end_level = electric_drive.level.value
@@ -222,12 +239,13 @@ class ChargingAgent(BaseAgent):
                                         except DatabaseError as err:
                                             session.rollback()
                                             LOG.error('DatabaseError while setting start level for vehicle %s in database: %s', self.vehicle.vin, err)
+                                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     self.carconnectivity_last_charging_state = element.value
             self.session_factory.remove()
 
     def __on_charging_rate_change(self, element: SpeedAttribute, flags: Observable.ObserverEvent) -> None:
         del flags
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
         if element.enabled:
             with self.last_charging_rate_lock:
@@ -235,8 +253,9 @@ class ChargingAgent(BaseAgent):
                     if self.last_charging_rate is not None:
                         self.last_charging_rate = session.merge(self.last_charging_rate)
                         session.refresh(self.last_charging_rate)
-                    if (self.last_charging_rate is None or self.last_charging_rate.rate != element.value) \
-                            and element.last_updated is not None:
+                    if element.last_updated is not None \
+                            and (self.last_charging_rate is None or (self.last_charging_rate.rate != element.value
+                                                                     and element.last_updated > self.last_charging_rate.last_date)):
                         new_charging_rate: ChargingRate = ChargingRate(vin=self.vehicle.vin, first_date=element.last_updated,
                                                                        last_date=element.last_updated, rate=element.value)
                         try:
@@ -247,6 +266,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while adding charging rate for vehicle %s to database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     elif self.last_charging_rate is not None and self.last_charging_rate.rate == element.value and element.last_updated is not None:
                         if self.last_charging_rate.last_date is None or element.last_updated > self.last_charging_rate.last_date:
                             try:
@@ -256,11 +276,12 @@ class ChargingAgent(BaseAgent):
                             except DatabaseError as err:
                                 session.rollback()
                                 LOG.error('DatabaseError while updating charging rate for vehicle %s in database: %s', self.vehicle.vin, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 self.session_factory.remove()
 
     def __on_charging_power_change(self, element: PowerAttribute, flags: Observable.ObserverEvent) -> None:
         del flags
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
         if element.enabled:
             with self.last_charging_power_lock:
@@ -268,8 +289,9 @@ class ChargingAgent(BaseAgent):
                     if self.last_charging_power is not None:
                         self.last_charging_power = session.merge(self.last_charging_power)
                         session.refresh(self.last_charging_power)
-                    if (self.last_charging_power is None or self.last_charging_power.power != element.value) \
-                            and element.last_updated is not None:
+                    if element.last_updated is not None \
+                            and (self.last_charging_power is None or (self.last_charging_power.power != element.value
+                                                                      and element.last_updated > self.last_charging_power.last_date)):
                         new_charging_power: ChargingPower = ChargingPower(vin=self.vehicle.vin, first_date=element.last_updated,
                                                                           last_date=element.last_updated, power=element.value)
                         try:
@@ -280,6 +302,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while adding charging power for vehicle %s to database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     elif self.last_charging_power is not None and self.last_charging_power.power == element.value and element.last_updated is not None:
                         if self.last_charging_power.last_date is None or element.last_updated > self.last_charging_power.last_date:
                             try:
@@ -288,11 +311,12 @@ class ChargingAgent(BaseAgent):
                             except DatabaseError as err:
                                 session.rollback()
                                 LOG.error('DatabaseError while updating charging power for vehicle %s in database: %s', self.vehicle.vin, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 self.session_factory.remove()
 
     def __on_connector_state_change(self, element: EnumAttribute[ChargingConnector.ChargingConnectorConnectionState], flags: Observable.ObserverEvent) -> None:
         del flags
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
 
         with self.session_factory() as session:
@@ -302,6 +326,7 @@ class ChargingAgent(BaseAgent):
                     session.refresh(self.last_charging_session)
 
                 if element.value == ChargingConnector.ChargingConnectorConnectionState.CONNECTED \
+                        and self.carconnectivity_last_connector_state is not None \
                         and self.carconnectivity_last_connector_state != ChargingConnector.ChargingConnectorConnectionState.CONNECTED:
                     if self.last_charging_session is None or self.last_charging_session.is_closed():
                         LOG.info("Starting new charging session for vehicle %s  due to connector connected state", self.vehicle.vin)
@@ -316,6 +341,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     elif not self.last_charging_session.was_connected():
                         LOG.debug("Continuing existing charging session for vehicle %s, writing connected date", self.vehicle.vin)
                         try:
@@ -326,6 +352,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while starting charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 elif element.value != ChargingConnector.ChargingConnectorConnectionState.CONNECTED \
                         and self.carconnectivity_last_connector_state == ChargingConnector.ChargingConnectorConnectionState.CONNECTED:
                     if self.last_charging_session is not None and not self.last_charging_session.was_disconnected():
@@ -336,22 +363,29 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while ending charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 # Create charging session when connected at startup
                 elif element.value == ChargingConnector.ChargingConnectorConnectionState.CONNECTED \
                         and self.carconnectivity_last_connector_state == ChargingConnector.ChargingConnectorConnectionState.CONNECTED:
                     if self.last_charging_session is None or self.last_charging_session.is_closed():
-                        LOG.info("Starting new charging session for vehicle %s due to connector connected state", self.vehicle.vin)
-                        new_session: ChargingSession = ChargingSession(vin=self.vehicle.vin, plug_connected_date=element.last_changed)
-                        try:
-                            session.add(new_session)
-                            self._update_session_odometer(session, new_session)
-                            self._update_session_position(session, new_session)
-                            session.commit()
-                            LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
-                            self.last_charging_session = new_session
-                        except DatabaseError as err:
-                            session.rollback()
-                            LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                        # when the incoming connected state was during the last session, this is a continuation
+                        if self.last_charging_session is None or element.last_changed is not None and element.last_changed > \
+                                (self.last_charging_session.session_end_date
+                                 or self.last_charging_session.plug_unlocked_date
+                                 or datetime.min.replace(tzinfo=timezone.utc)):
+                            LOG.info("Starting new charging session for vehicle %s due to connector connected state on startup", self.vehicle.vin)
+                            new_session: ChargingSession = ChargingSession(vin=self.vehicle.vin, plug_connected_date=element.last_changed)
+                            try:
+                                session.add(new_session)
+                                self._update_session_odometer(session, new_session)
+                                self._update_session_position(session, new_session)
+                                session.commit()
+                                LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
+                                self.last_charging_session = new_session
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     elif self.last_charging_session is not None and not self.last_charging_session.was_connected():
                         try:
                             self.last_charging_session.plug_connected_date = element.last_changed
@@ -360,12 +394,13 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while changing charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 self.carconnectivity_last_connector_state = element.value
         self.session_factory.remove()
 
     def __on_connector_lock_state_change(self, element: EnumAttribute[ChargingConnector.ChargingConnectorLockState], flags: Observable.ObserverEvent) -> None:
         del flags
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
 
         with self.session_factory() as session:
@@ -377,18 +412,33 @@ class ChargingAgent(BaseAgent):
                 if element.value == ChargingConnector.ChargingConnectorLockState.LOCKED \
                         and self.carconnectivity_last_connector_lock_state != ChargingConnector.ChargingConnectorLockState.LOCKED:
                     if self.last_charging_session is None or self.last_charging_session.is_closed():
-                        LOG.info("Starting new charging session for vehicle %s due to connector locked state", self.vehicle.vin)
-                        new_session: ChargingSession = ChargingSession(vin=self.vehicle.vin, plug_locked_date=element.last_changed)
-                        try:
-                            session.add(new_session)
-                            self._update_session_odometer(session, new_session)
-                            self._update_session_position(session, new_session)
-                            session.commit()
-                            LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
-                            self.last_charging_session = new_session
-                        except DatabaseError as err:
-                            session.rollback()
-                            LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                        # In case this was an interrupted charging session (interrupt no longer than 24hours), continue by erasing end time
+                        if self.last_charging_session is not None and not self.last_charging_session.was_disconnected() \
+                            and (self.last_charging_session.plug_unlocked_date is None
+                                 or self.last_charging_session.plug_unlocked_date > ((element.last_changed or datetime.now(timezone.utc))
+                                                                                     - timedelta(hours=24))):
+                            LOG.debug("found a closed charging session that was not disconneced. This could be an interrupted session we want to continue")
+                            try:
+                                self.last_charging_session.plug_unlocked_date = None
+                                session.commit()
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while changing charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                        else:
+                            LOG.info("Starting new charging session for vehicle %s due to connector locked state", self.vehicle.vin)
+                            new_session: ChargingSession = ChargingSession(vin=self.vehicle.vin, plug_locked_date=element.last_changed)
+                            try:
+                                session.add(new_session)
+                                self._update_session_odometer(session, new_session)
+                                self._update_session_position(session, new_session)
+                                session.commit()
+                                LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
+                                self.last_charging_session = new_session
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     elif not self.last_charging_session.was_locked():
                         LOG.debug("Continuing existing charging session for vehicle %s, writing locked date", self.vehicle.vin)
                         try:
@@ -399,6 +449,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while starting charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 elif element.value != ChargingConnector.ChargingConnectorLockState.LOCKED \
                         and self.carconnectivity_last_connector_lock_state == ChargingConnector.ChargingConnectorLockState.LOCKED:
                     if self.last_charging_session is not None and not self.last_charging_session.was_unlocked():
@@ -409,6 +460,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while ending charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 # Create charging session when locked at startup
                 elif element.value == ChargingConnector.ChargingConnectorLockState.LOCKED \
                         and self.carconnectivity_last_connector_lock_state == ChargingConnector.ChargingConnectorLockState.LOCKED:
@@ -425,6 +477,7 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     elif self.last_charging_session is not None and not self.last_charging_session.was_locked():
                         try:
                             self.last_charging_session.plug_locked_date = element.last_changed
@@ -433,62 +486,110 @@ class ChargingAgent(BaseAgent):
                         except DatabaseError as err:
                             session.rollback()
                             LOG.error('DatabaseError while changing charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 self.carconnectivity_last_connector_lock_state = element.value
         self.session_factory.remove()
 
     def _update_session_odometer(self, session: Session, charging_session: ChargingSession) -> None:
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
-        if self.vehicle.carconnectivity_vehicle.odometer.enabled:
+        if self.carconnectivity_vehicle.odometer.enabled:
             if charging_session.session_odometer is None:
                 try:
-                    charging_session.session_odometer = self.vehicle.carconnectivity_vehicle.odometer.value
+                    charging_session.session_odometer = self.carconnectivity_vehicle.odometer.value
                 except DatabaseError as err:
                     session.rollback()
                     LOG.error('DatabaseError while updating odometer for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
+                    self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
 
     def _update_session_charging_type(self, session: Session, charging_session: ChargingSession) -> None:
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
-        if isinstance(self.vehicle.carconnectivity_vehicle, ElectricVehicle) and self.vehicle.carconnectivity_vehicle.charging.type.enabled \
-                and self.vehicle.carconnectivity_vehicle.charging.type.value is not None:
+        if isinstance(self.carconnectivity_vehicle, ElectricVehicle) and self.carconnectivity_vehicle.charging.type.enabled \
+                and self.carconnectivity_vehicle.charging.type.value is not None:
             if charging_session.charging_type is None:
                 try:
-                    charging_session.charging_type = self.vehicle.carconnectivity_vehicle.charging.type.value
+                    charging_session.charging_type = self.carconnectivity_vehicle.charging.type.value
                 except DatabaseError as err:
                     session.rollback()
                     LOG.error('DatabaseError while updating charging type for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
+                    self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
 
     def _update_session_position(self, session: Session, charging_session: ChargingSession) -> None:
-        if self.vehicle.carconnectivity_vehicle is None:
+        if self.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
-        if self.vehicle.carconnectivity_vehicle.position.enabled and self.vehicle.carconnectivity_vehicle.position.latitude.enabled \
-                and self.vehicle.carconnectivity_vehicle.position.longitude.enabled \
-                and self.vehicle.carconnectivity_vehicle.position.latitude.value is not None \
-                and self.vehicle.carconnectivity_vehicle.position.longitude.value is not None:
+        if self.carconnectivity_vehicle.position.enabled and self.carconnectivity_vehicle.position.latitude.enabled \
+                and self.carconnectivity_vehicle.position.longitude.enabled \
+                and self.carconnectivity_vehicle.position.latitude.value is not None \
+                and self.carconnectivity_vehicle.position.longitude.value is not None:
             if charging_session.session_position_latitude is None and charging_session.session_position_longitude is None:
                 try:
-                    charging_session.session_position_latitude = self.vehicle.carconnectivity_vehicle.position.latitude.value
-                    charging_session.session_position_longitude = self.vehicle.carconnectivity_vehicle.position.longitude.value
+                    charging_session.session_position_latitude = self.carconnectivity_vehicle.position.latitude.value
+                    charging_session.session_position_longitude = self.carconnectivity_vehicle.position.longitude.value
                 except DatabaseError as err:
                     session.rollback()
                     LOG.error('DatabaseError while updating position for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
-            if charging_session.location is None and self.vehicle.carconnectivity_vehicle.position.location.enabled:
-                location: Location = Location.from_carconnectivity_location(location=self.vehicle.carconnectivity_vehicle.position.location)
+                    self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            if charging_session.location is None and self.carconnectivity_vehicle.position.location.enabled:
+                location: Location = Location.from_carconnectivity_location(location=self.carconnectivity_vehicle.position.location)
                 try:
                     location = session.merge(location)
                     charging_session.location = location
                 except DatabaseError as err:
                     session.rollback()
                     LOG.error('DatabaseError while merging location for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
+                    self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
         if charging_session.charging_station is None \
-                and isinstance(self.vehicle.carconnectivity_vehicle, ElectricVehicle) and self.vehicle.carconnectivity_vehicle.charging is not None \
-                and self.vehicle.carconnectivity_vehicle.charging.enabled and self.vehicle.carconnectivity_vehicle.charging.charging_station.enabled:
+                and isinstance(self.carconnectivity_vehicle, ElectricVehicle) and self.carconnectivity_vehicle.charging is not None \
+                and self.carconnectivity_vehicle.charging.enabled and self.carconnectivity_vehicle.charging.charging_station.enabled:
             charging_station: ChargingStation = ChargingStation.from_carconnectivity_charging_station(
-                charging_station=self.vehicle.carconnectivity_vehicle.charging.charging_station)
+                charging_station=self.carconnectivity_vehicle.charging.charging_station)
             try:
                 charging_station = session.merge(charging_station)
                 charging_session.charging_station = charging_station
             except DatabaseError as err:
                 session.rollback()
                 LOG.error('DatabaseError while merging charging station for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
+                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+
+    def _on_charging_type_change(self, element: EnumAttribute[Charging.ChargingType], flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.session_factory() as session:
+                with self.last_charging_session_lock:
+                    if self.last_charging_session is not None:
+                        self.last_charging_session = session.merge(self.last_charging_session)
+                        session.refresh(self.last_charging_session)
+                    if self.last_charging_session is not None and not self.last_charging_session.is_closed() \
+                            and element.value in [Charging.ChargingType.AC, Charging.ChargingType.DC]:
+                        try:
+                            self.last_charging_session.charging_type = element.value
+                            session.commit()
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while updating type of charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            self.session_factory.remove()
+
+    def _on_battery_level_change(self, element: FloatAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled and element.value is not None:
+            # We try to see if there was a late battery level update for a finished session
+            with self.session_factory() as session:
+                with self.last_charging_session_lock:
+                    if self.last_charging_session is not None:
+                        self.last_charging_session = session.merge(self.last_charging_session)
+                        session.refresh(self.last_charging_session)
+                    if self.last_charging_session is not None and self.last_charging_session.session_end_date is not None:
+                        if element.last_updated is not None and (element.last_updated <= (self.last_charging_session.session_end_date + timedelta(minutes=1))):
+                            # Only update if we have no end level yet or the new level is higher than the previous one (this happens with late level updates)
+                            if self.last_charging_session.end_level is None or self.last_charging_session.end_level < element.value:
+                                try:
+                                    self.last_charging_session.end_level = element.value
+                                    session.commit()
+                                except DatabaseError as err:
+                                    session.rollback()
+                                    LOG.error('DatabaseError while updating battery level of charging session for vehicle %s in database: %s',
+                                              self.vehicle.vin, err)
+                                    self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            self.session_factory.remove()