carconnectivity-plugin-database 0.1a11__tar.gz → 0.1a14__tar.gz

{carconnectivity_plugin_database-0.1a11/src/carconnectivity_plugin_database.egg-info → carconnectivity_plugin_database-0.1a14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carconnectivity-plugin-database
-Version: 0.1a11
+Version: 0.1a14
 Summary: CarConnectivity plugin for storing data to Databases
 Author: Till Steinbach
 License-Expression: MIT
@@ -19,7 +19,7 @@ Classifier: Topic :: Home Automation
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity>=0.9.2
+Requires-Dist: carconnectivity>=0.10
 Requires-Dist: sqlalchemy~=2.0.45
 Requires-Dist: psycopg2-binary~=2.9.11
 Requires-Dist: alembic~=1.17.2

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/pyproject.toml

@@ -14,7 +14,7 @@ authors = [
     { name = "Till Steinbach" }
 ]
 dependencies = [
-    "carconnectivity>=0.9.2",
+    "carconnectivity>=0.10",
     "sqlalchemy~=2.0.45",
     "psycopg2-binary~=2.9.11",
     "alembic~=1.17.2",

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14/src/carconnectivity_plugin_database.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: carconnectivity-plugin-database
-Version: 0.1a11
+Version: 0.1a14
 Summary: CarConnectivity plugin for storing data to Databases
 Author: Till Steinbach
 License-Expression: MIT
@@ -19,7 +19,7 @@ Classifier: Topic :: Home Automation
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: carconnectivity>=0.9.2
+Requires-Dist: carconnectivity>=0.10
 Requires-Dist: sqlalchemy~=2.0.45
 Requires-Dist: psycopg2-binary~=2.9.11
 Requires-Dist: alembic~=1.17.2

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugin_database.egg-info/SOURCES.txt

@@ -36,12 +36,15 @@ src/carconnectivity_plugins/database/model/charging_power.py
 src/carconnectivity_plugins/database/model/charging_rate.py
 src/carconnectivity_plugins/database/model/charging_session.py
 src/carconnectivity_plugins/database/model/charging_state.py
+src/carconnectivity_plugins/database/model/charging_station.py
 src/carconnectivity_plugins/database/model/climatization_state.py
 src/carconnectivity_plugins/database/model/connection_state.py
 src/carconnectivity_plugins/database/model/datetime_decorator.py
 src/carconnectivity_plugins/database/model/drive.py
 src/carconnectivity_plugins/database/model/drive_level.py
 src/carconnectivity_plugins/database/model/drive_range.py
+src/carconnectivity_plugins/database/model/drive_range_full.py
+src/carconnectivity_plugins/database/model/location.py
 src/carconnectivity_plugins/database/model/migrations.py
 src/carconnectivity_plugins/database/model/outside_temperature.py
 src/carconnectivity_plugins/database/model/state.py

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugin_database.egg-info/requires.txt

@@ -1,4 +1,4 @@
-carconnectivity>=0.9.2
+carconnectivity>=0.10
 sqlalchemy~=2.0.45
 psycopg2-binary~=2.9.11
 alembic~=1.17.2

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1a11'
-__version_tuple__ = version_tuple = (0, 1, 'a11')
+__version__ = version = '0.1a14'
+__version_tuple__ = version_tuple = (0, 1, 'a14')
 
-__commit_id__ = commit_id = 'gf46ffbb8b'
+__commit_id__ = commit_id = 'g0e0346a6f'

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/agents/charging_agent.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import logging
+from datetime import timedelta
 
-from sqlalchemy import and_
 from sqlalchemy.exc import DatabaseError
 
 from carconnectivity.observable import Observable
@@ -17,6 +17,8 @@ from carconnectivity_plugins.database.model.charging_state import ChargingState
 from carconnectivity_plugins.database.model.charging_rate import ChargingRate
 from carconnectivity_plugins.database.model.charging_power import ChargingPower
 from carconnectivity_plugins.database.model.charging_session import ChargingSession
+from carconnectivity_plugins.database.model.location import Location
+from carconnectivity_plugins.database.model.charging_station import ChargingStation
 
 if TYPE_CHECKING:
     from typing import Optional
@@ -40,8 +42,7 @@ class ChargingAgent(BaseAgent):
         self.session: Session = session
         self.vehicle: Vehicle = vehicle
 
-        self.last_charging_session: Optional[ChargingSession] = session.query(ChargingSession).filter(and_(ChargingSession.vehicle == vehicle,
-                                                                                                      ChargingSession.session_start_date.is_not(None))) \
+        self.last_charging_session: Optional[ChargingSession] = session.query(ChargingSession).filter(ChargingSession.vehicle == vehicle) \
             .order_by(ChargingSession.session_start_date.desc()).first()
         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\
@@ -49,7 +50,12 @@ class ChargingAgent(BaseAgent):
         self.carconnectivity_last_connector_lock_state: Optional[ChargingConnector.ChargingConnectorLockState] = vehicle.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):
+            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 ==
+                    ChargingConnector.ChargingConnectorConnectionState.CONNECTED) \
+                or (vehicle.carconnectivity_vehicle.charging.connector.lock_state.enabled
+                    and vehicle.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)
@@ -118,24 +124,47 @@ class ChargingAgent(BaseAgent):
         if element.value in (Charging.ChargingState.CHARGING, Charging.ChargingState.CONSERVATION) \
                 and self.carconnectivity_last_charging_state not in (Charging.ChargingState.CHARGING, Charging.ChargingState.CONSERVATION):
             if self.last_charging_session is None or self.last_charging_session.is_closed():
