feat: Fc logger

MODULE.bazel

@@ -0,0 +1,6 @@
+###############################################################################
+# Bazel now uses Bzlmod by default to manage external dependencies.
+# Please consider migrating your external dependencies from WORKSPACE to MODULE.bazel.
+#
+# For more details, please check https://github.com/bazelbuild/bazel/issues/18958
+###############################################################################

Makefile

@@ -10,6 +10,8 @@ update-deps:
 	cd desktop && flutter pub upgrade && flutter build linux
 
 run-all:
+	mkdir -p desktop/data/csv
+	chmod u+rwx desktop/data/csv
 	$(MAKE) -j 2 run-proxy run-desktop
 
 run-proxy:

api/app.py

@@ -110,6 +110,11 @@ def emit(self, record):
 from api.mainservice.router import router as mainservice_router
 from proxy.app.services.mainservice import initialize_mainservice
 
+# fcfilelogger
+from api.fcfileloggerapp.socketio import register_fcfileloggerapp_socketio
+from api.fcfileloggerapp.router import router as fcfilelogger_router
+from proxy.app.services.fcfileloggerapp import initialize_fcfileloggerapp
+
 
 sio = AsyncServer(
     async_mode='asgi',
@@ -138,6 +143,7 @@ def emit(self, record):
 app.include_router(primer_router)
 app.include_router(recovery_router)
 app.include_router(mainservice_router)
+app.include_router(fcfilelogger_router)
 
 register_servoservice_socketio(sio)
 register_engineservice_socketio(sio)
@@ -150,6 +156,7 @@ def emit(self, record):
 register_fileloggerapp_socketio(sio)
 register_fcsysstatservice_socketio(sio)
 register_mainservice_socketio(sio)
+register_fcfileloggerapp_socketio(sio)
 
 @app.middleware("http")
 async def log_requests(request, call_next):
@@ -186,6 +193,7 @@ async def lifespan(app: FastAPI):
     gps_task = asyncio.create_task(run_gpsservice_manager(sd_instance))
     mainserivce_task = asyncio.create_task(run_mainservice_manager(sd_instance))
     fcservice_task = asyncio.create_task(run_fcsysstatservice_manager(sd_instance))
+    fcfilelogger_task = asyncio.create_task(run_fcsysstatservice_manager(sd_instance))
 
 
     yield
@@ -237,6 +245,9 @@ async def run_mainservice_manager(sd):
 async def run_fcsysstatservice_manager(sd):
     await initialize_fcsysstatservice(sd)
 
+async def fc_fileloggerservice_manager(sd):
+    await initialize_fcfileloggerapp(sd)
+
 if __name__ == '__main__':
     import uvicorn
 

api/engineservice/router.py

@@ -2,7 +2,7 @@
 from fastapi import APIRouter, Body, HTTPException
 from fastapi.responses import JSONResponse
 from loguru import logger
-from proxy.app.dataclasses.engineservice_dataclass import (StartOut, SetModeOut)
+from proxy.app.dataclasses.engineservice_dataclass import (SetVentValveOut, SetModeOut, StartOut, GetModeOut)
 from proxy.app.services.engineservice import EngineServiceManager
 from api.common import process_method_result
 
@@ -12,6 +12,20 @@
 )
 
 
+@router.post("/getmode")
+async def getmode(data: dict = Body(...)):
+    try:
+        service_manager = EngineServiceManager()
+        params = data or {}
+        method_result = await service_manager.GetMode(**params)
+        return process_method_result(method_result, deserialization_class=GetModeOut)
+    except Exception as e:
+        logger.exception("Error in getmode handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
 @router.post("/setmode")
 async def setmode(data: dict = Body(...)):
     try:
@@ -26,6 +40,20 @@ async def setmode(data: dict = Body(...)):
             content={"error": str(e)}
         )
 
