拆分main.py

app/api/v1/endpoints/components/controls.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter, Request
+from typing import Any, List, Dict, Union
+from app.services.tjnetwork import *
+
+router = APIRouter()
+
+@router.get("/getcontrolschema/")
+async def fastapi_get_control_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_control_schema(network)
+
+@router.get("/getcontrolproperties/")
+async def fastapi_get_control_properties(network: str) -> dict[str, Any]:
+    return get_control(network)
+
+@router.post("/setcontrolproperties/", response_model=None)
+async def fastapi_set_control_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_control(network, ChangeSet(props))
+
+@router.get("/getruleschema/")
+async def fastapi_get_rule_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_rule_schema(network)
+
+@router.get("/getruleproperties/")
+async def fastapi_get_rule_properties(network: str) -> dict[str, Any]:
+    return get_rule(network)
+
+@router.post("/setruleproperties/", response_model=None)
+async def fastapi_set_rule_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_rule(network, ChangeSet(props))

app/api/v1/endpoints/components/curves.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Request
+from typing import Any, List, Dict, Union
+from app.services.tjnetwork import *
+
+router = APIRouter()
+
+@router.get("/getcurveschema")
+async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_curve_schema(network)
+
+@router.post("/addcurve/", response_model=None)
+async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = {
+        "id": curve,
+    } | props
+    return add_curve(network, ChangeSet(ps))
+
+@router.post("/deletecurve/", response_model=None)
+async def fastapi_delete_curve(network: str, curve: str) -> ChangeSet:
+    ps = {"id": curve}
+    return delete_curve(network, ChangeSet(ps))
+
+@router.get("/getcurveproperties/")
+async def fastapi_get_curve_properties(network: str, curve: str) -> dict[str, Any]:
+    return get_curve(network, curve)
+
+@router.post("/setcurveproperties/", response_model=None)
+async def fastapi_set_curve_properties(
+    network: str, curve: str, req: Request
+) -> ChangeSet:
+    props = await req.json()
+    ps = {"id": curve} | props
+    return set_curve(network, ChangeSet(ps))
+
+@router.get("/getcurves/")
+async def fastapi_get_curves(network: str) -> list[str]:
+    return get_curves(network)
+
+@router.get("/iscurve/")
+async def fastapi_is_curve(network: str, curve: str) -> bool:
+    return is_curve(network, curve)

app/api/v1/endpoints/components/options.py

@@ -0,0 +1,60 @@
+from fastapi import APIRouter, Request
+from typing import Any, List, Dict, Union
+from app.services.tjnetwork import *
+
+router = APIRouter()
+
+@router.get("/gettimeschema")
+async def fastapi_get_time_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_time_schema(network)
+
+@router.get("/gettimeproperties/")
+async def fastapi_get_time_properties(network: str) -> dict[str, Any]:
+    return get_time(network)
+
+@router.post("/settimeproperties/", response_model=None)
+async def fastapi_set_time_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_time(network, ChangeSet(props))
+
+@router.get("/getenergyschema/")
+async def fastapi_get_energy_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_energy_schema(network)
+
+@router.get("/getenergyproperties/")
+async def fastapi_get_energy_properties(network: str) -> dict[str, Any]:
+    return get_energy(network)
+
+@router.post("/setenergyproperties/", response_model=None)
+async def fastapi_set_energy_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_energy(network, ChangeSet(props))
+
+@router.get("/getpumpenergyschema/")
+async def fastapi_get_pump_energy_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pump_energy_schema(network)
+
+@router.get("/getpumpenergyproperties//")
+async def fastapi_get_pump_energy_proeprties(network: str, pump: str) -> dict[str, Any]:
+    return get_pump_energy(network, pump)
+
+@router.get("/setpumpenergyproperties//", response_model=None)
+async def fastapi_set_pump_energy_properties(
+    network: str, pump: str, req: Request
+) -> ChangeSet:
+    props = await req.json()
+    ps = {"id": pump} | props
+    return set_pump_energy(network, ChangeSet(ps))
+
+@router.get("/getoptionschema/")
+async def fastapi_get_option_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_option_v3_schema(network)
+
+@router.get("/getoptionproperties/")
+async def fastapi_get_option_properties(network: str) -> dict[str, Any]:
+    return get_option_v3(network)
+
+@router.post("/setoptionproperties/", response_model=None)
+async def fastapi_set_option_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_option_v3(network, ChangeSet(props))