-                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_updated)
-                try:
-                    self.session.add(new_session)
-                    LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
-                    self._update_session_odometer(new_session)
-                    self.last_charging_session = new_session
-                except DatabaseError as err:
-                    self.session.rollback()
-                    LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+                # check that we are not resuming an old session
+                allowed_interrupt: timedelta = timedelta(hours=24)
+                # we allow longer CONSERVATION within the session
+                if element.value == Charging.ChargingState.CONSERVATION:
+                    allowed_interrupt = timedelta(hours=300)
+                # We can reuse the session if the vehicle was connected and not disconnected in the meantime
+                # And the session end date was not set or is within the allowed interrupt time
+                if self.last_charging_session is not None \
+                        and self.last_charging_session.was_connected() and not self.last_charging_session.was_disconnected() \
+                        and (self.last_charging_session.session_end_date is None or element.last_changed is None
+                             or self.last_charging_session.session_end_date > (element.last_changed - allowed_interrupt)):
+                    LOG.debug("Continuing existing charging session for vehicle %s", self.vehicle.vin)
+                    try:
+                        self.last_charging_session.session_end_date = None
+                        self.last_charging_session.end_level = None
+                    except DatabaseError as err:
+                        self.session.rollback()
+                        LOG.error('DatabaseError while updating charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+                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)
+                    try:
+                        self.session.add(new_session)
+                        LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
+                        self._update_session_odometer(new_session)
+                        self._update_session_position(new_session)
+                        self._update_session_charging_type(new_session)
+                        self.last_charging_session = new_session
+                    except DatabaseError as err:
+                        self.session.rollback()
+                        LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
             else:
                 if self.last_charging_session.was_started():
                     LOG.debug("Continuing existing charging session for vehicle %s", self.vehicle.vin)
                 else:
                     LOG.debug("Starting charging in existing charging session for vehicle %s", self.vehicle.vin)
                     try:
-                        self.last_charging_session.session_start_date = element.last_updated
+                        self.last_charging_session.session_start_date = element.last_changed
                         self._update_session_odometer(self.last_charging_session)
+                        self._update_session_position(self.last_charging_session)
+                        self._update_session_charging_type(self.last_charging_session)
                     except DatabaseError as err:
                         self.session.rollback()
                         LOG.error('DatabaseError while starting charging session for vehicle %s in database: %s', self.vehicle.vin, err)
@@ -153,7 +182,7 @@ class ChargingAgent(BaseAgent):
             if self.last_charging_session is not None and not self.last_charging_session.was_ended():
                 LOG.info("Ending charging session for vehicle %s", self.vehicle.vin)
                 try:
-                    self.last_charging_session.session_end_date = element.last_updated
+                    self.last_charging_session.session_end_date = element.last_changed
                 except DatabaseError as err:
                     self.session.rollback()
                     LOG.error('DatabaseError while ending charging session for vehicle %s in database: %s', self.vehicle.vin, err)
@@ -230,11 +259,12 @@ class ChargingAgent(BaseAgent):
         if 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", self.vehicle.vin)
-                new_session: ChargingSession = ChargingSession(vin=self.vehicle.vin, plug_connected_date=element.last_updated)
+                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:
                     self.session.add(new_session)
                     self._update_session_odometer(new_session)
+                    self._update_session_position(new_session)
                     LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
                     self.last_charging_session = new_session
                 except DatabaseError as err:
@@ -243,8 +273,9 @@ class ChargingAgent(BaseAgent):
             elif not self.last_charging_session.was_connected():
                 LOG.debug("Continuing existing charging session for vehicle %s, writing connected date", self.vehicle.vin)
                 try:
-                    self.last_charging_session.plug_connected_date = element.last_updated
+                    self.last_charging_session.plug_connected_date = element.last_changed
                     self._update_session_odometer(self.last_charging_session)
+                    self._update_session_position(self.last_charging_session)
                 except DatabaseError as err:
                     self.session.rollback()
                     LOG.error('DatabaseError while starting charging session for vehicle %s in database: %s', self.vehicle.vin, err)
@@ -253,10 +284,32 @@ class ChargingAgent(BaseAgent):
             if self.last_charging_session is not None and not self.last_charging_session.was_disconnected():
                 LOG.info("Writing plug disconnected date for charging session of vehicle %s", self.vehicle.vin)
                 try:
-                    self.last_charging_session.plug_disconnected_date = element.last_updated
+                    self.last_charging_session.plug_disconnected_date = element.last_changed
                 except DatabaseError as err:
                     self.session.rollback()
                     LOG.error('DatabaseError while ending charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+        # 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:
+                    self.session.add(new_session)
+                    self._update_session_odometer(new_session)
+                    self._update_session_position(new_session)
+                    LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
+                    self.last_charging_session = new_session
+                except DatabaseError as err:
+                    self.session.rollback()
+                    LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+            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
+                    LOG.info("Writing plug connected date for charging session of vehicle %s", self.vehicle.vin)
+                except DatabaseError as err:
+                    self.session.rollback()
+                    LOG.error('DatabaseError while changing charging session for vehicle %s to database: %s', self.vehicle.vin, err)
         self.carconnectivity_last_connector_state = element.value
 
     def __on_connector_lock_state_change(self, element: EnumAttribute[ChargingConnector.ChargingConnectorLockState], flags: Observable.ObserverEvent) -> None:
@@ -270,11 +323,12 @@ 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", self.vehicle.vin)
-                new_session: ChargingSession = ChargingSession(vin=self.vehicle.vin, plug_locked_date=element.last_updated)
+                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:
                     self.session.add(new_session)
                     self._update_session_odometer(new_session)
+                    self._update_session_position(new_session)
                     LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
                     self.last_charging_session = new_session
                 except DatabaseError as err:
@@ -283,8 +337,9 @@ class ChargingAgent(BaseAgent):
             elif not self.last_charging_session.was_locked():
                 LOG.debug("Continuing existing charging session for vehicle %s, writing locked date", self.vehicle.vin)
                 try:
-                    self.last_charging_session.plug_locked_date = element.last_updated
+                    self.last_charging_session.plug_locked_date = element.last_changed
                     self._update_session_odometer(self.last_charging_session)
+                    self._update_session_position(self.last_charging_session)
                 except DatabaseError as err:
                     self.session.rollback()
                     LOG.error('DatabaseError while starting charging session for vehicle %s in database: %s', self.vehicle.vin, err)
@@ -293,10 +348,32 @@ class ChargingAgent(BaseAgent):
             if self.last_charging_session is not None and not self.last_charging_session.was_unlocked():
                 LOG.info("Writing plug unlocked date for charging session of vehicle %s", self.vehicle.vin)
                 try:
-                    self.last_charging_session.plug_unlocked_date = element.last_updated
+                    self.last_charging_session.plug_unlocked_date = element.last_changed
                 except DatabaseError as err:
                     self.session.rollback()
                     LOG.error('DatabaseError while ending charging session for vehicle %s in database: %s', self.vehicle.vin, err)
+        # Create charging session when locked at startup
+        elif 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:
+                    self.session.add(new_session)
+                    self._update_session_odometer(new_session)
+                    self._update_session_position(new_session)
+                    LOG.debug('Added new charging session for vehicle %s to database', self.vehicle.vin)
+                    self.last_charging_session = new_session
+                except DatabaseError as err:
+                    self.session.rollback()
+                    LOG.error('DatabaseError while adding charging session for vehicle %s to database: %s', self.vehicle.vin, err)
+            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
+                    LOG.info("Writing plug locked date for charging session of vehicle %s", self.vehicle.vin)
+                except DatabaseError as err:
+                    self.session.rollback()
+                    LOG.error('DatabaseError while changing charging session for vehicle %s to database: %s', self.vehicle.vin, err)
         self.carconnectivity_last_connector_lock_state = element.value
 
     def _update_session_odometer(self, charging_session: ChargingSession) -> None:
@@ -310,6 +387,18 @@ class ChargingAgent(BaseAgent):
                     self.session.rollback()
                     LOG.error('DatabaseError while updating odometer for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
 
+    def _update_session_charging_type(self, charging_session: ChargingSession) -> None:
+        if self.vehicle.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 charging_session.charging_type is None:
+                try:
+                    charging_session.charging_type = self.vehicle.carconnectivity_vehicle.charging.type.value
+                except DatabaseError as err:
+                    self.session.rollback()
+                    LOG.error('DatabaseError while updating charging type for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
+
     def _update_session_position(self, charging_session: ChargingSession) -> None:
         if self.vehicle.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
@@ -324,3 +413,22 @@ class ChargingAgent(BaseAgent):
                 except DatabaseError as err:
                     self.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)
+                try:
+                    location = self.session.merge(location)
+                    charging_session.location = location
+                except DatabaseError as err:
+                    self.session.rollback()
+                    LOG.error('DatabaseError while merging location for charging session of vehicle %s in database: %s', self.vehicle.vin, err)
+        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:
+            charging_station: ChargingStation = ChargingStation.from_carconnectivity_charging_station(
+                charging_station=self.vehicle.carconnectivity_vehicle.charging.charging_station)
+            try:
+                charging_station = self.session.merge(charging_station)
+                charging_session.charging_station = charging_station
+            except DatabaseError as err:
+                self.session.rollback()
+                LOG.error('DatabaseError while merging charging station for charging session of vehicle %s in database: %s', self.vehicle.vin, err)

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/agents/drive_state_agent.py

@@ -10,6 +10,7 @@ from carconnectivity.observable import Observable
 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_range_full import DriveRangeEstimatedFull
 
 if TYPE_CHECKING:
     from typing import Optional
@@ -22,6 +23,7 @@ if TYPE_CHECKING:
 
 LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents.drive_state_agent")
 
+
 class DriveStateAgent(BaseAgent):
     def __init__(self, session: Session, drive: Drive) -> None:
         if drive is None or drive.carconnectivity_drive is None:
@@ -31,6 +33,8 @@ class DriveStateAgent(BaseAgent):
 
         self.last_level: Optional[DriveLevel] = session.query(DriveLevel).filter(DriveLevel.drive_id == drive.id).order_by(DriveLevel.first_date.desc()).first()
         self.last_range: Optional[DriveRange] = session.query(DriveRange).filter(DriveRange.drive_id == drive.id).order_by(DriveRange.first_date.desc()).first()
+        self.last_range_estimated_full: Optional[DriveRangeEstimatedFull] = session.query(DriveRangeEstimatedFull) \
+            .filter(DriveRangeEstimatedFull.drive_id == drive.id).order_by(DriveRangeEstimatedFull.first_date.desc()).first()
 
         drive.carconnectivity_drive.level.add_observer(self.__on_level_change, Observable.ObserverEvent.UPDATED)
         if drive.carconnectivity_drive.level.enabled:
@@ -40,6 +44,10 @@ class DriveStateAgent(BaseAgent):
         if drive.carconnectivity_drive.range.enabled:
             self.__on_range_change(drive.carconnectivity_drive.range, Observable.ObserverEvent.UPDATED)
 
+        drive.carconnectivity_drive.range_estimated_full.add_observer(self.__on_range_estimated_full_change, Observable.ObserverEvent.UPDATED)
+        if drive.carconnectivity_drive.range_estimated_full.enabled:
+            self.__on_range_estimated_full_change(drive.carconnectivity_drive.range_estimated_full, Observable.ObserverEvent.UPDATED)
+
     def __on_level_change(self, element: LevelAttribute, flags: Observable.ObserverEvent) -> None:
         del flags
         if element.enabled:
@@ -48,7 +56,7 @@ class DriveStateAgent(BaseAgent):
             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)
+                                                   level=element.value)
                 try:
                     self.session.add(new_level)
                     LOG.debug('Added new level %s for drive %s to database', element.value, self.drive.id)
@@ -74,7 +82,7 @@ class DriveStateAgent(BaseAgent):
             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)