+@router.post("/setventvalve")
+async def setventvalve(data: dict = Body(...)):
+    try:
+        service_manager = EngineServiceManager()
+        params = data or {}
+        method_result = await service_manager.SetVentValve(**params)
+        return process_method_result(method_result, deserialization_class=SetVentValveOut)
+    except Exception as e:
+        logger.exception("Error in setventvalve handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
 @router.post("/start")
 async def start(data: dict = Body(...)):
     try:

api/engineservice/socketio.py

@@ -34,3 +34,35 @@ async def get_currentmode(sid, data):
                           room=sid,
                           namespace=namespace)
 
+    @sio.on('newhbstatus', namespace=namespace)
+    async def get_newhbstatus(sid, data):
+        try:
+            manager = EngineServiceManager()
+            response = manager.get_newhbstatus()
+            await sio.emit('newhbstatus', 
+                          {'event_name': 'newhbstatus', 'response': response},
+                          room=sid,
+                          namespace=namespace)
+        except Exception as e:
+            logger.exception("Error handling event newhbstatus: %s", e)
+            await sio.emit('event_error',
+                          {'error': str(e)},
+                          room=sid,
+                          namespace=namespace)
+
+    @sio.on('newventvalvestatus', namespace=namespace)
+    async def get_newventvalvestatus(sid, data):
+        try:
+            manager = EngineServiceManager()
+            response = manager.get_newventvalvestatus()
+            await sio.emit('newventvalvestatus', 
+                          {'event_name': 'newventvalvestatus', 'response': response},
+                          room=sid,
+                          namespace=namespace)
+        except Exception as e:
+            logger.exception("Error handling event newventvalvestatus: %s", e)
+            await sio.emit('event_error',
+                          {'error': str(e)},
+                          room=sid,
+                          namespace=namespace)
+

api/envapp/router.py

