feat: dim_vessel add scd filters to vessel repository: +scd_date +scd_enable

Author: rv2931

backend/bloom/domain/vessel.py

@@ -6,6 +6,7 @@
 
 class Vessel(BaseModel):
     id: Union[int, None] = None
+    key: Union[str, None] = None
     mmsi: Union[int, None]
     ship_name: str
     width: Union[float, None] = None
@@ -24,6 +25,9 @@ class Vessel(BaseModel):
     details: Union[str, None] = None
     check: Union[str, None] = None
     length_class: Union[str, None] = None
+    scd_start: Union[datetime, None] = None
+    scd_end: Union[datetime, None] = None
+    scd_active: Union[bool, None] = None
 
 class VesselListView(Vessel):
     details:ClassVar[Union[str, None]] = None

backend/bloom/domain/zone.py

@@ -12,6 +12,7 @@ class Zone(BaseModel):
                 Geometry: lambda p: mapping(p),
             },)
     id: Union[int, None] = None
+    key: Union[str, None] = None
     category: str
     sub_category: Union[str, None] = None
     name: str
@@ -21,14 +22,21 @@ class Zone(BaseModel):
     centroid: Union[Point, None] = None
     json_data: Union[dict, None] = None
     enable: Union[bool, None] = None
+    scd_start: Union[datetime, None] = None
+    scd_end: Union[datetime, None] = None
+    scd_active: Union[bool, None] = None
 
 class ZoneSummary(BaseModel):
     id: Union[int, None] = None
+    key: Union[str, None] = None
     category: str
     sub_category: Union[str, None] = None
     name: str
     created_at: Union[datetime, None] = None
     enable: Union[bool, None] = None
+    scd_start: Union[datetime, None] = None
+    scd_end: Union[datetime, None] = None
+    scd_active: Union[bool, None] = None
 
 
 class ZoneListView(Zone):

backend/bloom/infra/database/sql_model.py

@@ -24,6 +24,7 @@
 class Vessel(Base):
     __tablename__ = "dim_vessel"
     id = Column("id", Integer, primary_key=True)
+    key = Column("key",String,nullable=False)
     mmsi = Column("mmsi", Integer)
     ship_name = Column("ship_name", String, nullable=False)
     width = Column("width", Double)
@@ -47,7 +48,6 @@ class Vessel(Base):
     scd_start = Column("scd_start",DateTime(timezone=True))
     scd_end = Column("scd_end",DateTime(timezone=True))
     scd_active = Column("scd_active",Boolean)
-    key = Column("key",String)
 
 
 class Alert(Base):
@@ -114,6 +114,7 @@ class SpireAisData(Base):
 class Zone(Base):
     __tablename__ = "dim_zone"
     id = Column("id", Integer, primary_key=True)
+    key = Column("key", String, nullable=False)
     category = Column("category", String, nullable=False)
     sub_category = Column("sub_category", String)
     name = Column("name", String, nullable=False)

backend/bloom/infra/repositories/repository_spire_ais_data.py

@@ -3,7 +3,7 @@
 from bloom.infra.database import sql_model
 from dependency_injector.providers import Callable
 from sqlalchemy.orm import Session
-from sqlalchemy import select, and_
+from sqlalchemy import select, and_, between
 from datetime import datetime
 from bloom.logger import logger
 