+                                                   range=element.value)
                 try:
                     self.session.add(new_range)
                     LOG.debug('Added new range %s for drive %s to database', element.value, self.drive.id)
@@ -91,3 +99,29 @@ class DriveStateAgent(BaseAgent):
                     except DatabaseError as err:
                         self.session.rollback()
                         LOG.error('DatabaseError while updating range for drive %s in database: %s', self.drive.id, err)
+
+    def __on_range_estimated_full_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.enabled:
+            if self.last_range_estimated_full is not None:
+                self.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:
+                    self.session.add(new_range)
+                    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:
+                    self.session.rollback()
+                    LOG.error('DatabaseError while adding range_estimated_full for drive %s to database: %s', self.drive.id, err)
+            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
+                        LOG.debug('Updated range_estimated_full %s for drive %s in database', element.value, self.drive.id)
+                    except DatabaseError as err:
+                        self.session.rollback()
+                        LOG.error('DatabaseError while updating range_estimated_full for drive %s in database: %s', self.drive.id, err)

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/agents/trip_agent.py

@@ -90,7 +90,7 @@ class TripAgent(BaseAgent):
                         if self.trip is not None:
                             LOG.info("Ending trip for vehicle %s", self.vehicle.vin)
                             try:
-                                self.trip.end_date = element.last_updated if element.last_updated is not None else datetime.now(tz=timezone.utc)
+                                self.trip.destination_date = element.last_updated if element.last_updated is not None else datetime.now(tz=timezone.utc)
                                 if self.vehicle.carconnectivity_vehicle.odometer.enabled and \
                                         self.vehicle.carconnectivity_vehicle.odometer.value is not None:
                                     self.trip.destination_odometer = self.vehicle.carconnectivity_vehicle.odometer.value

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/model/__init__.py