app/api/v1/endpoints/components/patterns.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Request
+from typing import Any, List, Dict, Union
+from app.services.tjnetwork import *
+
+router = APIRouter()
+
+@router.get("/getpatternschema")
+async def fastapi_get_pattern_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pattern_schema(network)
+
+@router.post("/addpattern/", response_model=None)
+async def fastapi_add_pattern(network: str, pattern: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    ps = {
+        "id": pattern,
+    } | props
+    return add_pattern(network, ChangeSet(ps))
+
+@router.post("/deletepattern/", response_model=None)
+async def fastapi_delete_pattern(network: str, pattern: str) -> ChangeSet:
+    ps = {"id": pattern}
+    return delete_pattern(network, ChangeSet(ps))
+
+@router.get("/getpatternproperties/")
+async def fastapi_get_pattern_properties(network: str, pattern: str) -> dict[str, Any]:
+    return get_pattern(network, pattern)
+
+@router.post("/setpatternproperties/", response_model=None)
+async def fastapi_set_pattern_properties(
+    network: str, pattern: str, req: Request
+) -> ChangeSet:
+    props = await req.json()
+    ps = {"id": pattern} | props
+    return set_pattern(network, ChangeSet(ps))
+
+@router.get("/ispattern/")
+async def fastapi_is_pattern(network: str, pattern: str) -> bool:
+    return is_pattern(network, pattern)
+
+@router.get("/getpatterns/")
+async def fastapi_get_patterns(network: str) -> list[str]:
+    return get_patterns(network)

app/api/v1/endpoints/components/quality.py

@@ -0,0 +1,103 @@
+from fastapi import APIRouter, Request
+from typing import Any, List, Dict, Union
+from app.services.tjnetwork import *
+
+router = APIRouter()
+
+@router.get("/getqualityschema/")
+async def fastapi_get_quality_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_quality_schema(network)
+
+@router.get("/getqualityproperties/")
+async def fastapi_get_quality_properties(network: str, node: str) -> dict[str, Any]:
+    return get_quality(network, node)
+
+@router.post("/setqualityproperties/", response_model=None)
+async def fastapi_set_quality_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_quality(network, ChangeSet(props))
+
+@router.get("/getsourcechema/")
+async def fastapi_get_source_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_source_schema(network)
+
+@router.get("/getsource/")
+async def fastapi_get_source(network: str, node: str) -> dict[str, Any]:
+    return get_source(network, node)
+
+@router.post("/setsource/", response_model=None)
+async def fastapi_set_source(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_source(network, ChangeSet(props))
+
+@router.post("/addsource/", response_model=None)
+async def fastapi_add_source(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_source(network, ChangeSet(props))
+
+@router.post("/deletesource/", response_model=None)
+async def fastapi_delete_source(network: str, node: str) -> ChangeSet:
+    props = {"node": node}
+    return delete_source(network, ChangeSet(props))
+
+@router.get("/getreactionschema/")
+async def fastapi_get_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_reaction_schema(network)
+
+@router.get("/getreaction/")
+async def fastapi_get_reaction(network: str) -> dict[str, Any]:
+    return get_reaction(network)
+
+@router.post("/setreaction/", response_model=None)
+async def fastapi_set_reaction(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_reaction(network, ChangeSet(props))
+
+@router.get("/getpipereactionschema/")
+async def fastapi_get_pipe_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_pipe_reaction_schema(network)
+
+@router.get("/getpipereaction/")
+async def fastapi_get_pipe_reaction(network: str, pipe: str) -> dict[str, Any]:
+    return get_pipe_reaction(network, pipe)
+
+@router.post("/setpipereaction/", response_model=None)
+async def fastapi_set_pipe_reaction(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_pipe_reaction(network, ChangeSet(props))
+
+@router.get("/gettankreactionschema/")
+async def fastapi_get_tank_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_tank_reaction_schema(network)
+
+@router.get("/gettankreaction/")
+async def fastapi_get_tank_reaction(network: str, tank: str) -> dict[str, Any]:
+    return get_tank_reaction(network, tank)
+
+@router.post("/settankreaction/", response_model=None)
+async def fastapi_set_tank_reaction(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_tank_reaction(network, ChangeSet(props))
+
+@router.get("/getmixingschema/")
+async def fastapi_get_mixing_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_mixing_schema(network)
+
+@router.get("/getmixing/")
+async def fastapi_get_mixing(network: str, tank: str) -> dict[str, Any]:
+    return get_mixing(network, tank)
+
+@router.post("/setmixing/", response_model=None)
+async def fastapi_set_mixing(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return api.set_mixing(network, ChangeSet(props))
+
+@router.post("/addmixing/", response_model=None)
+async def fastapi_add_mixing(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_mixing(network, ChangeSet(props))
+
+@router.post("/deletemixing/", response_model=None)
+async def fastapi_delete_mixing(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_mixing(network, ChangeSet(props))

app/api/v1/endpoints/components/visuals.py

@@ -0,0 +1,76 @@
+from fastapi import APIRouter, Request, Response
+from typing import Any, List, Dict, Union
+from app.services.tjnetwork import *
+from fastapi.responses import PlainTextResponse
+import json
+
+router = APIRouter()
+
+@router.get("/getvertexschema/")
+async def fastapi_get_vertex_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_vertex_schema(network)
+
+@router.get("/getvertexproperties/")
+async def fastapi_get_vertex_properties(network: str, link: str) -> dict[str, Any]:
+    return get_vertex(network, link)
+
+@router.post("/setvertexproperties/", response_model=None)
+async def fastapi_set_vertex_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_vertex(network, ChangeSet(props))
+
+@router.post("/addvertex/", response_model=None)
+async def fastapi_add_vertex(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_vertex(network, ChangeSet(props))
+
+@router.post("/deletevertex/", response_model=None)
+async def fastapi_delete_vertex(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_vertex(network, ChangeSet(props))
+
+@router.get("/getallvertexlinks/", response_class=PlainTextResponse)
+async def fastapi_get_all_vertex_links(network: str) -> list[str]:
+    return json.dumps(get_all_vertex_links(network))
+
+@router.get("/getallvertices/", response_class=PlainTextResponse)
+async def fastapi_get_all_vertices(network: str) -> list[dict[str, Any]]:
+    return json.dumps(get_all_vertices(network))
+
+@router.get("/getlabelschema/")
+async def fastapi_get_label_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_label_schema(network)
+
+@router.get("/getlabelproperties/")
+async def fastapi_get_label_properties(
+    network: str, x: float, y: float
+) -> dict[str, Any]:
+    return get_label(network, x, y)
+
+@router.post("/setlabelproperties/", response_model=None)
+async def fastapi_set_label_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_label(network, ChangeSet(props))
+
+@router.post("/addlabel/", response_model=None)
+async def fastapi_add_label(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return add_label(network, ChangeSet(props))
+
+@router.post("/deletelabel/", response_model=None)
+async def fastapi_delete_label(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return delete_label(network, ChangeSet(props))
+
+@router.get("/getbackdropschema/")
+async def fastapi_get_backdrop_schema(network: str) -> dict[str, dict[str, Any]]:
+    return get_backdrop_schema(network)
+
+@router.get("/getbackdropproperties/")
+async def fastapi_get_backdrop_properties(network: str) -> dict[str, Any]:
+    return get_backdrop(network)
+
+@router.post("/setbackdropproperties/", response_model=None)
+async def fastapi_set_backdrop_properties(network: str, req: Request) -> ChangeSet:
+    props = await req.json()
+    return set_backdrop(network, ChangeSet(props))