carconnectivity-plugin-database 0.1a19__py3-none-any.whl

carconnectivity_plugins/database/agents/drive_state_agent.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import threading
+
+import logging
+
+from sqlalchemy.exc import DatabaseError
+
+from carconnectivity.observable import Observable
+from carconnectivity.drive import GenericDrive, ElectricDrive, CombustionDrive
+
+from carconnectivity_plugins.database.agents.base_agent import BaseAgent
+from carconnectivity_plugins.database.model.drive_level import DriveLevel
+from carconnectivity_plugins.database.model.drive_range import DriveRange
+from carconnectivity_plugins.database.model.drive_consumption import DriveConsumption
+from carconnectivity_plugins.database.model.drive_range_full import DriveRangeEstimatedFull
+
+if TYPE_CHECKING:
+    from typing import Optional
+    from sqlalchemy.orm import scoped_session
+    from sqlalchemy.orm.session import Session
+
+    from carconnectivity.attributes import LevelAttribute, RangeAttribute, EnumAttribute, EnergyAttribute, VolumeAttribute, EnergyConsumptionAttribute, \
+        FuelConsumptionAttribute
+
+    from carconnectivity_plugins.database.plugin import Plugin
+    from carconnectivity_plugins.database.model.drive import Drive
+
+
+LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents.drive_state_agent")
+
+
+class DriveStateAgent(BaseAgent):
+    def __init__(self, database_plugin: Plugin, session_factory: scoped_session[Session], drive: Drive) -> None:
+        self.database_plugin: Plugin = database_plugin
+        self.session_factory: scoped_session[Session] = session_factory
+        self.drive: Drive = drive
+        if self.drive is None or self.drive.carconnectivity_drive is None:
+            raise ValueError("Drive or its carconnectivity_drive attribute is None")
+
+        self.drive.carconnectivity_drive.type.add_observer(self.__on_type_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+        self.type_lock: threading.RLock = threading.RLock()
+        self.__on_type_change(self.drive.carconnectivity_drive.type, Observable.ObserverEvent.VALUE_CHANGED)
+
+        self.drive.carconnectivity_drive.range_wltp.add_observer(self.__on_range_wltp_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+        self.range_wltp_lock: threading.RLock = threading.RLock()
+        self.__on_range_wltp_change(self.drive.carconnectivity_drive.range_wltp, Observable.ObserverEvent.VALUE_CHANGED)
+
+        with self.session_factory() as session:
+            self.drive = session.merge(self.drive)
+            session.refresh(self.drive)
+
+            if isinstance(self.drive.carconnectivity_drive, ElectricDrive):
+                self.drive.carconnectivity_drive.battery.total_capacity.add_observer(self.__on_electric_total_capacity_change,
+                                                                                     Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+                self.total_capacity_lock: threading.RLock = threading.RLock()
+                self.__on_electric_total_capacity_change(self.drive.carconnectivity_drive.battery.total_capacity, Observable.ObserverEvent.VALUE_CHANGED)
+
+                self.drive.carconnectivity_drive.battery.available_capacity.add_observer(self.__on_electric_available_capacity_change,
+                                                                                         Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+                self.available_capacity_lock: threading.RLock = threading.RLock()
+                self.__on_electric_available_capacity_change(self.drive.carconnectivity_drive.battery.available_capacity,
+                                                             Observable.ObserverEvent.VALUE_CHANGED)
+
+                self.last_electric_consumption: Optional[DriveConsumption] = session.query(DriveConsumption) \
+                    .filter(DriveConsumption.drive_id == self.drive.id).order_by(DriveConsumption.first_date.desc()).first()
+                self.last_electric_consumption_lock: threading.RLock = threading.RLock()
+                self.drive.carconnectivity_drive.consumption.add_observer(self.__on_electric_consumption_change,
+                                                                          Observable.ObserverEvent.VALUE_CHANGED)
+                self.__on_electric_consumption_change(self.drive.carconnectivity_drive.consumption, Observable.ObserverEvent.UPDATED)
+
+            elif isinstance(self.drive.carconnectivity_drive, CombustionDrive):
+                self.drive.carconnectivity_drive.fuel_tank.available_capacity.add_observer(self.__on_fuel_available_capacity_change,
+                                                                                           Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+                self.fuel_available_capacity_lock: threading.RLock = threading.RLock()
+                self.__on_fuel_available_capacity_change(self.drive.carconnectivity_drive.fuel_tank.available_capacity, Observable.ObserverEvent.VALUE_CHANGED)
+
+                self.last_fuel_consumption: Optional[DriveConsumption] = session.query(DriveConsumption).filter(DriveConsumption.drive_id == self.drive.id) \
+                    .order_by(DriveConsumption.first_date.desc()).first()
+                self.last_fuel_consumption_lock: threading.RLock = threading.RLock()
+                self.drive.carconnectivity_drive.consumption.add_observer(self.__on_fuel_consumption_change,
+                                                                          Observable.ObserverEvent.VALUE_CHANGED)
+                self.__on_fuel_consumption_change(self.drive.carconnectivity_drive.consumption, Observable.ObserverEvent.UPDATED)
+
+            self.last_level: Optional[DriveLevel] = session.query(DriveLevel).filter(DriveLevel.drive_id == self.drive.id) \
+                .order_by(DriveLevel.first_date.desc()).first()
+            self.last_level_lock: threading.RLock = threading.RLock()
+            self.last_range: Optional[DriveRange] = session.query(DriveRange).filter(DriveRange.drive_id == self.drive.id) \
+                .order_by(DriveRange.first_date.desc()).first()
+            self.last_range_lock: threading.RLock = threading.RLock()
+            self.last_range_estimated_full: Optional[DriveRangeEstimatedFull] = session.query(DriveRangeEstimatedFull) \
+                .filter(DriveRangeEstimatedFull.drive_id == self.drive.id).order_by(DriveRangeEstimatedFull.first_date.desc()).first()
+            self.last_range_estimated_full_lock: threading.RLock = threading.RLock()
+
+            if self.drive.carconnectivity_drive is not None:
+                self.drive.carconnectivity_drive.level.add_observer(self.__on_level_change, Observable.ObserverEvent.UPDATED)
+                if self.drive.carconnectivity_drive.level.enabled:
+                    self.__on_level_change(self.drive.carconnectivity_drive.level, Observable.ObserverEvent.UPDATED)
+
+                self.drive.carconnectivity_drive.range.add_observer(self.__on_range_change, Observable.ObserverEvent.UPDATED)
+                if self.drive.carconnectivity_drive.range.enabled:
+                    self.__on_range_change(self.drive.carconnectivity_drive.range, Observable.ObserverEvent.UPDATED)
+
+                self.drive.carconnectivity_drive.range_estimated_full.add_observer(self.__on_range_estimated_full_change, Observable.ObserverEvent.UPDATED)
+                if self.drive.carconnectivity_drive.range_estimated_full.enabled:
+                    self.__on_range_estimated_full_change(self.drive.carconnectivity_drive.range_estimated_full, Observable.ObserverEvent.UPDATED)
+        session_factory.remove()
+
+    def __on_level_change(self, element: LevelAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_level_lock:
+                with self.session_factory() as session:
+                    self.drive = session.merge(self.drive)
+                    session.refresh(self.drive)
+                    if self.last_level is not None:
+                        self.last_level = session.merge(self.last_level)
+                        session.refresh(self.last_level)
+                    if (self.last_level is None or self.last_level.level != element.value) \
+                            and element.last_updated is not None:
+                        new_level: DriveLevel = DriveLevel(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
+                                                           level=element.value)
+                        try:
+                            session.add(new_level)
+                            session.commit()
+                            LOG.debug('Added new level %s for drive %s to database', element.value, self.drive.id)
+                            self.last_level = new_level
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding level for drive %s to database: %s', self.drive.id, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                    elif self.last_level is not None and self.last_level.level == element.value \
+                            and element.last_updated is not None:
+                        if self.last_level.last_date is None or element.last_updated > self.last_level.last_date:
+                            try:
+                                self.last_level.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated level %s for drive %s in database', element.value, self.drive.id)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating level for drive %s in database: %s', self.drive.id, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                self.session_factory.remove()
+
+    def __on_range_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_range_lock:
+                with self.session_factory() as session:
+                    self.drive = session.merge(self.drive)
+                    session.refresh(self.drive)
+                    if self.last_range is not None:
+                        self.last_range = session.merge(self.last_range)
+                        session.refresh(self.last_range)
+                    if (self.last_range is None or self.last_range.range != element.value) \
+                            and element.last_updated is not None:
+                        new_range: DriveRange = DriveRange(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
+                                                           range=element.value)
+                        try:
+                            session.add(new_range)
+                            session.commit()
+                            LOG.debug('Added new range %s for drive %s to database', element.value, self.drive.id)
+                            self.last_range = new_range
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding range for drive %s to database: %s', self.drive.id, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                    elif self.last_range is not None and self.last_range.range == element.value \
+                            and element.last_updated is not None:
+                        if self.last_range.last_date is None or element.last_updated > self.last_range.last_date:
+                            try:
+                                self.last_range.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated range %s for drive %s in database', element.value, self.drive.id)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating range for drive %s in database: %s', self.drive.id, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                self.session_factory.remove()
+
+    def __on_range_estimated_full_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_range_estimated_full_lock:
+                with self.session_factory() as session:
+                    self.drive = session.merge(self.drive)
+                    session.refresh(self.drive)
+                    if self.last_range_estimated_full is not None:
+                        self.last_range_estimated_full = session.merge(self.last_range_estimated_full)
+                        session.refresh(self.last_range_estimated_full)
+                    if (self.last_range_estimated_full is None or self.last_range_estimated_full.range_estimated_full != element.value) \
+                            and element.last_updated is not None:
+                        new_range: DriveRangeEstimatedFull = DriveRangeEstimatedFull(drive_id=self.drive.id, first_date=element.last_updated,
+                                                                                     last_date=element.last_updated, range_estimated_full=element.value)
+                        try:
+                            session.add(new_range)
+                            session.commit()
+                            LOG.debug('Added new range_estimated_full %s for drive %s to database', element.value, self.drive.id)
+                            self.last_range_estimated_full = new_range
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding range_estimated_full for drive %s to database: %s', self.drive.id, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                    elif self.last_range_estimated_full is not None and self.last_range_estimated_full.range_estimated_full == element.value \
+                            and element.last_updated is not None:
+                        if self.last_range_estimated_full.last_date is None or element.last_updated > self.last_range_estimated_full.last_date:
+                            try:
+                                self.last_range_estimated_full.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated range_estimated_full %s for drive %s in database', element.value, self.drive.id)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating range_estimated_full for drive %s in database: %s', self.drive.id, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                self.session_factory.remove()
+
+    def __on_type_change(self, element: EnumAttribute[GenericDrive.Type], flags: Observable.ObserverEvent) -> None:
+        del flags
+        with self.type_lock:
+            with self.session_factory() as session:
+                self.drive = session.merge(self.drive)
+                session.refresh(self.drive)
+                if element.enabled and element.value is not None and self.drive.type != element.value:
+                    try:
+                        self.drive.type = element.value
+                        session.commit()
+                    except DatabaseError as err:
+                        session.rollback()
+                        LOG.error('DatabaseError while updating type for drive %s to database: %s', self.drive.id, err)
+                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            self.session_factory.remove()
+
+    def __on_electric_total_capacity_change(self, element: EnergyAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        with self.total_capacity_lock:
+            with self.session_factory() as session:
+                self.drive = session.merge(self.drive)
+                session.refresh(self.drive)
+                if element.enabled and element.value is not None and self.drive.capacity_total != element.value:
+                    try:
+                        self.drive.capacity_total = element.value
+                        session.commit()
+                    except DatabaseError as err:
+                        session.rollback()
+                        LOG.error('DatabaseError while updating total capacity for drive %s to database: %s', self.drive.id, err)
+                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            self.session_factory.remove()
+
+    def __on_electric_available_capacity_change(self, element: EnergyAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        with self.available_capacity_lock:
+            with self.session_factory() as session:
+                self.drive = session.merge(self.drive)
+                session.refresh(self.drive)
+                if element.enabled and element.value is not None and self.drive.capacity != element.value:
+                    try:
+                        self.drive.capacity = element.value
+                        session.commit()
+                    except DatabaseError as err:
+                        session.rollback()
+                        LOG.error('DatabaseError while updating available capacity for drive %s to database: %s', self.drive.id, err)
+                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            self.session_factory.remove()
+
+    def __on_range_wltp_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        with self.range_wltp_lock:
+            with self.session_factory() as session:
+                self.drive = session.merge(self.drive)
+                session.refresh(self.drive)
+                if element.enabled and element.value is not None and self.drive.wltp_range != element.value:
+                    try:
+                        self.drive.wltp_range = element.value
+                        session.commit()
+                    except DatabaseError as err:
+                        session.rollback()
+                        LOG.error('DatabaseError while updating WLTP range for drive %s to database: %s', self.drive.id, err)
+                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            self.session_factory.remove()
+
+    def __on_fuel_available_capacity_change(self, element: VolumeAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        with self.fuel_available_capacity_lock:
+            with self.session_factory() as session:
+                self.drive = session.merge(self.drive)
+                session.refresh(self.drive)
+                if element.enabled and element.value is not None and self.drive.capacity != element.value:
+                    try:
+                        self.drive.capacity = element.value
+                        session.commit()
+                    except DatabaseError as err:
+                        session.rollback()
+                        LOG.error('DatabaseError while updating available capacity for drive %s to database: %s', self.drive.id, err)
+                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+            self.session_factory.remove()
+
+    def __on_electric_consumption_change(self, element: EnergyConsumptionAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_electric_consumption_lock:
+                with self.session_factory() as session:
+                    self.drive = session.merge(self.drive)
+                    session.refresh(self.drive)
+                    if self.last_electric_consumption is not None:
+                        self.last_electric_consumption = session.merge(self.last_electric_consumption)
+                        session.refresh(self.last_electric_consumption)
+                    if (self.last_electric_consumption is None or self.last_electric_consumption.consumption != element.value) \
+                            and element.last_updated is not None:
+                        new_level: DriveConsumption = DriveConsumption(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
+                                                                       consumption=element.value)
+                        try:
+                            session.add(new_level)
+                            session.commit()
+                            LOG.debug('Added new consumption %s for drive %s to database', element.value, self.drive.id)
+                            self.last_electric_consumption = new_level
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding consumption for drive %s to database: %s', self.drive.id, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                    elif self.last_electric_consumption is not None and self.last_electric_consumption.consumption == element.value \
+                            and element.last_updated is not None:
+                        if self.last_electric_consumption.last_date is None or element.last_updated > self.last_electric_consumption.last_date:
+                            try:
+                                self.last_electric_consumption.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated consumption %s for drive %s in database', element.value, self.drive.id)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating consumption for drive %s in database: %s', self.drive.id, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                self.session_factory.remove()
+
+    def __on_fuel_consumption_change(self, element: FuelConsumptionAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_fuel_consumption_lock:
+                with self.session_factory() as session:
+                    self.drive = session.merge(self.drive)
+                    session.refresh(self.drive)
+                    if self.last_fuel_consumption is not None:
+                        self.last_fuel_consumption = session.merge(self.last_fuel_consumption)
+                        session.refresh(self.last_fuel_consumption)
+                    if (self.last_fuel_consumption is None or self.last_fuel_consumption.consumption != element.value) \
+                            and element.last_updated is not None:
+                        new_level: DriveConsumption = DriveConsumption(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
+                                                                       consumption=element.value)
+                        try:
+                            session.add(new_level)
+                            session.commit()
+                            LOG.debug('Added new consumption %s for drive %s to database', element.value, self.drive.id)
+                            self.last_fuel_consumption = new_level
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding consumption for drive %s to database: %s', self.drive.id, err)
+                            self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                    elif self.last_fuel_consumption is not None and self.last_fuel_consumption.consumption == element.value \
+                            and element.last_updated is not None:
+                        if self.last_fuel_consumption.last_date is None or element.last_updated > self.last_fuel_consumption.last_date:
+                            try:
+                                self.last_fuel_consumption.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated consumption %s for drive %s in database', element.value, self.drive.id)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating consumption for drive %s in database: %s', self.drive.id, err)
+                                self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
+                self.session_factory.remove()

carconnectivity_plugins/database/agents/state_agent.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import threading
+
+import logging
+
+from sqlalchemy.exc import DatabaseError
+
+from carconnectivity.observable import Observable
+
+from carconnectivity_plugins.database.agents.base_agent import BaseAgent
+from carconnectivity_plugins.database.model.state import State
+from carconnectivity_plugins.database.model.connection_state import ConnectionState
+from carconnectivity_plugins.database.model.outside_temperature import OutsideTemperature
+
+if TYPE_CHECKING:
+    from typing import Optional
+    from sqlalchemy.orm import scoped_session
+    from sqlalchemy.orm.session import Session
+
+    from carconnectivity.attributes import EnumAttribute, TemperatureAttribute
+
+    from carconnectivity.vehicle import GenericVehicle
+
+    from carconnectivity_plugins.database.plugin import Plugin
+    from carconnectivity_plugins.database.model.vehicle import Vehicle
+
+
+LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents.state_agent")
+
+
+class StateAgent(BaseAgent):
+    def __init__(self, database_plugin: Plugin, session_factory: scoped_session[Session], vehicle: Vehicle) -> None:
+        if vehicle is None or vehicle.carconnectivity_vehicle is None:
+            raise ValueError("Vehicle or its carconnectivity_vehicle attribute is None")
+        self.database_plugin: Plugin = database_plugin
+        self.session_factory: scoped_session[Session] = session_factory
+        self.vehicle: Vehicle = vehicle
+
+        with self.session_factory() as session:
+            self.last_state: Optional[State] = session.query(State).filter(State.vehicle == vehicle).order_by(State.first_date.desc()).first()
+            self.last_state_lock: threading.RLock = threading.RLock()
+
+            self.last_connection_state: Optional[ConnectionState] = session.query(ConnectionState).filter(ConnectionState.vehicle == vehicle) \
+                .order_by(ConnectionState.first_date.desc()).first()
+            self.last_connection_state_lock: threading.RLock = threading.RLock()
+
+            self.last_outside_temperature: Optional[OutsideTemperature] = session.query(OutsideTemperature).filter(OutsideTemperature.vehicle == vehicle) \
+                .order_by(OutsideTemperature.first_date.desc()).first()
+            self.last_outside_temperature_lock: threading.RLock = threading.RLock()
+
+            vehicle.carconnectivity_vehicle.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
+            self.__on_state_change(vehicle.carconnectivity_vehicle.state, Observable.ObserverEvent.UPDATED)
+
+            vehicle.carconnectivity_vehicle.connection_state.add_observer(self.__on_connection_state_change, Observable.ObserverEvent.UPDATED)
+            self.__on_connection_state_change(vehicle.carconnectivity_vehicle.connection_state, Observable.ObserverEvent.UPDATED)
+
+            vehicle.carconnectivity_vehicle.outside_temperature.add_observer(self.__on_outside_temperature_change, Observable.ObserverEvent.UPDATED)
+            self.__on_outside_temperature_change(vehicle.carconnectivity_vehicle.outside_temperature, Observable.ObserverEvent.UPDATED)
+        self.session_factory.remove()
+
+    def __on_state_change(self, element: EnumAttribute[GenericVehicle.State], flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_state_lock:
+                with self.session_factory() as session:
+                    if self.last_state is not None:
+                        self.last_state = session.merge(self.last_state)
+                        session.refresh(self.last_state)
+                    if (self.last_state is None or self.last_state.state != element.value) \
+                            and element.last_updated is not None:
+                        new_state: State = State(vin=self.vehicle.vin, first_date=element.last_updated, last_date=element.last_updated, state=element.value)
+                        try:
+                            session.add(new_state)
+                            session.commit()
+                            LOG.debug('Added new state %s for vehicle %s to database', element.value, self.vehicle.vin)
+                            self.last_state = new_state
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding 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_state is not None and self.last_state.state == element.value and element.last_updated is not None:
+                        if self.last_state.last_date is None or element.last_updated > self.last_state.last_date:
+                            try:
+                                self.last_state.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated state %s for vehicle %s in database', element.value, self.vehicle.vin)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating state 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_connection_state_change(self, element: EnumAttribute[GenericVehicle.ConnectionState], flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_connection_state_lock:
+                with self.session_factory() as session:
+                    if self.last_connection_state is not None:
+                        self.last_connection_state = session.merge(self.last_connection_state)
+                        session.refresh(self.last_connection_state)
+                    if (self.last_connection_state is None or self.last_connection_state.connection_state != element.value) \
+                            and element.last_updated is not None:
+                        new_connection_state: ConnectionState = ConnectionState(vin=self.vehicle.vin, first_date=element.last_updated,
+                                                                                last_date=element.last_updated, connection_state=element.value)
+                        try:
+                            session.add(new_connection_state)
+                            session.commit()
+                            LOG.debug('Added new connection state %s for vehicle %s to database', element.value, self.vehicle.vin)
+                            self.last_connection_state = new_connection_state
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding connection 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_connection_state is not None and self.last_connection_state.connection_state == element.value \
+                            and element.last_updated is not None:
+                        if self.last_connection_state.last_date is None or element.last_updated > self.last_connection_state.last_date:
+                            try:
+                                self.last_connection_state.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated connection state %s for vehicle %s in database', element.value, self.vehicle.vin)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating connection state 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_outside_temperature_change(self, element: TemperatureAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            with self.last_outside_temperature_lock:
+                with self.session_factory() as session:
+                    if self.last_outside_temperature is not None:
+                        self.last_outside_temperature = session.merge(self.last_outside_temperature)
+                        session.refresh(self.last_outside_temperature)
+                    if (self.last_outside_temperature is None or self.last_outside_temperature.outside_temperature != element.value) \
+                            and element.last_updated is not None:
+                        new_outside_temperature: OutsideTemperature = OutsideTemperature(vin=self.vehicle.vin, first_date=element.last_updated,
+                                                                                         last_date=element.last_updated, outside_temperature=element.value)
+                        try:
+                            session.add(new_outside_temperature)
+                            session.commit()
+                            LOG.debug('Added new outside temperature %.2f for vehicle %s to database', element.value, self.vehicle.vin)
+                            self.last_outside_temperature = new_outside_temperature
+                        except DatabaseError as err:
+                            session.rollback()
+                            LOG.error('DatabaseError while adding outside temperature 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_outside_temperature is not None and self.last_outside_temperature.outside_temperature == element.value \
+                            and element.last_updated is not None:
+                        if self.last_outside_temperature.last_date is None or element.last_updated > self.last_outside_temperature.last_date:
+                            try:
+                                self.last_outside_temperature.last_date = element.last_updated
+                                session.commit()
+                                LOG.debug('Updated outside temperature %.2f for vehicle %s in database', element.value, self.vehicle.vin)
+                            except DatabaseError as err:
+                                session.rollback()
+                                LOG.error('DatabaseError while updating outside temperature 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()