2023 lines
76 KiB
Python
2023 lines
76 KiB
Python
import os
|
||
import io
|
||
import json
|
||
import time
|
||
from typing import *
|
||
from urllib.request import Request
|
||
from xml.dom import minicompat
|
||
from pydantic import BaseModel
|
||
from starlette.responses import FileResponse, JSONResponse
|
||
from fastapi import FastAPI, File, UploadFile, Response, status, Request, Body, HTTPException
|
||
from fastapi.responses import PlainTextResponse
|
||
from fastapi.middleware.gzip import GZipMiddleware
|
||
from tjnetwork import *
|
||
import asyncio
|
||
import threading
|
||
import uvicorn
|
||
from multiprocessing import Value
|
||
from fastapi.middleware.cors import CORSMiddleware
|
||
import random
|
||
import logging
|
||
import redis
|
||
import datetime
|
||
from influxdb_client import InfluxDBClient, BucketsApi, WriteApi, OrganizationsApi, Point, QueryApi
|
||
from typing import List, Dict
|
||
from datetime import datetime, timedelta, timezone
|
||
from dateutil import parser
|
||
import influxdb_api
|
||
|
||
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()
|
||
|
||
# 初始化 Redis 连接
|
||
# 用redis 限制并发访u
|
||
redis_client = redis.Redis(host="localhost", port=6379, db=0)
|
||
|
||
# influxdb数据库连接信息
|
||
influx_url = "http://localhost:8086" # 替换为你的InfluxDB实例地址
|
||
influx_token = "xGDM5RZqRJAuzAGS-otXUdC2NFdY75qJAjRLqAB4p5WcIIAlIUpOpT8_yA16AOHmJWerwQ_08gwb84sy42jnZQ==" # 替换为你的InfluxDB Token
|
||
influx_org_name = "TJWATERORG" # 替换为你的Organization名称
|
||
influx_client = InfluxDBClient(url=influx_url, token=influx_token, org=influx_org_name)
|
||
|
||
# 配置日志记录器
|
||
logging.basicConfig(level=logging.INFO)
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# 配置 CORS 中间件
|
||
app.add_middleware(
|
||
CORSMiddleware,
|
||
allow_origins=["*"], # 允许所有来源
|
||
allow_credentials=True, # 允许传递凭证（Cookie、HTTP 头等）
|
||
allow_methods=["*"], # 允许所有 HTTP 方法
|
||
allow_headers=["*"], # 允许所有 HTTP 头
|
||
)
|
||
# 定义一个共享变量
|
||
lock_simulation = Value('i', 0)
|
||
|
||
app.add_middleware(GZipMiddleware, minimum_size=1000)
|
||
|
||
@app.on_event("startup")
|
||
async def startup_db():
|
||
logger.info('\n')
|
||
logger.info('**********************************************************')
|
||
logger.info(str(datetime.now()))
|
||
logger.info("TJWater CloudService is starting...")
|
||
logger.info('**********************************************************')
|
||
logger.info('\n')
|
||
|
||
############################################################
|
||
# extension_data
|
||
############################################################
|
||
@app.get('/getallextensiondatakeys/')
|
||
async def fastapi_get_all_extension_data_keys(network: str) -> list[str]:
|
||
return get_all_extension_data_keys(network)
|
||
|
||
@app.get('/getallextensiondata/')
|
||
async def fastapi_get_all_extension_data(network: str) -> dict[str, Any]:
|
||
return get_all_extension_data(network)
|
||
|
||
@app.get('/getextensiondata/')
|
||
async def fastapi_get_extension_data(network: str, key: str) -> str | None:
|
||
return get_extension_data(network, key)
|
||
|
||
@app.post('/setextensiondata',response_model=None)
|
||
async def fastapi_set_extension_data(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
print(props)
|
||
cs = set_extension_data(network, ChangeSet(props))
|
||
print(cs.operations[0])
|
||
return cs
|
||
|
||
############################################################
|
||
# project
|
||
############################################################
|
||
|
||
@app.get('/listprojects/')
|
||
async def fastapi_list_projects() -> list[str]:
|
||
return list_project()
|
||
|
||
@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)
|
||
return network
|
||
|
||
@app.post("/deleteproject/")
|
||
async def fastapi_delete_project(network: str):
|
||
delete_project(network)
|
||
return True
|
||
|
||
@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)
|
||
return network
|
||
|
||
@app.post("/closeproject/")
|
||
async def fastapi_close_project(network: str):
|
||
close_project(network)
|
||
return True
|
||
|
||
@app.post("/copyproject/")
|
||
async def fastapi_copy_project(source: str, target: str):
|
||
copy_project(source, target)
|
||
return True
|
||
|
||
@app.post("/importinp/")
|
||
async def fastapi_import_inp(network: str, req: Request):
|
||
jo_root = await req.json()
|
||
inp_text = jo_root['inp']
|
||
ps = {
|
||
"inp" : inp_text
|
||
}
|
||
ret = import_inp(network, ChangeSet(ps))
|
||
print(ret)
|
||
return ret
|
||
|
||
@app.get("/exportinp/",response_model=None)
|
||
async def fastapi_export_inp(network: str, version: str) -> ChangeSet:
|
||
cs = export_inp(network, version)
|
||
op = cs.operations[0]
|
||
open_project(network)
|
||
op['vertex'] = json.dumps(get_all_vertices(network))
|
||
op['scada'] = json.dumps(get_all_scada_elements(network))
|
||
op['dma'] = json.dumps(get_all_district_metering_areas(network))
|
||
op['sa'] = json.dumps(get_all_service_areas(network))
|
||
op['vd'] = json.dumps(get_all_virtual_districts(network))
|
||
op['legend'] = get_extension_data(network, 'legend')
|
||
|
||
db = get_extension_data(network, 'scada_db')
|
||
print(db)
|
||
scada_db = ''
|
||
if db:
|
||
scada_db = db
|
||
print(scada_db)
|
||
op['scada_db'] = scada_db
|
||
|
||
close_project(network)
|
||
|
||
return cs
|
||
|
||
@app.post("/readinp/")
|
||
async def fastapi_read_inp(network: str, inp: str) -> bool:
|
||
read_inp(network, inp)
|
||
return True
|
||
|
||
@app.get("/dumpinp/")
|
||
async def fastapi_dump_inp(network: str, inp: str) -> bool:
|
||
dump_inp(network, inp)
|
||
return True
|
||
|
||
# 必须用这个PlainTextResponse，不然每个key都有引号
|
||
@app.get("/runproject/", response_class = PlainTextResponse)
|
||
async def fastapi_run_project(network: str) -> str:
|
||
lock_key = "exclusive_api_lock"
|
||
timeout = 120 # 锁自动过期时间（秒）
|
||
|
||
# 尝试获取锁（NX=True: 不存在时设置，EX=timeout: 过期时间）
|
||
acquired = redis_client.set(lock_key, "locked", nx=True, ex=timeout)
|
||
|
||
logger.info(f"acquired : {acquired}")
|
||
|
||
if not acquired:
|
||
raise HTTPException(status_code=409, detail="is in simulation")
|
||
else:
|
||
try:
|
||
return run_project(network)
|
||
finally:
|
||
# 手动释放锁（可选，依赖过期时间自动释放更安全）
|
||
redis_client.delete(lock_key)
|
||
|
||
# DingZQ, 2025-02-04, 返回dict[str, Any]
|
||
# output 和 report
|
||
# output 是 json
|
||
# report 是 text
|
||
@app.get("/runprojectreturndict/")
|
||
async def fastapi_run_project_return_dict(network: str) -> dict[str, Any]:
|
||
lock_key = "exclusive_api_lock"
|
||
timeout = 120 # 锁自动过期时间（秒）
|
||
|
||
# 尝试获取锁（NX=True: 不存在时设置，EX=timeout: 过期时间）
|
||
acquired = redis_client.set(lock_key, "locked", nx=True, ex=timeout)
|
||
|
||
logger.info(f"acquired : {acquired}")
|
||
|
||
if not acquired:
|
||
raise HTTPException(status_code=409, detail="is in simulation")
|
||
else:
|
||
try:
|
||
return run_project_return_dict(network)
|
||
finally:
|
||
# 手动释放锁（可选，依赖过期时间自动释放更安全）
|
||
redis_client.delete(lock_key)
|
||
|
||
|
||
# put in inp folder, name without extension
|
||
@app.get("/runinp/")
|
||
async def fastapi_run_inp(network: str) -> str:
|
||
return run_inp(network)
|
||
|
||
# path is absolute path
|
||
@app.get("/dumpoutput/")
|
||
async def fastapi_dump_output(output: str) -> str:
|
||
return dump_output(output)
|
||
|
||
@app.get("/isprojectlocked/")
|
||
async def fastapi_is_locked(network: str, req: Request):
|
||
return str in lockedPrjs.keys()
|
||
|
||
@app.get("/isprojectlockedbyme/")
|
||
async def fastapi_is_locked_by_me(network: str, req: Request):
|
||
client_host = req.client.host
|
||
return lockedPrjs.get(network) == client_host
|
||
|
||
# 0 successfully locked
|
||
# 1 already locked by you
|
||
# 2 locked by others
|
||
@app.post("/lockproject/")
|
||
async def fastapi_lock_project(network: str, req: Request):
|
||
client_host = req.client.host
|
||
if not network in lockedPrjs.keys():
|
||
lockedPrjs[network] = client_host
|
||
return 0
|
||
else:
|
||
if lockedPrjs.get(network) == client_host:
|
||
return 1
|
||
else:
|
||
return 2
|
||
|
||
@app.post("/unlockproject/")
|
||
def fastapi_unlock_project(network: str, req: Request):
|
||
client_host = req.client.host
|
||
if lockedPrjs[network] == client_host:
|
||
print("delete key")
|
||
del lockedPrjs[network]
|
||
return True
|
||
|
||
return False
|
||
|
||
### operations
|
||
|
||
@app.get('/getcurrentoperationid/')
|
||
async def fastapi_get_current_operaiton_id(network: str) -> int:
|
||
return get_current_operation(network)
|
||
|
||
@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('/getsnapshots/')
|
||
def fastapi_list_snapshot(network: str) -> list[tuple[int, str]]:
|
||
return list_snapshot(network)
|
||
|
||
@app.get('/havesnapshot/')
|
||
async def fastapi_have_snapshot(network: str, tag: str) -> bool:
|
||
return have_snapshot(network, tag)
|
||
|
||
@app.get('/havesnapshotforoperation/')
|
||
async def fastapi_have_snapshot_for_operation(network: str, operation: int) -> bool:
|
||
return have_snapshot_for_operation(network, operation)
|
||
|
||
@app.get('/havesnapshotforcurrentoperation/')
|
||
async def fastapi_have_snapshot_for_current_operation(network: str) -> bool:
|
||
return have_snapshot_for_current_operation(network)
|
||
|
||
@app.post('/takesnapshotforoperation/')
|
||
async def fastapi_take_snapshot_for_operation(network: str, operation: int, tag: str) -> None:
|
||
return take_snapshot_for_operation(network, operation, tag)
|
||
|
||
@app.post('takenapshotforcurrentoperation')
|
||
async def fastapi_take_snapshot_for_current_operation(network: str, tag: str) -> None:
|
||
return take_snapshot_for_current_operation(network, tag)
|
||
|
||
@app.post('/takesnapshot/')
|
||
def fastapi_take_snapshot(network: str, tag: str) -> None:
|
||
return take_snapshot(network, tag)
|
||
|
||
@app.post('/picksnapshot/',response_model=None)
|
||
def fastapi_pick_snapshot(network: str, tag: str, discard: bool = False) -> ChangeSet:
|
||
return pick_snapshot(network, tag, discard)
|
||
|
||
@app.post('/pickoperation/',response_model=None)
|
||
async def fastapi_pick_operation(network: str, operation: int, discard: bool = False) -> ChangeSet:
|
||
return pick_operation(network, operation, discard)
|
||
|
||
@app.get("/syncwithserver/",response_model=None)
|
||
async def fastapi_sync_with_server(network: str, operation: int) -> ChangeSet:
|
||
return sync_with_server(network, operation)
|
||
|
||
@app.post("/batch/",response_model=None)
|
||
async def fastapi_execute_batch_commands(network: str, req: Request)-> ChangeSet:
|
||
jo_root = await req.json()
|
||
cs: ChangeSet = ChangeSet()
|
||
cs.operations = jo_root['operations']
|
||
rcs = execute_batch_commands(network, cs)
|
||
return rcs
|
||
|
||
@app.post("/compressedbatch/",response_model=None)
|
||
async def fastapi_execute_compressed_batch_commands(network: str, req: Request)-> ChangeSet:
|
||
jo_root = await req.json()
|
||
cs: ChangeSet = ChangeSet()
|
||
cs.operations = jo_root['operations']
|
||
return execute_batch_command(network, cs)
|
||
|
||
@app.get("/getrestoreoperation/")
|
||
async def fastapi_get_restore_operation(network : str) -> int:
|
||
return get_restore_operation(network)
|
||
|
||
@app.post("/setrestoreoperation/")
|
||
async def fastapi_set_restore_operation(network: str, operation: int) -> None:
|
||
return set_restore_operation(network, operation)
|
||
|
||
############################################################
|
||
# type
|
||
############################################################
|
||
|
||
@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)
|
||
|
||
@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 fastapi_is_valve(network: str, link: str) -> bool:
|
||
return is_valve(network, link)
|
||
|
||
@app.get('/iscurve/')
|
||
async def fastapi_is_curve(network: str, curve: str) -> bool:
|
||
return is_curve(network, curve)
|
||
|
||
@app.get('/ispattern/')
|
||
async def fastapi_is_pattern(network: str, pattern: str) -> bool:
|
||
return is_pattern(network, pattern)
|
||
|
||
@app.get("/getnodes/")
|
||
async def fastapi_get_nodes(network: str) -> list[str]:
|
||
return get_nodes(network)
|
||
|
||
@app.get("/getlinks/")
|
||
async def fastapi_get_links(network: str) -> list[str]:
|
||
return get_links(network)
|
||
|
||
@app.get("/getcurves/")
|
||
async def fastapi_get_curves(network: str) -> list[str]:
|
||
return get_curves(network)
|
||
|
||
@app.get("/getpatterns/")
|
||
async def fastapi_get_patterns(network: str) -> list[str]:
|
||
return get_patterns(network)
|
||
|
||
@app.get("/getnodelinks/")
|
||
def get_node_links(network: str, node: str) -> list[str]:
|
||
return get_node_links(network, node)
|
||
|
||
############################################################
|
||
# title 1.[TITLE]
|
||
############################################################
|
||
@app.get('/gettitleschema/')
|
||
async def fast_get_title_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_title_schema(network)
|
||
|
||
@app.get('/gettitle/')
|
||
async def fast_get_title(network: str) -> dict[str, Any]:
|
||
return get_title(network)
|
||
|
||
@app.get('/settitle/',response_model=None)
|
||
async def fastapi_set_title(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_title(network, ChangeSet(props))
|
||
|
||
############################################################
|
||
# 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/",response_model=None)
|
||
async def fastapi_add_junction(network: str, junction: str, x: float, y: float, z: float) -> ChangeSet:
|
||
ps = { 'id' : junction,
|
||
'x' : x,
|
||
'y' : y,
|
||
'elevation' : z }
|
||
return add_junction(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletejunction/",response_model=None)
|
||
async def fastapi_delete_junction(network: str, junction: str) -> ChangeSet:
|
||
ps = {'id' : junction}
|
||
return delete_junction(network, ChangeSet(ps))
|
||
|
||
@app.get("/getjunctionelevation/")
|
||
async def fastapi_get_junction_elevation(network: str, junction: str) -> float:
|
||
ps = get_junction(network, junction)
|
||
return ps['elevation']
|
||
|
||
@app.get("/getjunctionx/")
|
||
async def fastapi_get_junction_x(network: str, junction: str) -> float:
|
||
ps = get_junction(network, junction)
|
||
return ps['x']
|
||
|
||
@app.get("/getjunctiony/")
|
||
async def fastapi_get_junction_x(network: str, junction: str) -> float:
|
||
ps = get_junction(network, junction)
|
||
return ps['y']
|
||
|
||
@app.get("/getjunctioncoord/")
|
||
async def fastapi_get_junction_coord(network: str, junction: str) -> dict[str, float]:
|
||
ps = get_junction(network, junction)
|
||
coord = { 'x' : ps['x'],
|
||
'y' : ps['y'] }
|
||
return 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/",response_model=None)
|
||
async def fastapi_set_junction_elevation(network: str, junction: str, elevation: float) -> ChangeSet:
|
||
ps = { 'id' : junction,
|
||
'elevation' : elevation }
|
||
return set_junction(network, ChangeSet(ps))
|
||
|
||
@app.post("/setjunctionx/",response_model=None)
|
||
async def fastapi_set_junction_x(network: str, junction: str, x: float) -> ChangeSet:
|
||
ps = { 'id' : junction,
|
||
'x' : x }
|
||
return set_junction(network, ChangeSet(ps))
|
||
|
||
@app.post("/setjunctiony/",response_model=None)
|
||
async def fastapi_set_junction_y(network: str, junction: str, y: float) -> ChangeSet:
|
||
ps = { 'id' : junction,
|
||
'y' : y }
|
||
return set_junction(network, ChangeSet(ps))
|
||
|
||
@app.post("/setjunctioncoord/",response_model=None)
|
||
async def fastapi_set_junction_coord(network: str, junction: str, x: float, y: float) -> ChangeSet:
|
||
ps = { 'id' : junction,
|
||
'x' : x,
|
||
'y' : y }
|
||
return set_junction(network, ChangeSet(ps))
|
||
|
||
@app.post("/setjunctiondemand/",response_model=None)
|
||
async def fastapi_set_junction_demand(network: str, junction: str, demand: float) -> ChangeSet:
|
||
ps = { 'id' : junction,
|
||
'demand' : demand }
|
||
return set_junction(network, ChangeSet(ps))
|
||
|
||
@app.post("/setjunctionpattern/",response_model=None)
|
||
async def fastapi_set_junction_pattern(network: str, junction: str, pattern: str) -> ChangeSet:
|
||
ps = { 'id' : junction,
|
||
'pattern' : pattern }
|
||
return set_junction(network, ChangeSet(ps))
|
||
|
||
@app.get("/getjunctionproperties/")
|
||
async def fastapi_get_junction_properties(network: str, junction: str) -> dict[str, Any]:
|
||
return get_junction(network, junction)
|
||
|
||
@app.post("/setjunctionproperties/",response_model=None)
|
||
async def fastapi_set_junction_properties(network: str, junction: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'id' : junction } | props
|
||
return set_junction(network, ChangeSet(ps))
|
||
|
||
############################################################
|
||
# 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/",response_model=None)
|
||
async def fastapi_add_reservoir(network: str, reservoir: str, x: float, y: float, head: float) -> ChangeSet:
|
||
ps = { 'id' : reservoir,
|
||
'x' : x,
|
||
'y' : y,
|
||
'head' : head }
|
||
return add_reservoir(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletereservoir/",response_model=None)
|
||
async def fastapi_delete_reservoir(network: str, reservoir: str) -> ChangeSet:
|
||
ps = { 'id' : reservoir }
|
||
return delete_reservoir(network, ChangeSet(ps))
|
||
|
||
@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("/getreservoirx/")
|
||
async def fastapi_get_reservoir_x(network: str, reservoir: str) -> dict[str, float] | None:
|
||
ps = get_reservoir(network, reservoir)
|
||
return ps['x']
|
||
|
||
@app.get("/getreservoiry/")
|
||
async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, float] | None:
|
||
ps = get_reservoir(network, reservoir)
|
||
return ps['y']
|
||
|
||
@app.get("/getreservoircoord/")
|
||
async def fastapi_get_reservoir_y(network: str, reservoir: str) -> dict[str, float] | None:
|
||
ps = get_reservoir(network, reservoir)
|
||
coord = { 'id' : reservoir,
|
||
'x' : ps['x'],
|
||
'y' : ps['y'] }
|
||
return coord
|
||
|
||
@app.post("/setreservoirhead/",response_model=None)
|
||
async def fastapi_set_reservoir_head(network: str, reservoir: str, head: float) -> ChangeSet:
|
||
ps = { 'id' : reservoir,
|
||
'head' : head }
|
||
return set_reservoir(network, ChangeSet(ps))
|
||
|
||
@app.post("/setreservoirpattern/",response_model=None)
|
||
async def fastapi_set_reservoir_pattern(network: str, reservoir: str, pattern: str) -> ChangeSet:
|
||
ps = { 'id' : reservoir,
|
||
'pattern' : pattern }
|
||
return set_reservoir(network, ChangeSet(ps))
|
||
|
||
@app.post("/setreservoirx/",response_model=None)
|
||
async def fastapi_set_reservoir_x(network: str, reservoir: str, x: float) -> ChangeSet:
|
||
ps = { 'id' : reservoir,
|
||
'x' : x }
|
||
return set_reservoir(network, ChangeSet(ps))
|
||
|
||
@app.post("/setreservoirx/",response_model=None)
|
||
async def fastapi_set_reservoir_y(network: str, reservoir: str, y: float) -> ChangeSet:
|
||
ps = { 'id' : reservoir,
|
||
'y' : y }
|
||
return set_reservoir(network, ChangeSet(ps))
|
||
|
||
@app.post("/setreservoircoord/",response_model=None)
|
||
async def fastapi_set_reservoir_y(network: str, reservoir: str, x: float, y: float) -> ChangeSet:
|
||
ps = { 'id' : reservoir,
|
||
'x' : x,
|
||
'y' : y }
|
||
return set_reservoir(network, ChangeSet(ps))
|
||
|
||
@app.get("/getreservoirproperties/")
|
||
async def fastapi_get_reservoir_properties(network: str, reservoir: str) -> dict[str, Any]:
|
||
return get_reservoir(network, reservoir)
|
||
|
||
@app.post("/setreservoirproperties/",response_model=None)
|
||
async def fastapi_set_reservoir_properties(network: str, reservoir: str
|
||
, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'id' : reservoir } | props
|
||
return set_reservoir(network, ChangeSet(ps))
|
||
|
||
|
||
############################################################
|
||
# 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/",response_model=None)
|
||
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:
|
||
ps = { 'id' : tank,
|
||
'x' : x,
|
||
'y' : y,
|
||
'elevation' : elevation,
|
||
'init_level' : init_level,
|
||
'min_level' : min_level,
|
||
'max_level' : max_level,
|
||
'diameter' : diameter,
|
||
'min_vol' : min_vol
|
||
}
|
||
return add_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletetank/",response_model=None)
|
||
async def fastapi_delete_tank(network: str, tank: str) -> ChangeSet:
|
||
ps = { 'id' : tank }
|
||
return delete_tank(network, ChangeSet(ps))
|
||
|
||
@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("/gettankx/")
|
||
async def fastapi_get_tank_x(network: str, tank: str) -> float:
|
||
ps = get_tank(network, tank)
|
||
return ps['x']
|
||
|
||
@app.get("/gettanky/")
|
||
async def fastapi_get_tank_x(network: str, tank: str) -> float:
|
||
ps = get_tank(network, tank)
|
||
return ps['y']
|
||
|
||
@app.get("/gettankcoord/")
|
||
async def fastapi_get_tank_coord(network: str, tank: str) -> dict[str, float]:
|
||
ps = get_tank(network, tank)
|
||
coord = { 'x' : ps['x'],
|
||
'y' : ps['y'] }
|
||
return coord
|
||
|
||
@app.post("/settankelevation/",response_model=None)
|
||
async def fastapi_set_tank_elevation(network: str, tank: str, elevation: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'elevation' : elevation }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankinitlevel/",response_model=None)
|
||
async def fastapi_set_tank_init_level(network: str, tank: str, init_level: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'init_level' : init_level }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankminlevel/",response_model=None)
|
||
async def fastapi_set_tank_min_level(network: str, tank: str, min_level: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'min_level' : min_level }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankmaxlevel/",response_model=None)
|
||
async def fastapi_set_tank_max_level(network: str, tank: str, max_level: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'max_level' : max_level }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("settankdiameter//",response_model=None)
|
||
async def fastapi_set_tank_diameter(network: str, tank: str, diameter: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'diameter' : diameter }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankminvol/",response_model=None)
|
||
async def fastapi_set_tank_min_vol(network: str, tank: str, min_vol: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'min_vol' : min_vol }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankvolcurve/",response_model=None)
|
||
async def fastapi_set_tank_vol_curve(network: str, tank: str, vol_curve: str) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'vol_curve' : vol_curve}
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankoverflow/",response_model=None)
|
||
async def fastapi_set_tank_overflow(network: str, tank: str, overflow: str) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'overflow' : overflow }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankx/",response_model=None)
|
||
async def fastapi_set_tank_x(network: str, tank: str, x: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'x' : x }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settanky/",response_model=None)
|
||
async def fastapi_set_tank_y(network: str, tank: str, y: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'y' : y }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/settankcoord/",response_model=None)
|
||
async def fastapi_set_tank_coord(network: str, tank: str, x: float, y: float) -> ChangeSet:
|
||
ps = { 'id' : tank,
|
||
'x' : x,
|
||
'y' : y }
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
@app.get("/gettankproperties/")
|
||
async def fastapi_get_tank_properties(network: str, tank: str) -> dict[str, Any]:
|
||
return get_tank(network, tank)
|
||
|
||
@app.post("/settankproperties/",response_model=None)
|
||
async def fastapi_set_tank_properties(network: str, tank: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'id' : tank } | props
|
||
return set_tank(network, ChangeSet(ps))
|
||
|
||
############################################################
|
||
# pipe 4.[PIPES]
|
||
############################################################
|
||
@app.get('/getpipeschema')
|
||
async def fastapi_get_pipe_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_pipe_schema(network)
|
||
|
||
@app.post("/addpipe/",response_model=None)
|
||
async def fastapi_add_pipe(network: str, pipe: str, node1: str, node2: str, length: float = 0,
|
||
diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'node1' : node1,
|
||
'node2' : node2,
|
||
'length' : length,
|
||
'diameter' : diameter,
|
||
'roughness' : roughness,
|
||
'minor_loss' : minor_loss,
|
||
'status' : status }
|
||
return add_pipe(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletepipe/",response_model=None)
|
||
async def fastapi_delete_pipe(network: str, pipe: str) -> ChangeSet:
|
||
ps = {'id' : pipe}
|
||
return delete_pipe(network, ChangeSet(ps))
|
||
|
||
@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/",response_model=None)
|
||
async def fastapi_set_pipe_node1(network: str, pipe: str, node1: str) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'node1' : node1 }
|
||
return set_pipe(network, ChangeSet(ps))
|
||
|
||
@app.post("/setpipenode2/",response_model=None)
|
||
async def fastapi_set_pipe_node2(network: str, pipe: str, node2: str) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'node2' : node2 }
|
||
return set_pipe(network, ChangeSet(ps))
|
||
|
||
@app.post("/setpipelength/",response_model=None)
|
||
async def fastapi_set_pipe_length(network: str, pipe: str, length: float) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'length' : length }
|
||
return set_pipe(network, ChangeSet(ps))
|
||
|
||
@app.post("/setpipediameter/",response_model=None)
|
||
async def fastapi_set_pipe_diameter(network: str, pipe: str, diameter: float) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'diameter' : diameter }
|
||
return set_pipe(network, ChangeSet(ps))
|
||
|
||
@app.post("/setpiperoughness/",response_model=None)
|
||
async def fastapi_set_pipe_roughness(network: str, pipe: str, roughness: float) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'roughness' : roughness }
|
||
return set_pipe(network, ChangeSet(ps))
|
||
|
||
@app.post("/setpipeminorloss/",response_model=None)
|
||
async def fastapi_set_pipe_minor_loss(network: str, pipe: str, minor_loss: float) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'minor_loss' : minor_loss }
|
||
return set_pipe(network, ChangeSet(ps))
|
||
|
||
@app.post("/setpipestatus/",response_model=None)
|
||
async def fastapi_set_pipe_status(network: str, pipe: str, status: str) -> ChangeSet:
|
||
ps = { 'id' : pipe,
|
||
'status' : status }
|
||
|
||
print(status)
|
||
print(ps)
|
||
|
||
ret = set_pipe(network, ChangeSet(ps))
|
||
print(ret)
|
||
return ret
|
||
|
||
@app.get("/getpipeproperties/")
|
||
async def fastapi_get_pipe_properties(network: str, pipe: str) -> dict[str, Any]:
|
||
return get_pipe(network, pipe)
|
||
|
||
@app.post("/setpipeproperties/",response_model=None)
|
||
async def fastapi_set_pipe_properties(network: str, pipe: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'id' : pipe } | props
|
||
return set_pipe(network, ChangeSet(ps))
|
||
|
||
|
||
############################################################
|
||
# pump 4.[PUMPS]
|
||
############################################################
|
||
@app.get('/getpumpschema')
|
||
async def fastapi_get_pump_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_pump_schema(network)
|
||
|
||
@app.post("/addpump/",response_model=None)
|
||
async def fastapi_add_pump(network: str, pump: str, node1: str, node2: str, power: float = 0.0) -> ChangeSet:
|
||
ps = { 'id' : pump,
|
||
'node1' : node1,
|
||
'node2' : node2,
|
||
'power' : power
|
||
}
|
||
return add_pump(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletepump/",response_model=None)
|
||
async def fastapi_delete_pump(network: str, pump: str) -> ChangeSet:
|
||
ps = { 'id' : pump }
|
||
return delete_pump(network, ChangeSet(ps))
|
||
|
||
@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/",response_model=None)
|
||
async def fastapi_set_pump_node1(network: str, pump: str, node1: str) -> ChangeSet:
|
||
ps = { 'id' : pump,
|
||
'node1' : node1 }
|
||
return set_pump(network, ChangeSet(ps))
|
||
|
||
@app.post("/setpumpnode2/",response_model=None)
|
||
async def fastapi_set_pump_node2(network: str, pump: str, node2: str) -> ChangeSet:
|
||
ps = { 'id' : pump,
|
||
'node2' : node2 }
|
||
return set_pump(network, ChangeSet(ps))
|
||
|
||
@app.get("/getpumpproperties/")
|
||
async def fastapi_get_pump_properties(network: str, pump: str) -> dict[str, Any]:
|
||
return get_pump(network, pump)
|
||
|
||
@app.post("/setpumpproperties/",response_model=None)
|
||
async def fastapi_set_pump_properties(network: str, pump: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'id' : pump } | props
|
||
return set_pump(network, ChangeSet(ps))
|
||
|
||
|
||
############################################################
|
||
# valve 4.[VALVES]
|
||
############################################################
|
||
@app.get('/getvalveschema')
|
||
async def fastapi_get_valve_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_valve_schema(network)
|
||
|
||
@app.post("/addvalve/",response_model=None)
|
||
async def fastapi_add_valve(network: str, valve: str, node1: str, node2: str, diameter: float = 0, v_type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
|
||
ps = { 'id' : valve,
|
||
'node1' : node1,
|
||
'node2' : node2,
|
||
'diameter' : diameter,
|
||
'v_type' : v_type,
|
||
'setting' : setting,
|
||
'minor_loss' : minor_loss }
|
||
|
||
return add_valve(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletevalve/",response_model=None)
|
||
async def fastapi_delete_valve(network: str, valve: str) -> ChangeSet:
|
||
ps = { 'id' : valve }
|
||
return delete_valve(network, ChangeSet(ps))
|
||
|
||
@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/",response_model=None)
|
||
async def fastapi_set_valve_node1(network: str, valve: str, node1: str) -> ChangeSet:
|
||
ps = { 'id' : valve,
|
||
'node1' : node1 }
|
||
return set_valve(network, ChangeSet(ps))
|
||
|
||
@app.post("/setvalvenode2/",response_model=None)
|
||
async def fastapi_set_valve_node2(network: str, valve: str, node2: str) -> ChangeSet:
|
||
ps = { 'id' : valve,
|
||
'node2' : node2 }
|
||
return set_valve(network, ChangeSet(ps))
|
||
|
||
@app.post("/setvalvenodediameter/",response_model=None)
|
||
async def fastapi_set_valve_diameter(network: str, valve: str, diameter: float) -> ChangeSet:
|
||
ps = { 'id' : valve,
|
||
'diameter' : diameter }
|
||
return set_valve(network, ChangeSet(ps))
|
||
|
||
@app.post("/setvalvetype/",response_model=None)
|
||
async def fastapi_set_valve_type(network: str, valve: str, type: str) -> ChangeSet:
|
||
ps = { 'id' : valve,
|
||
'type' : type }
|
||
return set_valve(network, ChangeSet(ps))
|
||
|
||
@app.post("/setvalvesetting/",response_model=None)
|
||
async def fastapi_set_valve_setting(network: str, valve: str, setting: float) -> ChangeSet:
|
||
ps = { 'id' : valve,
|
||
'setting' : setting }
|
||
return set_valve(network, ChangeSet(ps))
|
||
|
||
@app.get("/getvalveproperties/")
|
||
async def fastapi_get_valve_properties(network: str, valve: str) -> dict[str, Any]:
|
||
return get_valve(network, valve)
|
||
|
||
@app.post("/setvalveproperties/",response_model=None)
|
||
async def fastapi_set_valve_properties(network: str, valve: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'id' : valve } | props
|
||
return set_valve(network, ChangeSet(ps))
|
||
|
||
|
||
# node & link
|
||
@app.post("/deletenode/",response_model=None)
|
||
async def fastapi_delete_node(network: str, node: str) -> ChangeSet:
|
||
ps = {'id' : node}
|
||
if is_junction(network, node):
|
||
return delete_junction(network, ChangeSet(ps))
|
||
elif is_reservoir(network, node):
|
||
return delete_reservoir(network, ChangeSet(ps))
|
||
elif is_tank(network, node):
|
||
return delete_tank(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletelink/",response_model=None)
|
||
async def fastapi_delete_link(network: str, link: str) -> ChangeSet:
|
||
ps = {'id' : link}
|
||
if is_pipe(network, link):
|
||
return delete_pipe(network, ChangeSet(ps))
|
||
elif is_pump(network, link):
|
||
return delete_pump(network, ChangeSet(ps))
|
||
elif is_valve(network, link):
|
||
return delete_valve(network, ChangeSet(ps))
|
||
|
||
############################################################
|
||
# tag 8.[TAGS]
|
||
############################################################
|
||
#
|
||
# TAG_TYPE_NODE = api.TAG_TYPE_NODE
|
||
# TAG_TYPE_LINK = api.TAG_TYPE_LINK
|
||
#
|
||
|
||
@app.get('/gettagschema/')
|
||
async def fastapi_get_tag_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_tag_schema(network)
|
||
|
||
@app.get('/gettag/')
|
||
async def fastapi_get_tag(network: str, t_type: str, id: str) -> dict[str, Any]:
|
||
return get_tag(network, t_type, id)
|
||
|
||
@app.get('/gettags/')
|
||
async def fastapi_get_tags(network: str) -> list[dict[str, Any]]:
|
||
tags = get_tags(network)
|
||
print(tags)
|
||
return tags
|
||
|
||
# example:
|
||
# set_tag(p, ChangeSet({'t_type': TAG_TYPE_NODE, 'id': 'j1', 'tag': 'j1t' }))
|
||
# set_tag(p, ChangeSet({'t_type': TAG_TYPE_LINK, 'id': 'p0', 'tag': 'p0t' }))
|
||
@app.post('/settag/',response_model=None)
|
||
async def fastapi_set_tag(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_tag(network, ChangeSet(props))
|
||
|
||
############################################################
|
||
# demand 9.[DEMANDS]
|
||
############################################################
|
||
@app.get('/getdemandschema')
|
||
async def fastapi_get_demand_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_demand_schema(network)
|
||
|
||
@app.get("/getdemandproperties/")
|
||
async def fastapi_get_demand_properties(network: str, junction: str) -> dict[str, Any]:
|
||
return get_demand(network, junction)
|
||
|
||
# example: set_demand(p, ChangeSet({'junction': 'j1', 'demands': [{'demand': 10.0, 'pattern': None, 'category': 'x'}, {'demand': 20.0, 'pattern': None, 'category': None}]}))
|
||
@app.post("/setdemandproperties/",response_model=None)
|
||
async def fastapi_set_demand_properties(network: str, junction: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'junction' : junction } | props
|
||
return set_demand(network, ChangeSet(ps))
|
||
|
||
############################################################
|
||
# status 10.[STATUS] init_status
|
||
############################################################
|
||
@app.get('/getstatusschema')
|
||
async def fastapi_get_status_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_status_schema(network)
|
||
|
||
@app.get("/getstatus/")
|
||
async def fastapi_get_status(network: str, link: str) -> dict[str, Any]:
|
||
return get_status(network, link)
|
||
|
||
# example: set_status(p, ChangeSet({'link': 'p0', 'status': LINK_STATUS_OPEN, 'setting': 10.0}))
|
||
@app.post("/setstatus/",response_model=None)
|
||
async def fastapi_set_status_properties(network: str, link: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'link' : link } | props
|
||
return set_status(network, ChangeSet(ps))
|
||
|
||
############################################################
|
||
# pattern 11.[PATTERNS]
|
||
############################################################
|
||
@app.get('/getpatternschema')
|
||
async def fastapi_get_pattern_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_pattern_schema(network)
|
||
|
||
@app.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))
|
||
|
||
@app.post("/deletepattern/",response_model=None)
|
||
async def fastapi_delete_pattern(network: str, pattern: str) -> ChangeSet:
|
||
ps = { 'id' : pattern }
|
||
return delete_pattern(network, ChangeSet(ps))
|
||
|
||
@app.get("/getpatternproperties/")
|
||
async def fastapi_get_pattern_properties(network: str, pattern: str) -> dict[str, Any]:
|
||
return get_pattern(network, pattern)
|
||
|
||
# example: set_pattern(p, ChangeSet({'id' : 'p0', 'factors': [1.0, 2.0, 3.0]}))
|
||
@app.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))
|
||
|
||
############################################################
|
||
# curve 12.[CURVES]
|
||
############################################################
|
||
@app.get('/getcurveschema')
|
||
async def fastapi_get_curve_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_curve_schema(network)
|
||
|
||
@app.post("/addcurve/",response_model=None)
|
||
async def fastapi_add_curve(network: str, curve: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
|
||
print(props)
|
||
|
||
ps = {
|
||
'id' : curve,
|
||
} | props
|
||
|
||
print(ps)
|
||
|
||
return add_curve(network, ChangeSet(ps))
|
||
|
||
@app.post("/deletecurve/",response_model=None)
|
||
async def fastapi_delete_curve(network: str, curve: str) -> ChangeSet:
|
||
ps = { 'id' : curve }
|
||
return delete_curve(network, ChangeSet(ps))
|
||
|
||
@app.get("/getcurveproperties/")
|
||
async def fastapi_get_curve_properties(network: str, curve: str) -> dict[str, Any]:
|
||
return get_curve(network, curve)
|
||
|
||
# example: set_curve(p, ChangeSet({'id' : 'c0', 'c_type' : CURVE_TYPE_PUMP, 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
||
@app.post("/setcurveproperties/",response_model=None)
|
||
async def fastapi_set_curve_properties(network: str, curve: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
# c_type放到request中
|
||
ps = { 'id' : curve } | props
|
||
return set_curve(network, ChangeSet(ps))
|
||
|
||
|
||
############################################################
|
||
# control 13.[CONTROLS]
|
||
############################################################
|
||
@app.get('/getcontrolschema/')
|
||
async def fastapi_get_control_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_control_schema(network)
|
||
|
||
@app.get("/getcontrolproperties/")
|
||
async def fastapi_get_control_properties(network: str) -> dict[str, Any]:
|
||
return get_control(network)
|
||
|
||
# example: set_control(p, ChangeSet({'control': 'x'}))
|
||
@app.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))
|
||
|
||
############################################################
|
||
# rule 14.[RULES]
|
||
############################################################
|
||
@app.get("/getruleschema/")
|
||
async def fastapi_get_rule_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_rule_schema(network)
|
||
|
||
@app.get("/getruleproperties/")
|
||
async def fastapi_get_rule_properties(network: str) -> dict[str, Any]:
|
||
return get_rule(network)
|
||
|
||
# example: set_rule(p, ChangeSet({'rule': 'x'}))
|
||
@app.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))
|
||
|
||
|
||
############################################################
|
||
# energy 15.[ENERGY]
|
||
############################################################
|
||
@app.get("/getenergyschema/")
|
||
async def fastapi_get_energy_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_energy_schema(network)
|
||
|
||
@app.get("/getenergyproperties/")
|
||
async def fastapi_get_energy_properties(network: str) -> dict[str, Any]:
|
||
return get_energy(network)
|
||
|
||
@app.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))
|
||
|
||
@app.get("/getpumpenergyschema/")
|
||
async def fastapi_get_pump_energy_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_pump_energy_schema(network)
|
||
|
||
@app.get("/getpumpenergyproperties//")
|
||
async def fastapi_get_pump_energy_proeprties(network: str, pump: str) -> dict[str, Any]:
|
||
return get_pump_energy(network, pump)
|
||
|
||
@app.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))
|
||
|
||
############################################################
|
||
# emitter 16.[EMITTERS]
|
||
############################################################
|
||
@app.get('/getemitterschema')
|
||
async def fastapi_get_emitter_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_emitter_schema(network)
|
||
|
||
@app.get("/getemitterproperties/")
|
||
async def fastapi_get_emitter_properties(network: str, junction: str) -> dict[str, Any]:
|
||
return get_emitter(network, junction)
|
||
|
||
# example: set_emitter(p, ChangeSet({'junction': 'j1', 'coefficient': 10.0}))
|
||
@app.post("/setemitterproperties/",response_model=None)
|
||
async def fastapi_set_emitter_properties(network: str, junction: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
ps = { 'junction' : junction } | props
|
||
return set_emitter(network, ChangeSet(ps))
|
||
|
||
|
||
############################################################
|
||
# quality 17.[QUALITY]
|
||
############################################################
|
||
@app.get('/getqualityschema/')
|
||
async def fastapi_get_quality_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_quality_schema(network)
|
||
|
||
@app.get('/getqualityproperties/')
|
||
async def fastapi_get_quality_properties(network: str, node: str) -> dict[str, Any]:
|
||
return get_quality(network, node)
|
||
|
||
# example: set_quality(p, ChangeSet({'node': 'j1', 'quality': 10.0}))
|
||
@app.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))
|
||
|
||
|
||
############################################################
|
||
# source 18.[SOURCES]
|
||
############################################################
|
||
@app.get('/getsourcechema/')
|
||
async def fastapi_get_source_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_source_schema(network)
|
||
|
||
@app.get('/getsource/')
|
||
async def fastapi_get_source(network: str, node: str) -> dict[str, Any]:
|
||
return get_source(network, node)
|
||
|
||
@app.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))
|
||
|
||
# example: add_source(p, ChangeSet({'node': 'j0', 's_type': SOURCE_TYPE_CONCEN, 'strength': 10.0, 'pattern': 'p0'}))
|
||
@app.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))
|
||
|
||
@app.post('/deletesource/',response_model=None)
|
||
async def fastapi_delete_source(network: str, node: str) -> ChangeSet:
|
||
props = { 'node': node }
|
||
return delete_source(network, ChangeSet(props))
|
||
|
||
|
||
############################################################
|
||
# reaction 19.[REACTIONS]
|
||
############################################################
|
||
@app.get('/getreactionschema/')
|
||
async def fastapi_get_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_reaction_schema(network)
|
||
|
||
@app.get('/getreaction/')
|
||
async def fastapi_get_reaction(network: str) -> dict[str, Any]:
|
||
return get_reaction(network)
|
||
|
||
@app.post('/setreaction/',response_model=None)
|
||
# set_reaction(p, ChangeSet({ 'ORDER BULK' : '10' }))
|
||
async def fastapi_set_reaction(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_reaction(network, ChangeSet(props))
|
||
|
||
@app.get('/getpipereactionschema/')
|
||
async def fastapi_get_pipe_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_pipe_reaction_schema(network)
|
||
|
||
@app.get('/getpipereaction/')
|
||
async def fastapi_get_pipe_reaction(network: str, pipe: str) -> dict[str, Any]:
|
||
return get_pipe_reaction(network, pipe)
|
||
|
||
@app.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))
|
||
|
||
@app.get('/gettankreactionschema/')
|
||
async def fastapi_get_tank_reaction_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_tank_reaction_schema(network)
|
||
|
||
@app.get('/gettankreaction/')
|
||
async def fastapi_get_tank_reaction(network: str, tank: str) -> dict[str, Any]:
|
||
return get_tank_reaction(network, tank)
|
||
|
||
@app.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))
|
||
|
||
|
||
############################################################
|
||
# mixing 20.[MIXING]
|
||
############################################################
|
||
@app.get('/getmixingschema/')
|
||
async def fastapi_get_mixing_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_mixing_schema(network)
|
||
|
||
@app.get('/getmixing/')
|
||
async def fastapi_get_mixing(network: str, tank: str) -> dict[str, Any]:
|
||
return get_mixing(network, tank)
|
||
|
||
@app.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))
|
||
|
||
# example: add_mixing(p, ChangeSet({'tank': 't0', 'model': MIXING_MODEL_MIXED, 'value': 10.0}))
|
||
@app.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))
|
||
|
||
@app.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))
|
||
|
||
|
||
############################################################
|
||
# time 21.[TIME]
|
||
############################################################
|
||
@app.get('/gettimeschema')
|
||
async def fastapi_get_time_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_time_schema(network)
|
||
|
||
@app.get("/gettimeproperties/")
|
||
async def fastapi_get_time_properties(network: str) -> dict[str, Any]:
|
||
return get_time(network)
|
||
|
||
@app.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))
|
||
|
||
############################################################
|
||
# option 23.[OPTIONS]
|
||
############################################################
|
||
@app.get('/getoptionschema/')
|
||
async def fastapi_get_option_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_option_v3_schema(network)
|
||
|
||
@app.get("/getoptionproperties/")
|
||
async def fastapi_get_option_properties(network: str) -> dict[str, Any]:
|
||
return get_option_v3(network)
|
||
|
||
@app.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))
|
||
|
||
############################################################
|
||
# coord 24.[COORDINATES]
|
||
############################################################
|
||
@app.get("/getnodecoord/")
|
||
async def fastapi_get_node_coord(network: str, node: str) -> dict[str, float] | None:
|
||
return get_node_coord(network, node)
|
||
|
||
# DingZQ, 2024-12-08, get all node coord
|
||
# id:type:x:y
|
||
# type: junction, reservoir, tank
|
||
@app.get("/getnetworkcoords/")
|
||
async def fastapi_get_network_coords(network: str) -> list[str] | None:
|
||
coords = get_network_node_coords(network)
|
||
result = []
|
||
for node_id, coord in coords.items():
|
||
result.append(f"{node_id}:{coord['type']}:{coord['x']}:{coord['y']}")
|
||
return result
|
||
|
||
# DingZQ, 2025-01-27, get all node coord/links
|
||
# nodes: id:type:x:y
|
||
# links: id:type:node1:node2
|
||
# node type: junction, reservoir, tank
|
||
# link type: pipe, pump, valve
|
||
@app.get("/getnetworkgeometries/")
|
||
async def fastapi_get_network_geometries(network: str) -> dict[str, Any] | None:
|
||
coords = get_network_node_coords(network)
|
||
nodes = []
|
||
for node_id, coord in coords.items():
|
||
nodes.append(f"{node_id}:{coord['type']}:{coord['x']}:{coord['y']}")
|
||
links = get_network_link_nodes(network)
|
||
|
||
return { 'nodes': nodes, 'links': links }
|
||
|
||
# DingZQ, 2024-12-31, get major node coord
|
||
# id:type:x:y
|
||
# type: junction, reservoir, tank
|
||
@app.get("/getmajornodecoords/")
|
||
async def fastapi_get_major_node_coords(network: str, diameter: int) -> list[str] | None:
|
||
start_time = time.time()
|
||
coords = get_major_node_coords(network, diameter)
|
||
end_time = time.time()
|
||
logger.info("get_major_node_coords: %s, time: %s", coords, end_time - start_time)
|
||
|
||
result = []
|
||
for node_id, coord in coords.items():
|
||
result.append(f"{node_id}:{coord['type']}:{coord['x']}:{coord['y']}")
|
||
return result
|
||
|
||
# DingZQ, 2025-01-03, get network in extent
|
||
@app.get("/getnetworkinextent/")
|
||
async def fastapi_get_network_in_extent(network: str, x1: float, y1: float, x2: float, y2: float) -> dict[str, Any] | None:
|
||
nodes = api.get_nodes_in_extent(network, x1, y1, x2, y2)
|
||
links = api.get_links_in_extent(network, x1, y1, x2, y2)
|
||
return { 'nodes': nodes, 'links': links }
|
||
|
||
# DingZQ, 2024-12-08, get all links' start and end node
|
||
# link_id:link_type:node_id1:node_id2
|
||
@app.get("/getnetworklinknodes/")
|
||
async def fastapi_get_network_link_nodes(network: str) -> list[str] | None:
|
||
return get_network_link_nodes(network)
|
||
|
||
# DingZQ 2024-12-31
|
||
# 获取直径大于800的管道
|
||
@app.get("/getmajorpipenodes/")
|
||
async def fastapi_get_major_pipe_nodes(network: str, diameter: int) -> list[str] | None:
|
||
start_time = time.time()
|
||
result = get_major_pipe_nodes(network, diameter)
|
||
end_time = time.time()
|
||
logger.info("get_major_pipe_nodes: %s, time: %s", result, end_time - start_time)
|
||
return result
|
||
|
||
############################################################
|
||
# vertex 25.[VERTICES]
|
||
############################################################
|
||
@app.get('/getvertexschema/')
|
||
async def fastapi_get_vertex_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_vertex_schema(network)
|
||
|
||
@app.get('/getvertexproperties/')
|
||
async def fastapi_get_vertex_properties(network: str, link: str) -> dict[str, Any]:
|
||
return get_vertex(network, link)
|
||
|
||
# set_vertex(p, ChangeSet({'link' : 'p0', 'coords': [{'x': 1.0, 'y': 2.0}, {'x': 2.0, 'y': 1.0}]}))
|
||
@app.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))
|
||
|
||
@app.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))
|
||
|
||
@app.post('/deletevertex/',response_model=None)
|
||
async def fastapi_delete_vertex(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return api.delete_vertex(network, ChangeSet(props))
|
||
|
||
@app.get('/getallvertexlinks/', response_class = PlainTextResponse)
|
||
async def fastapi_get_all_vertex_links(network: str) -> list[str]:
|
||
return json.dumps(get_all_vertex_links(network))
|
||
|
||
@app.get('/getallvertices/', response_class = PlainTextResponse)
|
||
async def fastapi_get_all_vertices(network: str) -> list[dict[str, Any]]:
|
||
return json.dumps(get_all_vertices(network))
|
||
|
||
############################################################
|
||
# label 26.[LABELS]
|
||
############################################################
|
||
@app.get('/getlabelschema/')
|
||
async def fastapi_get_label_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_label_schema(network)
|
||
|
||
@app.get('/getlabelproperties/')
|
||
async def fastapi_get_label_properties(network: str, x: float, y: float) -> dict[str, Any]:
|
||
return get_label(network, x, y)
|
||
|
||
@app.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))
|
||
|
||
@app.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))
|
||
|
||
@app.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))
|
||
|
||
|
||
############################################################
|
||
# backdrop 27.[BACKDROP]
|
||
############################################################
|
||
@app.get('/getbackdropschema/')
|
||
async def fastapi_get_backdrop_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_backdrop_schema(network)
|
||
|
||
@app.get('/getbackdropproperties/')
|
||
async def fastapi_get_backdrop_properties(network: str) -> dict[str, Any]:
|
||
return get_backdrop(network)
|
||
|
||
@app.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))
|
||
|
||
############################################################
|
||
# scada_device 29
|
||
############################################################
|
||
@app.get('/getscadadeviceschema/')
|
||
async def fastapi_get_scada_device_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_scada_device_schema(network)
|
||
|
||
@app.get('/getscadadevice/')
|
||
async def fastapi_get_scada_device(network: str, id: str) -> dict[str, Any]:
|
||
return get_scada_device(network, id)
|
||
|
||
@app.post('/setscadadevice/',response_model=None)
|
||
async def fastapi_set_scada_device(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_scada_device(network, ChangeSet(props))
|
||
|
||
@app.post('/addscadadevice/',response_model=None)
|
||
async def fastapi_add_scada_device(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return add_scada_device(network, ChangeSet(props))
|
||
|
||
@app.post('/deletescadadevice/',response_model=None)
|
||
async def fastapi_delete_scada_device(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return delete_scada_device(network, ChangeSet(props))
|
||
|
||
@app.post('/cleanscadadevice/',response_model=None)
|
||
async def fastapi_clean_scada_device(network: str) -> ChangeSet:
|
||
return clean_scada_device(network)
|
||
|
||
@app.get('/getallscadadeviceids/')
|
||
async def fastapi_get_all_scada_device_ids(network: str) -> list[str]:
|
||
return get_all_scada_device_ids(network)
|
||
|
||
@app.get('/getallscadadevices/', response_class = PlainTextResponse)
|
||
async def fastapi_get_all_scada_devices(network: str) -> list[dict[str, Any]]:
|
||
return json.dumps(get_all_scada_devices(network))
|
||
|
||
|
||
############################################################
|
||
# scada_device_data 30
|
||
############################################################
|
||
@app.get('/getscadadevicedataschema/')
|
||
async def fastapi_get_scada_device_data_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_scada_device_data_schema(network)
|
||
|
||
@app.get('/getscadadevicedata/')
|
||
async def fastapi_get_scada_device_data(network: str, id: str) -> dict[str, Any]:
|
||
return get_scada_device_data(network, id)
|
||
|
||
# example: set_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'data': [{ 'time': '2023-02-10 00:02:22', 'value': 100.0 }, { 'time': '2023-02-10 00:03:22', 'value': 200.0 }]}))
|
||
# time format must be 'YYYY-MM-DD HH:MM:SS'
|
||
@app.post('/setscadadevicedata/',response_model=None)
|
||
async def fastapi_set_scada_device_data(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_scada_device_data(network, ChangeSet(props))
|
||
|
||
# example: add_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-10 00:02:22', 'value': 100.0}))
|
||
@app.post('/addscadadevicedata/',response_model=None)
|
||
async def fastapi_add_scada_device_data(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return add_scada_device_data(network, ChangeSet(props))
|
||
|
||
# example: delete_scada_device_data(p, ChangeSet({'device_id': 'sm_device', 'time': '2023-02-12 00:02:22'}))
|
||
@app.post('/deletescadadevicedata/',response_model=None)
|
||
async def fastapi_delete_scada_device_data(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return delete_scada_device_data(network, ChangeSet(props))
|
||
|
||
@app.post('/cleanscadadevicedata/',response_model=None)
|
||
async def fastapi_clean_scada_device_data(network: str) -> ChangeSet:
|
||
return clean_scada_device_data(network)
|
||
|
||
|
||
############################################################
|
||
# scada_element 31
|
||
############################################################
|
||
@app.get('/getscadaelementschema/')
|
||
async def fastapi_get_scada_element_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_scada_element_schema(network)
|
||
|
||
@app.get('/getscadaelements/')
|
||
async def fastapi_get_scada_elements(network: str) -> list[str]:
|
||
return get_all_scada_elements(network)
|
||
|
||
@app.get('/getscadaelement/')
|
||
async def fastapi_get_scada_element(network: str, id: str) -> dict[str, Any]:
|
||
return get_scada_element(network, id)
|
||
|
||
@app.post('/setscadaelement/',response_model=None)
|
||
async def fastapi_set_scada_element(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_scada_element(network, ChangeSet(props))
|
||
|
||
@app.post('/addscadaelement/',response_model=None)
|
||
async def fastapi_add_scada_element(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return add_scada_element(network, ChangeSet(props))
|
||
|
||
@app.post('/deletescadaelement/',response_model=None)
|
||
async def fastapi_delete_scada_element(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return delete_scada_element(network, ChangeSet(props))
|
||
|
||
@app.post('/cleanscadaelement/',response_model=None)
|
||
async def fastapi_clean_scada_element(network: str) -> ChangeSet:
|
||
return clean_scada_element(network)
|
||
|
||
############################################################
|
||
# general_region 32
|
||
############################################################
|
||
@app.get('/getregionschema/')
|
||
async def fastapi_get_region_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_region_schema(network)
|
||
|
||
@app.get('/getregion/')
|
||
async def fastapi_get_region(network: str, id: str) -> dict[str, Any]:
|
||
return get_region(network, id)
|
||
|
||
@app.post('/setregion/',response_model=None)
|
||
async def fastapi_set_region(network : str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_region(network, ChangeSet(props))
|
||
|
||
# example: add_region(p, ChangeSet({'id': 'r', 'boundary': [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 0.0)]}))
|
||
@app.post('/addregion/',response_model=None)
|
||
async def fastapi_add_region(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return add_region(network, ChangeSet(props))
|
||
|
||
@app.post('/deleteregion/',response_model=None)
|
||
async def fastapi_delete_region(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return delete_region(network, ChangeSet(props))
|
||
|
||
############################################################
|
||
# district_metering_area 33
|
||
############################################################
|
||
@app.get('/calculatedistrictmeteringareafornodes/')
|
||
async def fastapi_calculate_district_metering_area_for_nodes(network: str, req: Request) -> list[list[str]]:
|
||
props = await req.json()
|
||
nodes = props['nodes']
|
||
part_count = props['part_count']
|
||
part_type = props['part_type']
|
||
return calculate_district_metering_area_for_nodes(network, nodes, part_count, part_type)
|
||
|
||
@app.get('/calculatedistrictmeteringareaforregion/')
|
||
async def fastapi_calculate_district_metering_area_for_region(network: str, req: Request) -> list[list[str]]:
|
||
props = await req.json()
|
||
region = props['region']
|
||
part_count = props['part_count']
|
||
part_type = props['part_type']
|
||
return calculate_district_metering_area_for_region(network, region, part_count, part_type)
|
||
|
||
@app.get('/calculatedistrictmeteringareafornetwork/')
|
||
async def fastapi_calculate_district_metering_area_for_network(network: str, req: Request) -> list[list[str]]:
|
||
props = await req.json()
|
||
part_count = props['part_count']
|
||
part_type = props['part_type']
|
||
return calculate_district_metering_area_for_network(network, part_count, part_type)
|
||
|
||
@app.get('/getdistrictmeteringareaschema/')
|
||
async def fastapi_get_district_metering_area_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_district_metering_area_schema(network)
|
||
|
||
@app.get('/getdistrictmeteringarea/')
|
||
async def fastapi_get_district_metering_area(network: str, id: str) -> dict[str, Any]:
|
||
return get_district_metering_area(network, id)
|
||
|
||
@app.post('/setdistrictmeteringarea/',response_model=None)
|
||
async def fastapi_set_district_metering_area(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_district_metering_area(network, ChangeSet(props))
|
||
|
||
@app.post('/adddistrictmeteringarea/',response_model=None)
|
||
async def fastapi_add_district_metering_area(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
|
||
# boundary should be [(x,y), (x,y)]
|
||
boundary = props['boundary']
|
||
newBoundary = []
|
||
for pt in boundary:
|
||
newBoundary.append((pt[0], pt[1]))
|
||
|
||
props['boundary'] = newBoundary
|
||
|
||
return add_district_metering_area(network, ChangeSet(props))
|
||
|
||
@app.post('/deletedistrictmeteringarea/',response_model=None)
|
||
async def fastapi_delete_district_metering_area(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return delete_district_metering_area(network, ChangeSet(props))
|
||
|
||
@app.get('/getalldistrictmeteringareaids/')
|
||
async def fastapi_get_all_district_metering_area_ids(network: str) -> list[str]:
|
||
return get_all_district_metering_area_ids(network)
|
||
|
||
@app.get('/getalldistrictmeteringareas/')
|
||
async def getalldistrictmeteringareas(network: str) -> list[dict[str, Any]]:
|
||
return get_all_district_metering_areas(network)
|
||
|
||
@app.post('/generatedistrictmeteringarea/',response_model=None)
|
||
async def fastapi_generate_district_metering_area(network: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
|
||
return generate_district_metering_area(network, part_count, part_type, inflate_delta)
|
||
|
||
@app.post('/generatesubdistrictmeteringarea/',response_model=None)
|
||
async def fastapi_generate_sub_district_metering_area(network: str, dma: str, part_count: int, part_type: int, inflate_delta: float) -> ChangeSet:
|
||
print(network)
|
||
print(dma)
|
||
print(part_count)
|
||
print(part_type)
|
||
print(inflate_delta)
|
||
return generate_sub_district_metering_area(network, dma, part_count, part_type, inflate_delta)
|
||
|
||
############################################################
|
||
# service_area 34
|
||
############################################################
|
||
@app.get('/calculateservicearea/')
|
||
async def fastapi_calculate_service_area(network: str, time_index: int) -> dict[str, Any]:
|
||
return calculate_service_area(network, time_index)
|
||
|
||
@app.get('/getserviceareaschema/')
|
||
async def fastapi_get_service_area_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_service_area_schema(network)
|
||
|
||
@app.get('/getservicearea/')
|
||
async def fastapi_get_service_area(network: str, id: str) -> dict[str, Any]:
|
||
return get_service_area(network, id)
|
||
|
||
@app.post('/setservicearea/',response_model=None)
|
||
async def fastapi_set_service_area(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_service_area(network, ChangeSet(props))
|
||
|
||
@app.post('/addservicearea/',response_model=None)
|
||
async def fastapi_add_service_area(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return add_service_area(network, ChangeSet(props))
|
||
|
||
@app.post('/deleteservicearea/',response_model=None)
|
||
async def fastapi_delete_service_area(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return delete_service_area(network, ChangeSet(props))
|
||
|
||
@app.get('/getallserviceareas/')
|
||
async def fastapi_get_all_service_areas(network: str) -> list[dict[str, Any]]:
|
||
return get_all_service_areas(network)
|
||
|
||
@app.post('/generateservicearea/',response_model=None)
|
||
async def fastapi_generate_service_area(network: str, inflate_delta: float) -> ChangeSet:
|
||
return generate_service_area(network, inflate_delta)
|
||
|
||
|
||
############################################################
|
||
# virtual_district 35
|
||
############################################################
|
||
@app.get('/calculatevirtualdistrict/')
|
||
async def fastapi_calculate_virtual_district(network: str, centers: list[str]) -> dict[str, list[Any]]:
|
||
return calculate_virtual_district(network, centers)
|
||
|
||
@app.get('/getvirtualdistrictschema/')
|
||
async def fastapi_get_virtual_district_schema(network: str) -> dict[str, dict[str, Any]]:
|
||
return get_virtual_district_schema(network)
|
||
|
||
@app.get('/getvirtualdistrict/')
|
||
async def fastapi_get_virtual_district(network: str, id: str) -> dict[str, Any]:
|
||
return get_virtual_district(network, id)
|
||
|
||
@app.post('/setvirtualdistrict/',response_model=None)
|
||
async def fastapi_set_virtual_district(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return set_virtual_district(network, ChangeSet(props))
|
||
|
||
@app.post('/addvirtualdistrict/',response_model=None)
|
||
async def fastapi_add_virtual_district(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return add_virtual_district(network, ChangeSet(props))
|
||
|
||
@app.post('/deletevirtualdistrict/',response_model=None)
|
||
async def fastapi_delete_virtual_district(network: str, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return delete_virtual_district(network, ChangeSet(props))
|
||
|
||
@app.get('/getallvirtualdistrict/')
|
||
async def fastapi_get_all_virtual_district(network: str) -> list[dict[str, Any]]:
|
||
return get_all_virtual_districts(network)
|
||
|
||
@app.post('/generatevirtualdistrict/',response_model=None)
|
||
async def fastapi_generate_virtual_district(network: str, inflate_delta: float, req: Request) -> ChangeSet:
|
||
props = await req.json()
|
||
return generate_virtual_district(network, props['centers'], inflate_delta)
|
||
|
||
############################################################
|
||
# water_distribution_area 36
|
||
############################################################
|
||
@app.get('/calculatedemandtonodes/')
|
||
async def fastapi_calculate_demand_to_nodes(network: str, req: Request) -> dict[str, float]:
|
||
props = await req.json()
|
||
demand = props['demand']
|
||
nodes = props['nodes']
|
||
return calculate_demand_to_nodes(network, demand, nodes)
|
||
|
||
@app.get('/calculatedemandtoregion/')
|
||
async def fastapi_calculate_demand_to_region(network: str, req: Request) -> dict[str, float]:
|
||
props = await req.json()
|
||
demand = props['demand']
|
||
region = props['region']
|
||
return calculate_demand_to_region(network, demand, region)
|
||
|
||
@app.get('/calculatedemandtonetwork/')
|
||
async def fastapi_calculate_demand_to_network(network: str, demand: float) -> dict[str, float]:
|
||
return calculate_demand_to_network(network, demand)
|
||
|
||
|
||
# inp file
|
||
@app.post("/uploadinp/", status_code=status.HTTP_200_OK)
|
||
async def upload_inp(afile: bytes, name: str ):
|
||
filePath = inpDir + str(name)
|
||
f = open(filePath, 'wb')
|
||
f.write(afile)
|
||
f.close()
|
||
|
||
return True
|
||
|
||
@app.get("/downloadinp/", status_code=status.HTTP_200_OK)
|
||
async def download_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
|
||
|
||
# DingZQ, 2024-12-28, convert v3 to v2
|
||
@app.get("/convertv3tov2/",response_model=None)
|
||
async def fastapi_convert_v3_to_v2(req: Request) -> ChangeSet:
|
||
network = 'v3Tov2'
|
||
jo_root = await req.json()
|
||
inp = jo_root['inp']
|
||
cs = convert_inp_v3_to_v2(inp)
|
||
op = cs.operations[0]
|
||
open_project(network)
|
||
op['vertex'] = json.dumps(get_all_vertices(network))
|
||
op['scada'] = json.dumps(get_all_scada_elements(network))
|
||
op['dma'] = json.dumps(get_all_district_metering_areas(network))
|
||
op['sa'] = json.dumps(get_all_service_areas(network))
|
||
op['vd'] = json.dumps(get_all_virtual_districts(network))
|
||
op['legend'] = get_extension_data(network, 'legend')
|
||
|
||
db = get_extension_data(network, 'scada_db')
|
||
print(db)
|
||
scada_db = ''
|
||
if db:
|
||
scada_db = db
|
||
print(scada_db)
|
||
op['scada_db'] = scada_db
|
||
|
||
close_project(network)
|
||
|
||
return cs
|
||
|
||
@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,
|
||
}
|
||
)
|
||
|
||
|
||
############################################################
|
||
# DingZQ, 2024-12-09, Add sample API to return real time data/simulation result
|
||
# influx db operation
|
||
############################################################
|
||
@app.get("/getrealtimedata/")
|
||
async def get_realtimedata():
|
||
data = [random.randint(0, 100) for _ in range(100)]
|
||
return data
|
||
|
||
@app.get("/getsimulationresult/")
|
||
async def get_simulationresult():
|
||
data = [random.randint(0, 100) for _ in range(100)]
|
||
return data
|
||
|
||
# DingZQ 2025-01-31
|
||
# def query_latest_record_by_ID(ID: str, type: str, bucket: str="realtime_data", client: InfluxDBClient=client) -> dict:
|
||
@app.get("/querynodelatestrecordbyid/")
|
||
async def query_node_latest_record_by_id(id: str):
|
||
return influxdb_api.query_latest_record_by_ID(id, type='node', client=influx_client);
|
||
|
||
@app.get("/querylinklatestrecordbyid/")
|
||
async def query_link_latest_record_by_id(id: str):
|
||
return influxdb_api.query_latest_record_by_ID(id, type='link', client=influx_client);
|
||
|
||
# def query_all_record_by_time(query_time: str, bucket: str="realtime_data", client: InfluxDBClient=client) -> tuple:
|
||
@app.get("/queryallrecordbytime/")
|
||
async def query_all_record_by_time(querytime: str) -> dict[str, list]:
|
||
results: tuple = influxdb_api.query_all_record_by_time(query_time=querytime, client=influx_client);
|
||
return { "nodes": results[0],
|
||
"links": results[1] }
|
||
|
||
# def query_curve_by_ID_property_daterange(ID: str, type: str, property: str, start_date: str, end_date: str, bucket: str="realtime_data", client: InfluxDBClient=client) -> list:
|
||
@app.get("/querynodecurvebyidpropertydatarage/")
|
||
async def query_node_curve_by_id_property_datarage(id: str, prop: str, startdate: str, enddate: str):
|
||
return influxdb_api.query_curve_by_ID_property_daterange(id, type='node', property=prop, start_date=startdate, end_date=enddate, client=influx_client);
|
||
|
||
@app.get("/querylinkcurvebyidpropertydatarage/")
|
||
async def query_link_curve_by_id_property_datarage(id: str, prop: str, startdate: str, enddate: str):
|
||
return influxdb_api.query_curve_by_ID_property_daterange(id, type='link', property=prop, start_date=startdate, end_date=enddate, client=influx_client);
|
||
|
||
|
||
# DingZQ, 2024-12-31, generate openapi.json
|
||
def generate_openapi_json():
|
||
openapi_json_path = "openapi.json"
|
||
with open(openapi_json_path, "w") as file:
|
||
json.dump(app.openapi(), file, indent=4)
|
||
|
||
|
||
# DingZQ, 2024-12-31, run main
|
||
# if __name__ == "__main__":
|
||
# generate_openapi_json()
|
||
# uvicorn.run(app, host="127.0.0.1", port=80)
|