@@ -4,11 +4,14 @@ from .charging_state import ChargingState  # noqa: F401
 from .charging_rate import ChargingRate  # noqa: F401
 from .charging_power import ChargingPower  # noqa: F401
 from .charging_session import ChargingSession  # noqa: F401
+from .charging_station import ChargingStation  # noqa: F401
 from .climatization_state import ClimatizationState  # noqa: F401
+from .connection_state import ConnectionState  # noqa: F401
 from .drive import Drive  # noqa: F401
 from .drive_level import DriveLevel  # noqa: F401
 from .drive_range import DriveRange  # noqa: F401
-from .connection_state import ConnectionState  # noqa: F401
+from .drive_range_full import DriveRangeEstimatedFull  # noqa: F401
+from .location import Location  # noqa: F401
 from .outside_temperature import OutsideTemperature  # noqa: F401
 from .state import State  # noqa: F401
 from .tag import Tag  # noqa: F401

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/model/charging_power.py

@@ -1,10 +1,10 @@
 """ This module contains the Vehicle charging power database model"""
 from __future__ import annotations
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from datetime import datetime
 
-from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKey, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from sqlalchemy_utc import UtcDateTime
@@ -12,6 +12,10 @@ from sqlalchemy_utc import UtcDateTime
 from carconnectivity_plugins.database.model.base import Base
 
 
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
 class ChargingPower(Base):  # pylint: disable=too-few-public-methods
     """
     SQLAlchemy model representing a vehicle's charging power information over a time period.
@@ -32,6 +36,7 @@ class ChargingPower(Base):  # pylint: disable=too-few-public-methods
     """
 
     __tablename__: str = 'charging_powers'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="vin_first_date"),)
 
     id: Mapped[int] = mapped_column(primary_key=True)
     vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/model/charging_rate.py