@@ -0,0 +1,55 @@
+
+from fastapi import APIRouter, Body, HTTPException
+from fastapi.responses import JSONResponse
+from loguru import logger
+from proxy.app.dataclasses.envapp_dataclass import (GetLowerTankTempOut, GetUpperTankTempOut, GetTankPressureOut)
+from proxy.app.services.envapp import EnvAppManager
+from api.common import process_method_result
+
+router = APIRouter(
+    prefix="/envapp",
+    tags=["envapp"]
+)
+
+
+@router.post("/getlowertanktemp")
+async def getlowertanktemp(data: dict = Body(...)):
+    try:
+        service_manager = EnvAppManager()
+        params = data or {}
+        method_result = await service_manager.GetLowerTankTemp(**params)
+        return process_method_result(method_result, deserialization_class=GetLowerTankTempOut)
+    except Exception as e:
+        logger.exception("Error in getlowertanktemp handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+@router.post("/gettankpressure")
+async def gettankpressure(data: dict = Body(...)):
+    try:
+        service_manager = EnvAppManager()
+        params = data or {}
+        method_result = await service_manager.GetTankPressure(**params)
+        return process_method_result(method_result, deserialization_class=GetTankPressureOut)
+    except Exception as e:
+        logger.exception("Error in gettankpressure handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+@router.post("/getuppertanktemp")
+async def getuppertanktemp(data: dict = Body(...)):
+    try:
+        service_manager = EnvAppManager()
+        params = data or {}
+        method_result = await service_manager.GetUpperTankTemp(**params)
+        return process_method_result(method_result, deserialization_class=GetUpperTankTempOut)
+    except Exception as e:
+        logger.exception("Error in getuppertanktemp handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )

api/fcfileloggerapp/__init__.py

@@ -0,0 +1 @@
+# Package for fcfileloggerapp API

api/fcfileloggerapp/router.py

@@ -0,0 +1,41 @@
+
+from fastapi import APIRouter, Body, HTTPException
+from fastapi.responses import JSONResponse
+from loguru import logger
+from proxy.app.dataclasses.fcfileloggerapp_dataclass import (StopOut, StartOut)
+from proxy.app.services.fcfileloggerapp import FcFileLoggerAppManager
+from api.common import process_method_result
+
+router = APIRouter(
+    prefix="/fcfileloggerapp",
+    tags=["fcfileloggerapp"]
+)
+
+
+@router.post("/start")
+async def start(data: dict = Body(...)):
+    try:
+        service_manager = FcFileLoggerAppManager()
+        params = data or {}
+        method_result = await service_manager.Start(**params)
+        return process_method_result(method_result, deserialization_class=StartOut)
+    except Exception as e:
+        logger.exception("Error in start handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
+@router.post("/stop")
+async def stop(data: dict = Body(...)):
+    try:
+        service_manager = FcFileLoggerAppManager()
+        params = data or {}
+        method_result = await service_manager.Stop(**params)
+        return process_method_result(method_result, deserialization_class=StopOut)
+    except Exception as e:
+        logger.exception("Error in stop handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )

api/fcfileloggerapp/socketio.py

@@ -0,0 +1,36 @@
+
+from socketio import AsyncServer
+from loguru import logger
+from proxy.app.services.fcfileloggerapp import FcFileLoggerAppManager
+
+namespace = '/fcfileloggerapp'
+
+def register_fcfileloggerapp_socketio(sio: AsyncServer):
+    @sio.on('connect', namespace=namespace)
+    async def connect(sid, environ):
+        await sio.emit('connected', 
+                      {"message": "Connected to fcfileloggerapp namespace"},
+                      room=sid,
+                      namespace=namespace)
+
+    @sio.on('disconnect', namespace=namespace)
+    async def disconnect(sid):
+        logger.info("Client %s disconnected from fcfileloggerapp namespace", sid)
+
+
+    @sio.on('loggingstate', namespace=namespace)
+    async def get_loggingstate(sid, data):
+        try:
+            manager = FcFileLoggerAppManager()
+            response = manager.get_loggingstate()
+            await sio.emit('loggingstate', 
+                          {'event_name': 'loggingstate', 'response': response},
+                          room=sid,
+                          namespace=namespace)
+        except Exception as e:
+            logger.exception("Error handling event loggingstate: %s", e)
+            await sio.emit('event_error',
+                          {'error': str(e)},
+                          room=sid,
+                          namespace=namespace)
+

api/fileloggerapp/router.py

@@ -2,7 +2,7 @@
 from fastapi import APIRouter, Body, HTTPException
 from fastapi.responses import JSONResponse
 from loguru import logger
-from proxy.app.dataclasses.fileloggerapp_dataclass import (StartOut, StopOut)
+from proxy.app.dataclasses.fileloggerapp_dataclass import (StopOut, StartOut)
 from proxy.app.services.fileloggerapp import FileLoggerAppManager
 from api.common import process_method_result
 

api/primerservice/router.py

@@ -2,7 +2,7 @@
 from fastapi import APIRouter, Body, HTTPException
 from fastapi.responses import JSONResponse
 from loguru import logger
-from proxy.app.dataclasses.primerservice_dataclass import (OnPrimeOut, OffPrimeOut, StartPrimeOut)
+from proxy.app.dataclasses.primerservice_dataclass import (GetPrimerStateOut, OffPrimeOut, OnPrimeOut, StartPrimeOut)
 from proxy.app.services.primerservice import PrimerServiceManager
 from api.common import process_method_result
 
@@ -12,6 +12,20 @@
 )
 
 
+@router.post("/getprimerstate")
+async def getprimerstate(data: dict = Body(...)):
+    try:
+        service_manager = PrimerServiceManager()
+        params = data or {}
+        method_result = await service_manager.GetPrimerState(**params)
+        return process_method_result(method_result, deserialization_class=GetPrimerStateOut)
+    except Exception as e:
+        logger.exception("Error in getprimerstate handler: %s", e)
+        return JSONResponse(
+            status_code=500,
+            content={"error": str(e)}
+        )
+
 @router.post("/offprime")
 async def offprime(data: dict = Body(...)):
     try: