wip => removed file in main

# Conflicts:
#	backend/bloom/tasks/create_update_rel_segments_zones.py

backend/bloom/config.py

@@ -16,6 +16,7 @@
     model_validator
 )
 
+
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
         # validate_assignment=True allows to update db_url value as soon as one of
@@ -27,44 +28,44 @@ class Settings(BaseSettings):
         env_ignore_empty=True,
         env_nested_delimiter='__',
         env_file='.env',
-        env_file_encoding = 'utf-8',
+        env_file_encoding='utf-8',
         extra='ignore'
-        )
-    
+    )
+
     # Déclaration des attributs/paramètres disponibles au sein de la class settings
-    postgres_user:str = Field(default='')
-    postgres_password:str = Field(default='')
-    postgres_hostname:str = Field(min_length=1,
-                                  default='localhost')
-    postgres_port:int = Field(gt=1024,
-                                  default=5432)
+    postgres_user: str = Field(default='')
+    postgres_password: str = Field(default='')
+    postgres_hostname: str = Field(min_length=1,
+                                   default='localhost')
+    postgres_port: int = Field(gt=1024,
+                               default=5432)
 
-    postgres_db:str = Field(min_length=1,max_length=32,pattern=r'^(?:[a-zA-Z]|_)[\w\d_]*$')
+    postgres_db: str = Field(min_length=1, max_length=32, pattern=r'^(?:[a-zA-Z]|_)[\w\d_]*$')
     srid: int = Field(default=4326)
-    spire_token:str = Field(default='')
-    data_folder:str=Field(default=str(Path(__file__).parent.parent.parent.joinpath('./data')))
-    db_url:str=Field(default='')
+    spire_token: str = Field(default='')
+    data_folder: str = Field(default=str(Path(__file__).parent.parent.parent.joinpath('./data')))
+    db_url: str = Field(default='')
 
     redis_host: str = Field(default='localhost')
     redis_port: int = Field(default=6379)
     redis_cache_expiration: int = Field(default=3600)
-    
-    logging_level:str=Field(
-                                default="INFO",
-                                pattern=r'NOTSET|DEBUG|INFO|WARNING|ERROR|CRITICAL'
-                            )
+
+    logging_level: str = Field(
+        default="INFO",
+        pattern=r'NOTSET|DEBUG|INFO|WARNING|ERROR|CRITICAL'
+    )
 
     @model_validator(mode='after')
-    def update_db_url(self)->dict:
-        new_url= f"postgresql://{self.postgres_user}:"\
-                          f"{self.postgres_password}@{self.postgres_hostname}:"\
-                          f"{self.postgres_port}/{self.postgres_db}"
+    def update_db_url(self) -> dict:
+        new_url = f"postgresql://{self.postgres_user}:" \
+                  f"{self.postgres_password}@{self.postgres_hostname}:" \
+                  f"{self.postgres_port}/{self.postgres_db}"
         if self.db_url != new_url:
-           self.db_url = new_url
+            self.db_url = new_url
         return self
 
 
 settings = Settings(_env_file=os.getenv('BLOOM_CONFIG',
-                                    Path(__file__).parent.parent.parent.joinpath('.env')),
+                                        Path(__file__).parent.parent.parent.joinpath('.env')),
                     _secrets_dir=os.getenv('BLOOM_SECRETS_DIR',
-                                    Path(__file__).parent.parent.parent.joinpath('./secrets')))
+                                           Path(__file__).parent.parent.parent.joinpath('./secrets')))

backend/bloom/container.py

@@ -14,7 +14,7 @@
 from dependency_injector import containers, providers
 
 
