Add api.py

api.py

@@ -0,0 +1,138 @@
+import yaml
+import os
+import glob
+import importlib
+import re
+
+from fastapi import FastAPI, Request, HTTPException, APIRouter
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+with open('paths_config.yml', 'r') as file:
+    data = yaml.safe_load(file)
+    INITIAL= data["INITIAL"]
+    PATHS = data["PATHS"]
+BUILD_DIR = "."#"/build/"
+
+app = FastAPI()
+target_name="MICHELIN"
+display_name="Michelin"
+
+app.mount("/static", StaticFiles(directory=os.path.join(BUILD_DIR,"initial","static")), name="static_initial")
+app.mount("/static_common", StaticFiles(directory=os.path.join(BUILD_DIR,"static")), name="static")
+base_templates = Jinja2Templates(directory=os.path.join(BUILD_DIR,"initial","template"))
+error_template = Jinja2Templates(directory=os.path.join(BUILD_DIR,"templates"))
+
+
+
+@app.get("/")
+def read_root(request: Request):
+    first_file = next((f for f in os.listdir(os.path.join(BUILD_DIR,"initial","template")) if re.search(r"0_", f)), None)
+    donnees = {"request": request, "target_name":target_name, "display_name": display_name}
+    return base_templates.TemplateResponse(first_file, donnees)
+
+def find_router_modules(directory):
+    """Trouver tous les fichiers Python dans le dossier spécifié."""
+    module_paths = glob.glob(os.path.join(directory, "*.py"))
+    return [os.path.splitext(os.path.basename(path))[0] for path in module_paths]
+
+def load_routers(directory, module_names):
+    """Charger dynamiquement les routeurs à partir des noms de modules."""
+    routers = []
+    for module_name in module_names:
+        module = importlib.import_module(f"{directory}.{module_name}")
+        if hasattr(module, "router"):
+            routers.append(module.router)
+    return routers
+
+# Create a router and a Jinja2Templates instance for each path
+routers = {}
+key_list=list(PATHS.keys())
+key_list.append("initial")
+for path in key_list:
+    # Create the directory path for the templates
+    template_dir = os.path.join(BUILD_DIR, path, "template")
+
+    # Create the directory path for the static files
+    static_dir = os.path.join(BUILD_DIR, path, "static")
+
+    # Create an APIRouter instance
+    router = APIRouter()
+    # Mount static files to the router
+    router.mount("/static", StaticFiles(directory=static_dir), name="static_" + path)
+
+    router_directory = os.path.join(BUILD_DIR, path, "api")
+    router_modules = find_router_modules(router_directory)
+    api_routers = load_routers(f"{ path }.api", router_modules)
+
+    # Create a Jinja2Templates instance
+    templates = Jinja2Templates(directory=template_dir)
+
+    for new_router in api_routers:
+        router.include_router(new_router(templates))
+
+
+    # Add the router with templates and static files to the routers dictionary
+    routers[path] = {
+        "router": router,
+        "templates": templates
+    }
+
+def create_challenge_route(templates: Jinja2Templates):
+    async def challenge(request: Request, challenge: str):
+        try:
+            data = {"request": request}
+            return templates.TemplateResponse(challenge, data)
+        except Exception as e:
+            print(e)
+            return not_found_exception_handler(request,e)
+    return challenge
+
+# Add routes to each router
+for path, elements in routers.items():
+    router = elements["router"]
+    templates = elements["templates"]
+
+
+    challenge_route = create_challenge_route(templates)
+    router.get("/{challenge}")(challenge_route)
+    router.post("/{challenge}")(challenge_route)
+    router.put("/{challenge}")(challenge_route)
+
+    # Include the router in the main application with a path prefix
+    if path=="initial":
+        app.mount("/",router)
+    else:
+        app.mount(f"/{path}",router)
+
+
+@app.get("/{challenge}")
+def read_root_chall(request: Request, challenge: str):
+    try:
+        return base_templates.TemplateResponse(challenge, {"request": request})
+    except Exception as e:
+        print(e)
+        return not_found_exception_handler(request,e)
+
+
+
+
+
+async def get_body(request: Request):
+    return await request.body()
+
+
+
+@app.get("/hello/{name}")
+def hello_name(name: str):
+    return f"Hello {name}"
+
+
+
+
+@app.exception_handler(404)
+def not_found_exception_handler(request: Request, exc: HTTPException):
+    print("error 404")
+    return error_template.TemplateResponse('404.html', {'request': request})
+