@@ -38,6 +38,7 @@ def get_all_data_after_date(
             sql_model.SpireAisData.spire_update_statement,
             sql_model.SpireAisData.vessel_mmsi,
             sql_model.Vessel.id,
+            sql_model.Vessel.key,
             sql_model.SpireAisData.position_accuracy,
             sql_model.SpireAisData.position_collection_type,
             sql_model.SpireAisData.position_course,
@@ -66,6 +67,7 @@ def get_all_data_after_date(
             "spire_update_statement",
             "vessel_mmsi",
             "vessel_id",
+            "vessel_key",
             "position_accuracy",
             "position_collection_type",
             "position_course",
@@ -90,6 +92,7 @@ def get_all_data_between_date(
             sql_model.SpireAisData.spire_update_statement,
             sql_model.SpireAisData.vessel_mmsi,
             sql_model.Vessel.id,
+            sql_model.Vessel.key,
             sql_model.SpireAisData.position_accuracy,
             sql_model.SpireAisData.position_collection_type,
             sql_model.SpireAisData.position_course,
@@ -112,13 +115,20 @@ def get_all_data_between_date(
                 sql_model.SpireAisData.created_at > created_updated_after,
                 sql_model.SpireAisData.created_at <= created_updated_before
             )
+        ).where(
+            # scd attribute management
+            # filter on spire_update_statement reference date
+            between(sql_model.SpireAisData.spire_update_statement,
+                    sql_model.Vessel.scd_start,
+                    sql_model.Vessel.scd_end)
         ).order_by(sql_model.SpireAisData.created_at.asc())
         result = session.execute(stmt)
         return pd.DataFrame(result, columns=[
             "id",
             "spire_update_statement",
             "vessel_mmsi",
             "vessel_id",
+            "vessel_key",
             "position_accuracy",
             "position_collection_type",
             "position_course",

backend/bloom/infra/repositories/repository_vessel.py

@@ -1,15 +1,17 @@
 from contextlib import AbstractContextManager
-from typing import Any, Generator, Union
+from typing import Any, Generator, Union, Optional
+from datetime import datetime
 
 from bloom.domain.vessel import Vessel
 from bloom.domain.metrics import VesselTimeInZone
 from bloom.infra.database import sql_model
 from dependency_injector.providers import Callable
-from sqlalchemy import func, select, update, and_, asc, desc, literal_column
+from sqlalchemy import func, select, update, and_, asc, desc, literal_column, between
 from sqlalchemy.orm import Session
 from bloom.routers.requests import (DatetimeRangeRequest,
                                     OrderByRequest,
                                     OrderByEnum)
+from bloom.config import settings
 
 
 class VesselRepository:
@@ -20,54 +22,128 @@ def __init__(
         self.session_factory = session_factory
 
 
-    def get_vessel_tracked_count(self, session: Session) -> int:
+    def get_vessel_tracked_count(self, session: Session,
+                                 scd_date:Optional[datetime]=None,
+                                 scd_enable:bool=True
+                                 ) -> int:
         stmt = select(func.count(sql_model.Vessel.id)).select_from(sql_model.Vessel)\
             .distinct().where(sql_model.Vessel.tracking_activated == True)
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
         return session.execute(stmt).scalar()
 
-    def get_vessel_types(self, session: Session) -> list[str]:
+    def get_vessel_types(self,
+                         session: Session,
+                         scd_date:Optional[datetime]=None,
+                         scd_enable:bool=True
+                        ) -> list[str]:
         stmt = select(sql_model.Vessel.type).select_from(sql_model.Vessel).distinct()
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
         return [i for i in session.execute(stmt).scalars()]
 
-    def get_vessel_length_classes(self, session: Session) -> list[str]:
+    def get_vessel_length_classes(self, session: Session,
+                         scd_date:Optional[datetime]=None,
+                         scd_enable:bool=True
+                         ) -> list[str]:
         stmt = select(sql_model.Vessel.length_class).select_from(sql_model.Vessel).distinct()
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
         return [i for i in session.execute(stmt).scalars()]
 
-    def get_vessel_countries(self, session: Session) -> list[str]:
+    def get_vessel_countries(self, session: Session,
+                         scd_date:Optional[datetime]=None,
+                         scd_enable:bool=True
+                         ) -> list[str]:
         stmt = select(sql_model.Vessel.country_iso3).select_from(sql_model.Vessel).distinct()
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
         return [i for i in session.execute(stmt).scalars()]
 
     def get_vessel_by_id(self, session: Session, vessel_id: int) -> Union[Vessel, None]:
         return session.get(sql_model.Vessel, vessel_id)
+    
+    def get_vessel_by_key(self, session: Session,
+                          key: str,
+                          scd_date:Optional[datetime]=None,
+                          scd_enable:bool=True
+                         ) -> Union[Vessel, list[Vessel],None]:
+        stmt=select(sql_model.Vessel).where(sql_model.Vessel.key == key)
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
+            return session.execute(stmt).scalar()
+        else:
+            return session.execute(stmt).scalars()
 
-    def get_activated_vessel_by_mmsi(self, session: Session, mmsi: int) -> Union[Vessel, None]:
+    def get_activated_vessel_by_mmsi(self, session: Session,
+                                     mmsi: int,
+                                     scd_date:Optional[datetime]=None,
+                                     scd_enable:bool=True
+                                     ) -> Union[Vessel, None]:
         stmt = select(sql_model.Vessel).where(
             and_(
                 sql_model.Vessel.tracking_activated == True,
                 sql_model.Vessel.mmsi == mmsi
             )
         )
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
         vessel = session.execute(stmt).scalar()
         if not vessel:
             return None
         else:
             return VesselRepository.map_to_domain(vessel)
 
-    def get_vessels_list(self, session: Session) -> list[Vessel]:
+    def get_vessels_list(self, session: Session,
+                         scd_date:Optional[datetime]=None,
+                         scd_enable:bool=True
+                         ) -> list[Vessel]:
         """
         Liste l'ensemble des vessels actifs
         """
         stmt = select(sql_model.Vessel).where(sql_model.Vessel.tracking_activated == True)
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
         e = session.execute(stmt).scalars()
         if not e:
             return []
         return [VesselRepository.map_to_domain(vessel) for vessel in e]
 
-    def get_all_vessels_list(self, session: Session) -> list[Vessel]:
+    def get_all_vessels_list(self,
+                             session: Session,
+                             scd_date:Optional[datetime]=None,
+                             scd_enable:bool=True
+                             ) -> list[Vessel]:
         """
         Liste l'ensemble des vessels actifs ou inactifs
         """
         stmt = select(sql_model.Vessel)
+        if scd_enable:
+            if scd_date:
+                stmt=stmt.where(between(scd_date,sql_model.Vessel.scd_start,sql_model.Vessel.scd_end))
+            else:
+                stmt=stmt.where(sql_model.Vessel.scd_active)
         e = session.execute(stmt).scalars()
 
         if not e:
@@ -137,8 +213,10 @@ def get_vessel_times_in_zones(  self,
 
         return result
 
-    def batch_create_vessel(self, session: Session, vessels: list[Vessel]) -> list[Vessel]:
-        orm_list = [VesselRepository.map_to_sql(port) for port in vessels]
+    def batch_create_vessel(self, session: Session,
+                            vessels: list[Vessel]
+                            ) -> list[Vessel]:
+        orm_list = [VesselRepository.map_to_sql(vessel) for vessel in vessels]
         session.add_all(orm_list)
         return [VesselRepository.map_to_domain(orm) for orm in orm_list]
 
@@ -187,12 +265,16 @@ def map_to_domain(sql_vessel: sql_model.Vessel) -> Vessel:
             details=sql_vessel.details,
             check=sql_vessel.check,
             length_class=sql_vessel.length_class,
+            scd_start=sql_vessel.scd_start,
+            scd_end=sql_vessel.scd_end,
+            scd_active=sql_vessel.scd_active,
         )
 
     @staticmethod
     def map_to_sql(vessel: Vessel) -> sql_model.Vessel:
         return sql_model.Vessel(
             id=vessel.id,
+            key=vessel.key,
             mmsi=vessel.mmsi,
             ship_name=vessel.ship_name,
             width=vessel.width,
@@ -211,4 +293,7 @@ def map_to_sql(vessel: Vessel) -> sql_model.Vessel:
             details=vessel.details,
             check=vessel.check,
             length_class=vessel.length_class,
+            scd_start=vessel.scd_start,
+            scd_end=vessel.scd_end,
+            scd_active=vessel.scd_active,
         )

backend/bloom/infra/repositories/repository_vessel_position.py

@@ -23,7 +23,10 @@ def create_vessel_position(self, session: Session, position: VesselPosition) ->
         session.add(orm_position)
         return VesselPositionRepository.map_to_domain(orm_position)
 
-    def batch_create_vessel_position(self, session: Session, vessel_positions: list[VesselPosition]) -> list[
+    def batch_create_vessel_position(self,
+                                     session: Session,
+                                     vessel_positions: list[VesselPosition]
+                                     ) -> list[
         VesselPosition]:
         orm_list = [VesselPositionRepository.map_to_sql(vessel_position) for vessel_position in vessel_positions]
         session.add_all(orm_list)