-class UseCases(containers.DeclarativeContainer):
+class UseCasesContainer(containers.DeclarativeContainer):
     config = providers.Configuration()
     db_url = settings.db_url
     db = providers.Singleton(

backend/bloom/infra/repositories/repository_excursion.py

@@ -34,18 +34,21 @@ def get_param_from_last_excursion(self, session: Session, vessel_id: int) -> Uni
             return None
         return {"arrival_port_id": result.arrival_port_id, "arrival_position": result.arrival_position}
 
-    def get_excursions_by_vessel_id(self, session: Session, vessel_id: int) -> List[Excursion]:
-        """Recheche l'excursion en cours d'un bateau, c'est-à-dire l'excursion qui n'a pas de date d'arrivée"""
-        stmt = select(sql_model.Excursion).where(sql_model.Excursion.vessel_id == vessel_id)
-        result = session.execute(stmt).scalars()
-        if not result:
-            return []
+    def get_excursions_by_vessel_id(self, vessel_id: int) -> List[Excursion]:
+        with self.session_factory as session:
+            """Recheche l'excursion en cours d'un bateau, c'est-à-dire l'excursion qui n'a pas de date d'arrivée"""
+            stmt = select(sql_model.Excursion).where(sql_model.Excursion.vessel_id == vessel_id)
+            result = session.execute(stmt).scalars()
+            if not result:
+                return []
         return [ExcursionRepository.map_to_domain(r) for r in result]
 
     def get_vessel_excursion_by_id(self, session: Session, vessel_id: int, excursion_id: int) -> Union[Excursion, None]:
         """Recheche l'excursion en cours d'un bateau, c'est-à-dire l'excursion qui n'a pas de date d'arrivée"""
-        stmt = select(sql_model.Excursion).where((sql_model.Excursion.vessel_id == vessel_id)
-                                                 & (sql_model.Excursion.id == excursion_id))
+        stmt = select(sql_model.Excursion).where(
+            (sql_model.Excursion.vessel_id == vessel_id)
+            & (sql_model.Excursion.id == excursion_id)
+        )
         result = session.execute(stmt).scalar()
         if not result:
             return None
@@ -164,29 +167,3 @@ def map_to_domain(excursion: sql_model.Excursion) -> Excursion:
             created_at=excursion.created_at,
             updated_at=excursion.updated_at
         )
-
-    @staticmethod
-    def map_to_orm(excursion: Excursion) -> sql_model.Excursion:
-        return sql_model.Excursion(
-            id=excursion.id,
-            vessel_id=excursion.vessel_id,
-            departure_port_id=excursion.departure_port_id,
-            departure_at=excursion.departure_at,
-            departure_position=from_shape(
-                excursion.departure_position) if excursion.departure_position is not None else None,
-            arrival_port_id=excursion.arrival_port_id,
-            arrival_at=excursion.arrival_at,
-            arrival_position=from_shape(excursion.arrival_position) if excursion.arrival_position is not None else None,
-            excursion_duration=excursion.excursion_duration,
-            total_time_at_sea=excursion.total_time_at_sea,
-            total_time_in_amp=excursion.total_time_in_amp,
-            total_time_in_territorial_waters=excursion.total_time_fishing_in_territorial_waters,
-            total_time_in_costal_waters=excursion.total_time_fishing_in_costal_waters,
-            total_time_fishing=excursion.total_time_fishing,
-            total_time_fishing_in_amp=excursion.total_time_fishing_in_amp,
-            total_time_fishing_in_territorial_waters=excursion.total_time_fishing_in_territorial_waters,
-            total_time_fishing_in_costal_waters=excursion.total_time_fishing_in_costal_waters,
-            total_time_extincting_amp=excursion.total_time_extincting_amp,
-            created_at=excursion.created_at,
-            updated_at=excursion.updated_at
-        )

backend/bloom/infra/repositories/repository_port.py

@@ -17,17 +17,19 @@ class PortRepository:
     def __init__(self, session_factory: Callable) -> None:
         self.session_factory = session_factory
 
-    def get_port_by_id(self, session: Session, port_id: int) -> Union[Port, None]:
-        entity = session.get(sql_model.Port, port_id)
+    def get_port_by_id(self, port_id: int) -> Union[Port, None]:
+        with self.session_factory() as session:
+            entity = session.get(sql_model.Port, port_id)
         if entity is not None:
             return PortRepository.map_to_domain(entity)
         else:
             return None
 
-    def get_all_ports(self, session: Session) -> List[Port]:
-        q = session.query(sql_model.Port)
-        if not q:
-            return []
+    def get_all_ports(self) -> List[Port]:
+        with self.session_factory() as session:
+            q = session.query(sql_model.Port)
+            if not q:
+                return []
         return [PortRepository.map_to_domain(entity) for entity in q]
 
     def get_empty_geometry_buffer_ports(self, session: Session) -> list[Port]:

backend/bloom/main.py

@@ -0,0 +1,65 @@
+from fastapi import FastAPI
+from starlette.requests import Request
+
+from bloom.container import UseCasesContainer
+from bloom.routers import excursions, zones, vessels, ports
+from bloom.routers.vessels import router, rd
+
+
+def init_db(container):
+    db = container.db()
+    db.create_database()
+
+
+def create_app() -> FastAPI:
+    container = init_container()
+
+    init_db(container)
+    server = init_server(container)
+    # server.add_exception_handler(DBException, db_exception_handler)
+    # server.add_exception_handler(ValidationError, validation_exception_handler)
+    # server.add_exception_handler(Exception, generic_exception_handler)
+
+    return server
+
+
+def init_container():
+    container = UseCasesContainer()
+    container.wire(
+        modules=[
+            zones,
+            vessels,
+            excursions,
+            ports
+        ]
+    )
+    return container
+
+
+def init_server(container):
+    server = FastAPI(dependencies=[])
+    server.container = container
+    server.include_router(excursions.router)
+    server.include_router(ports.router)
+    server.include_router(vessels.router)
+    server.include_router(zones.router)
+    return server
+
+
+app = create_app()
+
+
+@app.get("/")
+async def root(request: Request):
+    return {
+        "maptiles": f"{request.url_for('list_maptiles')}",
+        "ports": f"{request.url_for('list_ports')}",
+        "vessels": f"{request.url_for('list_vessels')}",
+        "zones": f"{request.url_for('list_zones')}",
+    }
+
+
+@router.get("/cache/all/flush")
+async def cache_all_flush(request: Request):
+    await rd.flushall()
+    return {"code": 0}