@@ -1,10 +1,10 @@
 """ This module contains the Vehicle charging rates database model"""
 from __future__ import annotations
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from datetime import datetime
 
-from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKey, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from sqlalchemy_utc import UtcDateTime
@@ -12,6 +12,10 @@ from sqlalchemy_utc import UtcDateTime
 from carconnectivity_plugins.database.model.base import Base
 
 
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
 class ChargingRate(Base):  # pylint: disable=too-few-public-methods
     """
     SQLAlchemy model representing a vehicle's charging type information over a time period.
@@ -32,6 +36,7 @@ class ChargingRate(Base):  # pylint: disable=too-few-public-methods
     """
 
     __tablename__: str = 'charging_rates'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="vin_first_date"),)
 
     id: Mapped[int] = mapped_column(primary_key=True)
     vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/model/charging_session.py

@@ -1,10 +1,10 @@
 """ This module contains the Vehicle charging sessions database model"""
 from __future__ import annotations
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from datetime import datetime
 
-from sqlalchemy import ForeignKey, Table, Column
+from sqlalchemy import ForeignKey, Table, Column, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship, backref
 
 from sqlalchemy_utc import UtcDateTime
@@ -14,6 +14,10 @@ from carconnectivity.charging import Charging
 from carconnectivity_plugins.database.model.base import Base
 
 
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
 charging_tag_association_table = Table('charging_sessions_tags', Base.metadata,
                                        Column('charging_sessions_id', ForeignKey('charging_sessions.id')),
                                        Column('tags_name', ForeignKey('tags.name'))
@@ -51,6 +55,7 @@ class ChargingSession(Base):  # pylint: disable=too-few-public-methods
     """
 
     __tablename__: str = 'charging_sessions'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "session_start_date", name="vin_session_start_date"),)
 
     id: Mapped[int] = mapped_column(primary_key=True)
     vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))
@@ -68,6 +73,17 @@ class ChargingSession(Base):  # pylint: disable=too-few-public-methods
     session_position_longitude: Mapped[Optional[float]]
     session_odometer: Mapped[Optional[float]]
     charging_type: Mapped[Optional[Charging.ChargingType]]
+    location_uid: Mapped[Optional[str]] = mapped_column(ForeignKey("locations.uid"))
+    location: Mapped[Optional["Location"]] = relationship("Location")
+    charging_station_uid: Mapped[Optional[str]] = mapped_column(ForeignKey("charging_stations.uid"))
+    charging_station: Mapped[Optional["ChargingStation"]] = relationship("ChargingStation")
+    meter_start_kwh = Mapped[Optional[float]]
+    meter_end_kwh = Mapped[Optional[float]]
+    price_per_kwh = Mapped[Optional[float]]
+    price_per_min = Mapped[Optional[float]]
+    price_per_session = Mapped[Optional[float]]
+    real_charged = Mapped[Optional[float]]
+    real_cost = Mapped[Optional[float]]
     tags: Mapped[list["Tag"]] = relationship("Tag", secondary=charging_tag_association_table, backref=backref("charging_sessions"))
 
     # pylint: disable-next=too-many-arguments, too-many-positional-arguments

{carconnectivity_plugin_database-0.1a11 → carconnectivity_plugin_database-0.1a14}/src/carconnectivity_plugins/database/model/charging_state.py

@@ -1,10 +1,10 @@
 """ This module contains the Vehicle charging state database model"""
 from __future__ import annotations
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from datetime import datetime
 
-from sqlalchemy import ForeignKey
+from sqlalchemy import ForeignKey, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from sqlalchemy_utc import UtcDateTime
@@ -13,6 +13,9 @@ from carconnectivity.charging import Charging
 
 from carconnectivity_plugins.database.model.base import Base
 
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
 
 class ChargingState(Base):  # pylint: disable=too-few-public-methods
     """
@@ -38,6 +41,7 @@ class ChargingState(Base):  # pylint: disable=too-few-public-methods
         state (Optional[Charging.ChargingState]): The charging state value.
     """
     __tablename__: str = 'charging_states'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="vin_first_date"),)
 
     id: Mapped[int] = mapped_column(primary_key=True)
     vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))