671 lines
22 KiB
Python
671 lines
22 KiB
Python
from asyncio.windows_utils import pipe
|
|
import os
|
|
import io
|
|
from typing import *
|
|
from fastapi import FastAPI, File, UploadFile
|
|
from pydantic import BaseModel
|
|
from starlette.responses import FileResponse, JSONResponse
|
|
from fastapi import FastAPI, Response, status
|
|
from tjnetwork import *
|
|
|
|
JUNCTION = 0
|
|
RESERVOIR = 1
|
|
TANK = 2
|
|
PIPE = 1
|
|
NODE_COUNT = 0
|
|
LINK_COUNT = 2
|
|
|
|
prjs = []
|
|
inpDir = "C:/inpfiles/"
|
|
tmpDir = "C:/tmpfiles/"
|
|
|
|
lockedPrjs = {}
|
|
|
|
if not os.path.exists(inpDir):
|
|
os.mkdir(inpDir)
|
|
|
|
if not os.path.exists(tmpDir):
|
|
os.mkdir(tmpDir)
|
|
|
|
app = FastAPI()
|
|
|
|
# project operations
|
|
@app.get("/haveproject/")
|
|
async def fastapi_have_project(network: str):
|
|
return have_project(network)
|
|
|
|
@app.post("/createproject/")
|
|
async def fastapi_create_project(network: str):
|
|
create_project(network)
|
|
|
|
print(network)
|
|
return network
|
|
|
|
@app.get("/isprojectopen/")
|
|
async def fastapi_is_project_open(network: str):
|
|
return is_project_open(network)
|
|
|
|
@app.post("/openproject/")
|
|
async def fastapi_open_project(network: str):
|
|
open_project(network)
|
|
|
|
print(network)
|
|
return network
|
|
|
|
@app.post("/closeproject/")
|
|
async def fastapi_close_project(network: str):
|
|
close_project(network)
|
|
return True
|
|
|
|
@app.post("/deleteproject/")
|
|
async def fastapi_delete_project(network: str):
|
|
delete_project(network)
|
|
return True
|
|
|
|
@app.post("/copyproject/")
|
|
async def fastapi_copy_project(source: str, target: str):
|
|
copy_project(source, target)
|
|
return True
|
|
|
|
@app.get("/isprojectlocked/")
|
|
async def fastapi_is_locked(network: str):
|
|
return lockedPrjs.get(network) != None
|
|
|
|
@app.post("/lockproject/")
|
|
async def fastapi_lock_project(network: str, id: str):
|
|
lockedPrjs[network] = id
|
|
return True
|
|
|
|
@app.post("/unlockproject/")
|
|
async def fastapi_unlock_project(network: str, id: str):
|
|
if lockedPrjs[network] == id:
|
|
del lockedPrjs[network]
|
|
return True
|
|
|
|
# undo/redo
|
|
@app.post("/undo/")
|
|
async def fastapi_undo(network: str):
|
|
return execute_undo(network)
|
|
|
|
@app.post("/redo/")
|
|
async def fastapi_redo(network: str):
|
|
return execute_redo(network)
|
|
|
|
@app.get("/getcurrentoperationid/")
|
|
async def fastapi_get_current_operaiton_id(network: str) -> int:
|
|
return get_current_operation(network)
|
|
|
|
@app.get("/syncwithserver/")
|
|
def fastapi_sync_with_server(network: str, operationid: int) -> ChangeSet:
|
|
return sync_with_server(network, operationid)
|
|
|
|
# node
|
|
@app.get("/getnodes/")
|
|
async def fastapi_get_nodes(network: str) -> list[str]:
|
|
return get_nodes(network)
|
|
|
|
@app.get("/isnode/")
|
|
async def fastapi_is_node(network: str, node: str) -> bool:
|
|
return is_node(network, node)
|
|
|
|
@app.get("/isjunction/")
|
|
async def fastapi_is_junction(network: str, node: str) -> bool:
|
|
return is_junction(network, node)
|
|
|
|
@app.get("/isreservoir/")
|
|
async def fastapi_is_reservoir(network: str, node: str) -> bool:
|
|
return is_reservoir(network, node)
|
|
|
|
@app.get("/istank/")
|
|
async def fastapi_is_tank(network: str, node: str) -> bool:
|
|
return is_tank(network, node)
|
|
|
|
# link
|
|
@app.get("/getlinks/")
|
|
async def fastapi_get_links(network: str) -> list[str]:
|
|
return get_links(network)
|
|
|
|
@app.get("/islink/")
|
|
async def fastapi_is_link(network: str, link: str) -> bool:
|
|
return is_link(network, link)
|
|
|
|
@app.get("/ispipe/")
|
|
async def fastapi_is_pipe(network: str, link: str) -> bool:
|
|
return is_pipe(network, link)
|
|
|
|
@app.get("/ispump/")
|
|
async def fastapi_is_pump(network: str, link: str) -> bool:
|
|
return is_pump(network, link)
|
|
|
|
@app.get("/isvalve/")
|
|
async def is_valve(network: str, link: str) -> bool:
|
|
return is_valve(network, link)
|
|
|
|
# curve
|
|
@app.get("/getcurves/")
|
|
async def fastapi_get_curves(network: str) -> list[str]:
|
|
return get_curves(network)
|
|
|
|
@app.get("/iscurve/")
|
|
async def fastapi_is_curve(network: str, curve: str) -> bool:
|
|
return is_curve(network, curve)
|
|
|
|
# parttern
|
|
@app.get("/getpatterns/")
|
|
async def fastapi_get_patterns(network: str) -> list[str]:
|
|
return get_patterns(network)
|
|
|
|
@app.get("/ispattern/")
|
|
async def fastapi_is_curve(network: str, pattern: str) -> bool:
|
|
return is_pattern(network, pattern)
|
|
|
|
|
|
############################################################
|
|
# junction 2.[JUNCTIONS]
|
|
############################################################
|
|
@app.get('/getjunctionschema')
|
|
async def fast_get_junction_schema(network: str) -> dict[str, dict[str, Any]]:
|
|
return get_junction_schema(network)
|
|
|
|
@app.post("/addjunction/")
|
|
async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet:
|
|
return add_junction(network, junction, x, y, z)
|
|
|
|
@app.post("/deletejunction/")
|
|
async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet:
|
|
return delete_junction(network, junction)
|
|
|
|
@app.get("/getjunctionelevation/")
|
|
async def fastapi_get_junction_elevation(network: str, junction: str) -> float:
|
|
ps = get_junction(network, junction)
|
|
return ps['elevation']
|
|
|
|
@app.get("/getjunctioncoord/")
|
|
async def fastapi_get_junction_coord(network: str, junction: str) -> dict[str, float]:
|
|
ps = get_junction(network, junction)
|
|
return ps['coord']
|
|
|
|
@app.get("/getjunctiondemand/")
|
|
async def fastapi_get_junction_demand(network: str, junction: str) -> float:
|
|
ps = get_junction(network, junction)
|
|
return ps['demand']
|
|
|
|
@app.get("/getjunctionpattern/")
|
|
async def fastapi_get_junction_pattern(network: str, junction: str) -> str:
|
|
ps = get_junction(network, junction)
|
|
return ps['pattern']
|
|
|
|
@app.post("/setjunctionelevation/")
|
|
async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
|
|
props = {}
|
|
props['elevation'] = elevation
|
|
return set_junction(network, junction, props)
|
|
|
|
@app.post("/setjunctioncoord/")
|
|
async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
|
|
props = {}
|
|
props['coord'] = {'x' : x, 'y' : y}
|
|
return set_junction(network, junction, props)
|
|
|
|
@app.post("/setjunctiondemand/")
|
|
async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
|
|
props = {}
|
|
props['demand'] = demand
|
|
return set_junction(network, junction, props)
|
|
|
|
@app.post("/setjunctionpattern/")
|
|
async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
|
|
props = {}
|
|
props['pattern'] = pattern
|
|
return set_junction(network, junction, props)
|
|
|
|
@app.get("/getjunctionproperties/")
|
|
async def fastapi_get_junction_properties(network: str, junction: str) -> dict[str, Any]:
|
|
return get_junction(network, junction)
|
|
|
|
@app.post("/setjunctionproperties/")
|
|
async def fastapi_set_junction_properties(network: str, junction: str, props: dict[str, Any]) -> ChangeSet:
|
|
return set_junction(network, junction, props)
|
|
|
|
############################################################
|
|
# reservoir 3.[RESERVOIRS]
|
|
############################################################
|
|
@app.get('/getreservoirschema')
|
|
async def fast_get_reservoir_schema(network: str) -> dict[str, dict[str, Any]]:
|
|
return get_reservoir_schema(network)
|
|
|
|
@app.post("/addreservoir/")
|
|
async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet:
|
|
return add_reservoir(network, reservoir, x, y, head)
|
|
|
|
@app.post("/deletereservoir/")
|
|
async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet:
|
|
return delete_reservoir(network, reservoir)
|
|
|
|
@app.get("/getreservoirhead/")
|
|
async def fastapi_get_reservoir_head(network: str, reservoir: str) -> float | None:
|
|
ps = get_reservoir(network, reservoir)
|
|
return ps['head']
|
|
|
|
@app.get("/getreservoirpattern/")
|
|
async def fastapi_get_reservoir_pattern(network: str, reservoir: str) -> str | None:
|
|
ps = get_reservoir(network, reservoir)
|
|
return ps['pattern']
|
|
|
|
@app.get("/getreservoircoord/")
|
|
async def fastapi_get_reservoir_coord(network: str, reservoir: str) -> dict[str, float] | None:
|
|
ps = get_reservoir(network, reservoir)
|
|
return ps['coord']
|
|
|
|
@app.post("/setreservoirhead/")
|
|
async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet:
|
|
props = {}
|
|
props['head'] = head
|
|
return set_reservoir(network, reservoir, props)
|
|
|
|
@app.post("/setreservoirpattern/")
|
|
async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet:
|
|
props = {}
|
|
props['pattern'] = pattern
|
|
return set_reservoir(network, reservoir, props)
|
|
|
|
@app.post("/setreservoircoord/")
|
|
async def fastapi_set_reservoir_coord(network: str, reservoir: str, x: float, y: float) -> ChangeSet:
|
|
props = {}
|
|
props['coord'] = {'x' : x, 'y' : y}
|
|
return set_reservoir(network, reservoir, props)
|
|
|
|
@app.get("/getreservoirproperties/")
|
|
async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict[str, Any]:
|
|
return get_reservoir(network, reservoir)
|
|
|
|
@app.post("/setreservoirproperties/")
|
|
async def fastapi_set_reservoir_properties(network: str, reservoir: str, props: dict[str, Any]) -> ChangeSet:
|
|
return set_reservoir(network, reservoir, props)
|
|
|
|
|
|
############################################################
|
|
# tank 4.[TANKS]
|
|
############################################################
|
|
@app.get('/gettankschema')
|
|
async def fast_get_tank_schema(network: str) -> dict[str, dict[str, Any]]:
|
|
return get_tank_schema(network)
|
|
|
|
@app.post("/addtank/")
|
|
async def fastapi_add_tank(network: str, tank: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
|
|
return add_tank(network, tank, x, y, elevation, init_level, min_level, max_level, diameter, min_vol)
|
|
|
|
@app.post("/deletetank/")
|
|
async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet:
|
|
return delete_tank(network, tank)
|
|
|
|
@app.get("/gettankelevation/")
|
|
async def fastapi_get_tank_elevation(network: str, tank: str) -> float | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['elevation']
|
|
|
|
@app.get("/gettankinitlevel/")
|
|
async def fastapi_get_tank_init_level(network: str, tank: str) -> float | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['init_level']
|
|
|
|
@app.get("/gettankminlevel/")
|
|
async def fastapi_get_tank_min_level(network: str, tank: str) -> float | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['min_level']
|
|
|
|
@app.get("/gettankmaxlevel/")
|
|
async def fastapi_get_tank_max_level(network: str, tank: str) -> float | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['max_level']
|
|
|
|
@app.get("/gettankdiameter/")
|
|
async def fastapi_get_tank_diameter(network: str, tank: str) -> float | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['diameter']
|
|
|
|
@app.get("/gettankminvol/")
|
|
async def fastapi_get_tank_min_vol(network: str, tank: str) -> float | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['min_vol']
|
|
|
|
@app.get("/gettankvolcurve/")
|
|
async def fastapi_get_tank_vol_curve(network: str, tank: str) -> str | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['vol_curve']
|
|
|
|
@app.get("/gettankoverflow/")
|
|
async def fastapi_get_tank_overflow(network: str, tank: str) -> str | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['overflow']
|
|
|
|
@app.get("/gettankcoord/")
|
|
async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float] | None:
|
|
ps = get_tank(network, tank)
|
|
return ps['coord']
|
|
|
|
@app.post("/settankelevation/")
|
|
async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
|
|
props = {}
|
|
props['elevation'] = elevation
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("/settankinitlevel/")
|
|
async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet:
|
|
props = {}
|
|
props['init_level'] = init_level
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("/settankminlevel/")
|
|
async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet:
|
|
props = {}
|
|
props['min_level'] = min_level
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("/settankmaxlevel/")
|
|
async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet:
|
|
props = {}
|
|
props['max_level'] = max_level
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("settankdiameter//")
|
|
async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet:
|
|
props = {}
|
|
props['diameter'] = diameter
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("/settankminvol/")
|
|
async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet:
|
|
props = {}
|
|
props['min_vol'] = min_vol
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("/settankvolcurve/")
|
|
async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet:
|
|
props = {}
|
|
props['vol_curve'] = vol_curve
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("/settankoverflow/")
|
|
async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet:
|
|
props = {}
|
|
props['overflow'] = overflow
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.post("/settankcoord/")
|
|
async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet:
|
|
props = {}
|
|
props['coord'] = {'x' : x, 'y' : y}
|
|
return set_tank(network, tank, props)
|
|
|
|
@app.get("/gettankproperties/")
|
|
async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]:
|
|
return get_tank(network, tank)
|
|
|
|
@app.post("/settankproperties/")
|
|
async def fastapi_set_tank_properties(network: str, tank: str, props: dict[str, Any]) -> ChangeSet:
|
|
return set_tank(network, tank, props)
|
|
|
|
|
|
############################################################
|
|
# pipe 4.[PIPES]
|
|
############################################################
|
|
@app.get('/getpipeschema')
|
|
async def fast_get_pipe_schema(network: str) -> dict[str, dict[str, Any]]:
|
|
return get_pipe_schema(network)
|
|
|
|
@app.post("/addpipe/")
|
|
async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, length: float = 0, diameter: float = 0, roughness: float = 0, minorloss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
|
|
return add_pipe(network, pipe, node1, node2, length, diameter, roughness, minorloss, status)
|
|
|
|
@app.post("/deletepipe/")
|
|
async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
|
|
return delete_pipe(network, pipe)
|
|
|
|
@app.get("/getpipenode1/")
|
|
async def fastapi_get_pipe_node1(network: str, pipe: str) -> str | None:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['node1']
|
|
|
|
@app.get("/getpipenode2/")
|
|
async def fastapi_get_pipe_node2(network: str, pipe: str) -> str | None:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['node2']
|
|
|
|
@app.get("/getpipelength/")
|
|
async def fastapi_get_pipe_length(network: str, pipe: str) -> float | None:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['length']
|
|
|
|
@app.get("/getpipediameter/")
|
|
async def fastapi_get_pipe_diameter(network: str, pipe: str) -> float | None:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['diameter']
|
|
|
|
@app.get("/getpiperoughness/")
|
|
async def fastapi_get_pipe_roughness(network: str, pipe: str) -> float | None:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['roughness']
|
|
|
|
@app.get("/getpipeminorloss/")
|
|
async def fastapi_get_pipe_minor_loss(network: str, pipe: str) -> float | None:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['minor_loss']
|
|
|
|
@app.get("/getpipestatus/")
|
|
async def fastapi_get_pipe_status(network: str, pipe: str) -> str | None:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['status']
|
|
|
|
@app.post("/setpipenode1/")
|
|
async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['node1']
|
|
|
|
@app.post("/setpipenode2/")
|
|
async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
|
|
ps = get_pipe(network, pipe)
|
|
return ps['node2']
|
|
|
|
@app.post("/setpipelength/")
|
|
async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
|
|
props = {}
|
|
props['length'] = length
|
|
return set_pipe(network, pipe, props)
|
|
|
|
@app.post("/setpipediameter/")
|
|
async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
|
|
props = {}
|
|
props['diameter'] = diameter
|
|
return set_pipe(network, pipe, props)
|
|
|
|
@app.post("/setpiperoughness/")
|
|
async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
|
|
props = {}
|
|
props['roughness'] = roughness
|
|
return set_pipe(network, pipe, props)
|
|
|
|
@app.post("/setpipeminorloss/")
|
|
async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
|
|
props = {}
|
|
props['minor_loss'] = minor_loss
|
|
return set_pipe(network, pipe, props)
|
|
|
|
@app.post("/setpipestatus/")
|
|
async def fastapi_set_pipe_status(network: str, pipe: str, status: float) -> ChangeSet:
|
|
props = {}
|
|
props['status'] = status
|
|
return set_pipe(network, pipe, props)
|
|
|
|
@app.get("/getpipeproperties/")
|
|
async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]:
|
|
return get_pipe(network, pipe)
|
|
|
|
@app.post("/setpipeproperties/")
|
|
async def fastapi_set_pipe_properties(network: str, pipe: str, props: dict[str, Any]) -> ChangeSet:
|
|
return set_pipe(network, pipe, props)
|
|
|
|
|
|
############################################################
|
|
# pump 4.[PUMPS]
|
|
############################################################
|
|
@app.get('/getpumpschema')
|
|
async def fast_get_pump_schema(network: str) -> dict[str, dict[str, Any]]:
|
|
return get_pump_schema(network)
|
|
|
|
@app.post("/addpump/")
|
|
async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str) -> ChangeSet:
|
|
return add_pump(network, pump, node1, node2)
|
|
|
|
@app.post("/deletepump/")
|
|
async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet:
|
|
return delete_pump(network, pump)
|
|
|
|
@app.get("/getpumpnode1/")
|
|
async def fastapi_get_pump_node1(network: str, pump: str) -> str | None:
|
|
ps = get_pump(network, pump)
|
|
return ps['node1']
|
|
|
|
@app.get("/getpumpnode2/")
|
|
async def fastapi_get_pump_node2(network: str, pump: str) -> str | None:
|
|
ps = get_pump(network, pump)
|
|
return ps['node2']
|
|
|
|
@app.post("/setpumpnode1/")
|
|
async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
|
|
props = {}
|
|
props['node1'] = node1
|
|
return set_pump(network, pump, props)
|
|
|
|
@app.post("/setpumpnode2/")
|
|
async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet:
|
|
props = {}
|
|
props['node2'] = node2
|
|
return set_pump(network, pump, props)
|
|
|
|
@app.get("/getpumpproperties/")
|
|
async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]:
|
|
return get_pump(network, pump)
|
|
|
|
@app.post("/setpumpproperties/")
|
|
async def fastapi_set_pump_properties(network: str, pump: str, props: dict[str, Any]) -> ChangeSet:
|
|
return set_pump(network, pump, props)
|
|
|
|
|
|
############################################################
|
|
# valve 4.[VALVES]
|
|
############################################################
|
|
@app.get('/getvalveschema')
|
|
async def fast_get_valve_schema(network: str) -> dict[str, dict[str, Any]]:
|
|
return get_valve_schema(network)
|
|
|
|
@app.post("/addvalve/")
|
|
async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, diameter: float = 0, type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
|
|
return add_valve(network, valve, node1, node2, diameter, type, setting, minor_loss)
|
|
|
|
@app.post("/deletevalve/")
|
|
async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet:
|
|
return delete_valve(network, valve)
|
|
|
|
@app.get("/getvalvenode1/")
|
|
async def fastapi_get_valve_node1(network: str, valve: str) -> str | None:
|
|
ps = get_valve(network, valve)
|
|
return ps['node1']
|
|
|
|
@app.get("/getvalvenode2/")
|
|
async def fastapi_get_valve_node2(network: str, valve: str) -> str | None:
|
|
ps = get_valve(network, valve)
|
|
return ps['node2']
|
|
|
|
@app.get("/getvalvediameter/")
|
|
async def fastapi_get_valve_diameter(network: str, valve: str) -> float | None:
|
|
ps = get_valve(network, valve)
|
|
return ps['diameter']
|
|
|
|
@app.get("/getvalvetype/")
|
|
async def fastapi_get_valve_type(network: str, valve: str) -> str | None:
|
|
ps = get_valve(network, valve)
|
|
return ps['type']
|
|
|
|
@app.get("/getvalvesetting/")
|
|
async def fastapi_get_valve_setting(network: str, valve: str) -> float | None:
|
|
ps = get_valve(network, valve)
|
|
return ps['setting']
|
|
|
|
@app.get("/getvalveminorloss/")
|
|
async def fastapi_get_valve_minor_loss(network: str, valve: str) -> float | None:
|
|
ps = get_valve(network, valve)
|
|
return ps['minor_loss']
|
|
|
|
@app.post("/setvalvenode1/")
|
|
async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet:
|
|
props = {}
|
|
props['node1'] = node1
|
|
return set_valve(network, valve, props)
|
|
|
|
@app.post("/setvalvenode2/")
|
|
async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet:
|
|
props = {}
|
|
props['node2'] = node2
|
|
return set_valve(network, valve, props)
|
|
|
|
@app.post("/setvalvenodediameter/")
|
|
async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet:
|
|
props = {}
|
|
props['diameter'] = diameter
|
|
return set_valve(network, valve, props)
|
|
|
|
@app.post("/setvalvetype/")
|
|
async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet:
|
|
props = {}
|
|
props['type'] = type
|
|
return set_valve(network, valve, props)
|
|
|
|
@app.post("/setvalvesetting/")
|
|
async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet:
|
|
props = {}
|
|
props['setting'] = setting
|
|
return set_valve(network, valve, props)
|
|
|
|
@app.get("/getvalveproperties/")
|
|
async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, Any]:
|
|
return get_valve(network, valve)
|
|
|
|
@app.post("/setvalveproperties/")
|
|
async def fastapi_set_valve_properties(network: str, valve: str, props: dict[str, Any]) -> ChangeSet:
|
|
return set_valve(network, valve, props)
|
|
|
|
|
|
|
|
# inp file
|
|
@app.post("/uploadinp/", status_code=status.HTTP_200_OK)
|
|
async def upload_inp(file: bytes = File(), name: str = None):
|
|
filePath = inpDir + str(name)
|
|
f = open(filePath, 'wb')
|
|
f.write(file)
|
|
f.close()
|
|
|
|
return True
|
|
|
|
@app.get("/downloadinp/", status_code=status.HTTP_200_OK)
|
|
async def download_inp(name: str, response: Response):
|
|
filePath = inpDir + name
|
|
if os.path.exists(filePath):
|
|
return FileResponse(filePath, media_type='application/octet-stream', filename="inp.inp")
|
|
else:
|
|
response.status_code = status.HTTP_400_BAD_REQUEST
|
|
return True
|
|
|
|
@app.get("/getjson/")
|
|
async def get_json():
|
|
return JSONResponse(
|
|
status_code = status.HTTP_400_BAD_REQUEST,
|
|
content={
|
|
'code': 400,
|
|
'message': "this is message",
|
|
'data': 123,
|
|
}
|
|
)
|
|
|
|
|