backend/bloom/routers/excursions.py

@@ -0,0 +1,71 @@
+import json
+import time
+
+import redis
+from dependency_injector.wiring import inject, Provide
+from fastapi import APIRouter, Depends
+
+from bloom.config import settings
+from bloom.container import UseCasesContainer
+from bloom.logger import logger
+from bloom.usecase.Excursions import ExcursionUseCase
+
+rd = redis.Redis(host=settings.redis_host, port=settings.redis_port, db=0)
+
+router = APIRouter()
+
+
+@router.get("/vessels/{vessel_id}/excursions")
+@inject
+async def list_vessel_excursions(
+        vessel_id: int,
+        nocache: bool = False,
+        excursion_usecase: ExcursionUseCase = Depends(
+            Provide[UseCasesContainer.emission_service]
+        )
+):
+    endpoint = f"/vessels/{vessel_id}/excursions"
+    cache = rd.get(endpoint)
+    start = time.time()
+    if cache and not nocache:
+        logger.debug(f"{endpoint} cached ({settings.redis_cache_expiration})s")
+        payload = json.loads(cache)
+        logger.debug(f"{endpoint} elapsed Time: {time.time() - start}")
+        return payload
+    else:
+        return excursion_usecase.list_vessel_excursions(vessel_id)
+
+
+@router.get("/vessels/{vessel_id}/excursions/{excursions_id}")
+async def get_vessel_excursion(
+        vessel_id: int,
+        excursions_id: int,
+        excursion_usecase: ExcursionUseCase = Depends(
+            Provide[UseCasesContainer.emission_service]
+        )):
+    return excursion_usecase.get_excursion_by_id(vessel_id, excursions_id)
+
+
+@router.get("/vessels/{vessel_id}/excursions/{excursions_id}/segments")
+@inject
+async def list_vessel_excursion_segments(
+        vessel_id: int,
+        excursions_id: int,
+        excursion_usecase: ExcursionUseCase = Depends(
+            Provide[UseCasesContainer.emission_service]
+        )
+):
+    return excursion_usecase.get_excursions_segments(vessel_id, excursions_id)
+
+
+@router.get("/vessels/{vessel_id}/excursions/{excursions_id}/segments/{segment_id}")
+@inject
+async def get_vessel_excursion_segment(
+        vessel_id: int,
+        excursions_id: int,
+        segment_id: int,
+        excursion_usecase: ExcursionUseCase = Depends(
+            Provide[UseCasesContainer.emission_service]
+        )
+):
+    return await excursion_usecase.get_segment_by_id(vessel_id, excursions_id, segment_id)

backend/bloom/routers/ports.py

@@ -0,0 +1,45 @@
+import json
+import time
+
+from redis import Redis
+from dependency_injector.wiring import inject, Provide
+from fastapi import APIRouter, Depends
+from bloom.config import settings
+from bloom.container import UseCasesContainer
+from bloom.logger import logger
+from bloom.services.api import rd
+from bloom.usecase.Ports import PortUseCase
+
+router = APIRouter()
+redis_client = Redis(host=settings.redis_host, port=settings.redis_port, db=0)
+
+
+@router.get("/ports")
+@inject
+async def list_ports(
+        nocache: bool = False,
+        ports_usecase: PortUseCase = Depends(
+            Provide[UseCasesContainer.emission_service]
+        )
+):
+    endpoint = f"/ports"
+    cache = rd.get(endpoint)
+    start = time.time()
+    if cache and not nocache:
+        logger.debug(f"{endpoint} cached ({settings.redis_cache_expiration})s")
+        payload = json.loads(cache)
+        logger.debug(f"{endpoint} elapsed Time: {time.time() - start}")
+        return payload
+    else:
+        return ports_usecase.list_ports()
+
+
+@router.get("/ports/{port_id}")
+@inject
+async def get_port(
+        port_id: int,
+        ports_usecase: PortUseCase = Depends(
+            Provide[UseCasesContainer.emission_service]
+        )
+):
+    return ports_usecase.get_port_by_id(port_id)