OrgTJWater/TJWaterServer
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Support cascade deletion

Browse Source
This commit is contained in:
WQY\qiong
2023-02-04 13:45:14 +08:00
parent 633a616d39
commit 804e1c7796
38 changed files with 1272 additions and 707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
api/__init__.py
View File

@@ -4,14 +4,15 @@ from .project import copy_project
from .parser import read_inp, dump_inp
from .operation import API_ADD, API_UPDATE, API_DELETE
from .operation import ChangeSet
from .operation import get_current_operation
from .operation import execute_undo, execute_redo
from .operation import have_snapshot, take_snapshot, pick_snapshot
from .operation import pick_operation, sync_with_server, get_restore_operation
from .database import API_ADD, API_UPDATE, API_DELETE
from .database import ChangeSet
from .database import get_current_operation
from .database import execute_undo, execute_redo
from .database import have_snapshot, take_snapshot, pick_snapshot
from .database import pick_operation, sync_with_server, get_restore_operation
from .command import execute_batch_command, execute_batch_commands
from .batch_cmd import execute_batch_command
from .batch_cmds import execute_batch_commands
from .s0_base import JUNCTION, RESERVOIR, TANK, PIPE, PUMP, VALVE, PATTERN, CURVE
from .s0_base import is_node, is_junction, is_reservoir, is_tank
@@ -23,20 +24,26 @@ from .s0_base import get_node_links
from .s1_title import get_title_schema, get_title, set_title
from .s2_junctions import get_junction_schema, add_junction, get_junction, set_junction, delete_junction
from .s2_junctions import get_junction_schema, add_junction, get_junction, set_junction
from .del_cmd import delete_junction_cascade
from .s3_reservoirs import get_reservoir_schema, add_reservoir, get_reservoir, set_reservoir, delete_reservoir
from .s3_reservoirs import get_reservoir_schema, add_reservoir, get_reservoir, set_reservoir
from .del_cmd import delete_reservoir_cascade
from .s4_tanks import OVERFLOW_YES, OVERFLOW_NO
from .s4_tanks import get_tank_schema, add_tank, get_tank, set_tank, delete_tank
from .s4_tanks import get_tank_schema, add_tank, get_tank, set_tank
from .del_cmd import delete_tank_cascade
from .s5_pipes import PIPE_STATUS_OPEN, PIPE_STATUS_CLOSED, PIPE_STATUS_CV
from .s5_pipes import get_pipe_schema, add_pipe, get_pipe, set_pipe, delete_pipe
from .s5_pipes import get_pipe_schema, add_pipe, get_pipe, set_pipe
from .del_cmd import delete_pipe_cascade
from .s6_pumps import get_pump_schema, add_pump, get_pump, set_pump, delete_pump
from .s6_pumps import get_pump_schema, add_pump, get_pump, set_pump
from .del_cmd import delete_pump_cascade
from .s7_valves import VALVES_TYPE_PRV, VALVES_TYPE_PSV, VALVES_TYPE_PBV, VALVES_TYPE_FCV, VALVES_TYPE_TCV, VALVES_TYPE_GPV
from .s7_valves import get_valve_schema, add_valve, get_valve, set_valve, delete_valve
from .s7_valves import get_valve_schema, add_valve, get_valve, set_valve
from .del_cmd import delete_valve_cascade
from .s8_tags import TAG_TYPE_NODE, TAG_TYPE_LINK
from .s8_tags import get_tag_schema, get_tag, set_tag
@@ -46,10 +53,12 @@ from .s9_demands import get_demand_schema, get_demand, set_demand
from .s10_status import LINK_STATUS_OPEN, LINK_STATUS_CLOSED, LINK_STATUS_ACTIVE
from .s10_status import get_status_schema, get_status, set_status
from .s11_patterns import get_pattern_schema, get_pattern, set_pattern, add_pattern, delete_pattern
from .s11_patterns import get_pattern_schema, get_pattern, set_pattern, add_pattern
from .del_cmd import delete_pattern_cascade
from .s12_curves import CURVE_TYPE_PUMP, CURVE_TYPE_EFFICIENCY, CURVE_TYPE_VOLUME, CURVE_TYPE_HEADLOSS
from .s12_curves import get_curve_schema, get_curve, set_curve, add_curve, delete_curve
from .s12_curves import get_curve_schema, get_curve, set_curve, add_curve
from .del_cmd import delete_curve_cascade
from .s13_controls import get_control_schema, get_control, set_control

277
api/batch_cmd.py Normal file
View File

@@ -0,0 +1,277 @@
from .sections import *
from .database import API_ADD, API_UPDATE, API_DELETE, ChangeSet, DbChangeSet, execute_command
from .s1_title import set_title_cmd
from .s2_junctions import set_junction_cmd, add_junction_cmd, delete_junction_cmd
from .s3_reservoirs import set_reservoir_cmd, add_reservoir_cmd, delete_reservoir_cmd
from .s4_tanks import set_tank_cmd, add_tank_cmd, delete_tank_cmd
from .s5_pipes import set_pipe_cmd, add_pipe_cmd, delete_pipe_cmd
from .s6_pumps import set_pump_cmd, add_pump_cmd, delete_pump_cmd
from .s7_valves import set_valve_cmd, add_valve_cmd, delete_valve_cmd
from .s8_tags import set_tag_cmd
from .s9_demands import set_demand_cmd
from .s10_status import set_status_cmd
from .s11_patterns import set_pattern_cmd, add_pattern_cmd, delete_pattern_cmd
from .s12_curves import set_curve_cmd, add_curve_cmd, delete_curve_cmd
from .s13_controls import set_control_cmd
from .s14_rules import set_rule_cmd
from .s15_energy import set_energy_cmd, set_pump_energy_cmd
from .s16_emitters import set_emitter_cmd
from .s17_quality import set_quality_cmd
from .s18_sources import set_source_cmd, add_source_cmd, delete_source_cmd
from .s19_reactions import set_reaction_cmd, set_pipe_reaction_cmd, set_tank_reaction_cmd
from .s20_mixing import set_mixing_cmd, add_mixing_cmd, delete_mixing_cmd
from .s21_times import set_time_cmd
#from .s22_report import *
from .s23_options import set_option_cmd
#from .s24_coordinates import *
from .s25_vertices import set_vertex_cmd, add_vertex_cmd, delete_vertex_cmd
from .s26_labels import set_label_cmd, add_label_cmd, delete_label_cmd
from .s27_backdrop import set_backdrop_cmd
# from .s28_end import *
from .del_cmd_raw import del_cascade_cmd
def add_cmd(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == s1_title:
return None
if type == s2_junction:
return add_junction_cmd(name, cs)
elif type == s3_reservoir:
return add_reservoir_cmd(name, cs)
elif type == s4_tank:
return add_tank_cmd(name, cs)
elif type == s5_pipe:
return add_pipe_cmd(name, cs)
elif type == s6_pump:
return add_pump_cmd(name, cs)
elif type == s7_valve:
return add_valve_cmd(name, cs)
elif type == s8_tag:
return None
elif type == s9_demand:
return None
elif type == s10_status:
return None
elif type == s11_pattern:
return add_pattern_cmd(name, cs)
elif type == s12_curve:
return add_curve_cmd(name, cs)
elif type == s13_control:
return None
elif type == s14_rule:
return None
elif type == s15_energy:
return None
elif type == s15_pump_energy:
return None
elif type == s16_emitter:
return None
elif type == s17_quality:
return None
elif type == s18_source:
return add_source_cmd(name, cs)
elif type == s19_reaction:
return None
elif type == s19_pipe_reaction:
return None
elif type == s19_tank_reaction:
return None
elif type == s20_mixing:
return add_mixing_cmd(name, cs)
elif type == s21_time:
return None
elif type == s22_report:
return None
elif type == s23_option:
return None
elif type == s24_coordinate:
return None
elif type == s25_vertex:
return add_vertex_cmd(name, cs)
elif type == s26_label:
return add_label_cmd(name, cs)
elif type == s27_backdrop:
return None
elif type == s28_end:
return None
return None
def set_cmd(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == s1_title:
return set_title_cmd(name, cs)
if type == s2_junction:
return set_junction_cmd(name, cs)
elif type == s3_reservoir:
return set_reservoir_cmd(name, cs)
elif type == s4_tank:
return set_tank_cmd(name, cs)
elif type == s5_pipe:
return set_pipe_cmd(name, cs)
elif type == s6_pump:
return set_pump_cmd(name, cs)
elif type == s7_valve:
return set_valve_cmd(name, cs)
elif type == s8_tag:
return set_tag_cmd(name, cs)
elif type == s9_demand:
return set_demand_cmd(name, cs)
elif type == s10_status:
return set_status_cmd(name, cs)
elif type == s11_pattern:
return set_pattern_cmd(name, cs)
elif type == s12_curve:
return set_curve_cmd(name, cs)
elif type == s13_control:
return set_control_cmd(name, cs)
elif type == s14_rule:
return set_rule_cmd(name, cs)
elif type == s15_energy:
return set_energy_cmd(name, cs)
elif type == s15_pump_energy:
return set_pump_energy_cmd(name, cs)
elif type == s16_emitter:
return set_emitter_cmd(name, cs)
elif type == s17_quality:
return set_quality_cmd(name, cs)
elif type == s18_source:
return set_source_cmd(name, cs)
elif type == s19_reaction:
return set_reaction_cmd(name, cs)
elif type == s19_pipe_reaction:
return set_pipe_reaction_cmd(name, cs)
elif type == s19_tank_reaction:
return set_tank_reaction_cmd(name, cs)
elif type == s20_mixing:
return set_mixing_cmd(name, cs)
elif type == s21_time:
return set_time_cmd(name, cs)
elif type == s22_report: # no api now
return None
elif type == s23_option:
return set_option_cmd(name, cs)
elif type == s24_coordinate: # do not support update here
return None
elif type == s25_vertex:
return set_vertex_cmd(name, cs)
elif type == s26_label:
return set_label_cmd(name, cs)
elif type == s27_backdrop:
return set_backdrop_cmd(name, cs)
elif type == s28_end: # end
return None
return None
def del_cmd(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == s1_title:
return None
if type == s2_junction:
return delete_junction_cmd(name, cs)
elif type == s3_reservoir:
return delete_reservoir_cmd(name, cs)
elif type == s4_tank:
return delete_tank_cmd(name, cs)
elif type == s5_pipe:
return delete_pipe_cmd(name, cs)
elif type == s6_pump:
return delete_pump_cmd(name, cs)
elif type == s7_valve:
return delete_valve_cmd(name, cs)
elif type == s8_tag:
return None
elif type == s9_demand:
return None
elif type == s10_status:
return None
elif type == s11_pattern:
return delete_pattern_cmd(name, cs)
elif type == s12_curve:
return delete_curve_cmd(name, cs)
elif type == s13_control:
return None
elif type == s14_rule:
return None
elif type == s15_energy:
return None
elif type == s15_pump_energy:
return None
elif type == s16_emitter:
return None
elif type == s17_quality:
return None
elif type == s18_source:
return delete_source_cmd(name, cs)
elif type == s19_reaction:
return None
elif type == s19_pipe_reaction:
return None
elif type == s19_tank_reaction:
return None
elif type == s20_mixing:
return delete_mixing_cmd(name, cs)
elif type == s21_time:
return None
elif type == s22_report:
return None
elif type == s23_option:
return None
elif type == s24_coordinate:
return None
elif type == s25_vertex:
return delete_vertex_cmd(name, cs)
elif type == s26_label:
return delete_label_cmd(name, cs)
elif type == s27_backdrop:
return None
elif type == s28_end:
return None
return None
def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
css: list[DbChangeSet] = []
# for delete, generate cascade command
new_cs = ChangeSet()
for op in cs.operations:
if op['operation'] == API_DELETE:
new_cs.merge(del_cascade_cmd(name, ChangeSet(op)))
else:
new_cs.merge(ChangeSet(op))
try:
for op in new_cs.operations:
operation = op['operation']
r = None
if operation == API_ADD:
r = add_cmd(name, ChangeSet(op))
elif operation == API_UPDATE:
r = set_cmd(name, ChangeSet(op))
elif operation == API_DELETE:
r = del_cmd(name, ChangeSet(op))
if r == None:
print(f'ERROR: Build [{op}] returns None')
return ChangeSet()
css.append(r)
except:
return ChangeSet()
try:
return execute_command(name, DbChangeSet.from_list(css))
except:
return ChangeSet()

268
api/batch_cmds.py Normal file
View File

@@ -0,0 +1,268 @@
from .sections import *
from .database import API_ADD, API_UPDATE, API_DELETE, ChangeSet
from .s1_title import set_title
from .s2_junctions import set_junction, add_junction, delete_junction
from .s3_reservoirs import set_reservoir, add_reservoir, delete_reservoir
from .s4_tanks import set_tank, add_tank, delete_tank
from .s5_pipes import set_pipe, add_pipe, delete_pipe
from .s6_pumps import set_pump, add_pump, delete_pump
from .s7_valves import set_valve, add_valve, delete_valve
from .s8_tags import set_tag
from .s9_demands import set_demand
from .s10_status import set_status
from .s11_patterns import set_pattern, add_pattern, delete_pattern
from .s12_curves import set_curve, add_curve, delete_curve
from .s13_controls import set_control
from .s14_rules import set_rule
from .s15_energy import set_energy, set_pump_energy
from .s16_emitters import set_emitter
from .s17_quality import set_quality
from .s18_sources import set_source, add_source, delete_source
from .s19_reactions import set_reaction, set_pipe_reaction, set_tank_reaction
from .s20_mixing import set_mixing, add_mixing, delete_mixing
from .s21_times import set_time
#from .s22_report import *
from .s23_options import set_option
#from .s24_coordinates import *
from .s25_vertices import set_vertex, add_vertex, delete_vertex
from .s26_labels import set_label, add_label, delete_label
from .s27_backdrop import set_backdrop
# from .s28_end import *
from .del_cmd_raw import del_cascade_cmd
def execute_add_command(name: str, cs: ChangeSet) -> ChangeSet:
type = cs.operations[0]['type']
if type == s1_title:
return ChangeSet()
if type == s2_junction:
return add_junction(name, cs)
elif type == s3_reservoir:
return add_reservoir(name, cs)
elif type == s4_tank:
return add_tank(name, cs)
elif type == s5_pipe:
return add_pipe(name, cs)
elif type == s6_pump:
return add_pump(name, cs)
elif type == s7_valve:
return add_valve(name, cs)
elif type == s8_tag:
return ChangeSet()
elif type == s9_demand:
return ChangeSet()
elif type == s10_status:
return ChangeSet()
elif type == s11_pattern:
return add_pattern(name, cs)
elif type == s12_curve:
return add_curve(name, cs)
elif type == s13_control:
return ChangeSet()
elif type == s14_rule:
return ChangeSet()
elif type == s15_energy:
return ChangeSet()
elif type == s15_pump_energy:
return ChangeSet()
elif type == s16_emitter:
return ChangeSet()
elif type == s17_quality:
return ChangeSet()
elif type == s18_source:
return add_source(name, cs)
elif type == s19_reaction:
return ChangeSet()
elif type == s19_pipe_reaction:
return ChangeSet()
elif type == s19_tank_reaction:
return ChangeSet()
elif type == s20_mixing:
return add_mixing(name, cs)
elif type == s21_time:
return ChangeSet()
elif type == s22_report:
return ChangeSet()
elif type == s23_option:
return ChangeSet()
elif type == s24_coordinate:
return ChangeSet()
elif type == s25_vertex:
return add_vertex(name, cs)
elif type == s26_label:
return add_label(name, cs)
elif type == s27_backdrop:
return ChangeSet()
elif type == s28_end:
return ChangeSet()
return ChangeSet()
def execute_update_command(name: str, cs: ChangeSet) -> ChangeSet:
type = cs.operations[0]['type']
if type == s1_title:
return set_title(name, cs)
if type == s2_junction:
return set_junction(name, cs)
elif type == s3_reservoir:
return set_reservoir(name, cs)
elif type == s4_tank:
return set_tank(name, cs)
elif type == s5_pipe:
return set_pipe(name, cs)
elif type == s6_pump:
return set_pump(name, cs)
elif type == s7_valve:
return set_valve(name, cs)
elif type == s8_tag:
return set_tag(name, cs)
elif type == s9_demand:
return set_demand(name, cs)
elif type == s10_status:
return set_status(name, cs)
elif type == s11_pattern:
return set_pattern(name, cs)
elif type == s12_curve:
return set_curve(name, cs)
elif type == s13_control:
return set_control(name, cs)
elif type == s14_rule:
return set_rule(name, cs)
elif type == s15_energy:
return set_energy(name, cs)
elif type == s15_pump_energy:
return set_pump_energy(name, cs)
elif type == s16_emitter:
return set_emitter(name, cs)
elif type == s17_quality:
return set_quality(name, cs)
elif type == s18_source:
return set_source(name, cs)
elif type == s19_reaction:
return set_reaction(name, cs)
elif type == s19_pipe_reaction:
return set_pipe_reaction(name, cs)
elif type == s19_tank_reaction:
return set_tank_reaction(name, cs)
elif type == s20_mixing:
return set_mixing(name, cs)
elif type == s21_time:
return set_time(name, cs)
elif type == s22_report: # no api now
return ChangeSet()
elif type == s23_option:
return set_option(name, cs)
elif type == s24_coordinate: # do not support update here
return ChangeSet()
elif type == s25_vertex:
return set_vertex(name, cs)
elif type == s26_label:
return set_label(name, cs)
elif type == s27_backdrop:
return set_backdrop(name, cs)
elif type == s28_end: # end
return ChangeSet()
return ChangeSet()
def execute_delete_command(name: str, cs: ChangeSet) -> ChangeSet:
type = cs.operations[0]['type']
if type == s1_title:
return ChangeSet()
if type == s2_junction:
return delete_junction(name, cs)
elif type == s3_reservoir:
return delete_reservoir(name, cs)
elif type == s4_tank:
return delete_tank(name, cs)
elif type == s5_pipe:
return delete_pipe(name, cs)
elif type == s6_pump:
return delete_pump(name, cs)
elif type == s7_valve:
return delete_valve(name, cs)
elif type == s8_tag:
return ChangeSet()
elif type == s9_demand:
return ChangeSet()
elif type == s10_status:
return ChangeSet()
elif type == s11_pattern:
return delete_pattern(name, cs)
elif type == s12_curve:
return delete_curve(name, cs)
elif type == s13_control:
return ChangeSet()
elif type == s14_rule:
return ChangeSet()
elif type == s15_energy:
return ChangeSet()
elif type == s15_pump_energy:
return ChangeSet()
elif type == s16_emitter:
return ChangeSet()
elif type == s17_quality:
return ChangeSet()
elif type == s18_source:
return delete_source(name, cs)
elif type == s19_reaction:
return ChangeSet()
elif type == s19_pipe_reaction:
return ChangeSet()
elif type == s19_tank_reaction:
return ChangeSet()
elif type == s20_mixing:
return delete_mixing(name, cs)
elif type == s21_time:
return ChangeSet()
elif type == s22_report:
return ChangeSet()
elif type == s23_option:
return ChangeSet()
elif type == s24_coordinate:
return ChangeSet()
elif type == s25_vertex:
return delete_vertex(name, cs)
elif type == s26_label:
return delete_label(name, cs)
elif type == s27_backdrop:
return ChangeSet()
elif type == s28_end:
return ChangeSet()
return ChangeSet()
def execute_batch_commands(name: str, cs: ChangeSet) -> ChangeSet:
# for delete, generate cascade command
new_cs = ChangeSet()
for op in cs.operations:
if op['operation'] == API_DELETE:
new_cs.merge(del_cascade_cmd(name, ChangeSet(op)))
else:
new_cs.merge(ChangeSet(op))
result = ChangeSet()
todo = {}
try:
for op in new_cs.operations:
todo = op
operation = op['operation']
if operation == API_ADD:
result.merge(execute_add_command(name, ChangeSet(op)))
elif operation == API_UPDATE:
result.merge(execute_update_command(name, ChangeSet(op)))
elif operation == API_DELETE:
result.merge(execute_delete_command(name, ChangeSet(op)))
except:
print(f'ERROR: Fail to execute {todo}!')
pass
return result

541
api/command.py
View File

@@ -1,541 +0,0 @@
from .s1_title import *
from .s2_junctions import *
from .s3_reservoirs import *
from .s4_tanks import *
from .s5_pipes import *
from .s6_pumps import *
from .s7_valves import *
from .s8_tags import *
from .s9_demands import *
from .s10_status import *
from .s11_patterns import *
from .s12_curves import *
from .s13_controls import *
from .s14_rules import *
from .s15_energy import *
from .s16_emitters import *
from .s17_quality import *
from .s18_sources import *
from .s19_reactions import *
from .s20_mixing import *
from .s21_times import *
from .s22_report import *
from .s23_options import *
from .s24_coordinates import *
from .s25_vertices import *
from .s26_labels import *
from .s27_backdrop import *
from .s28_end import *
_s1_title = 'title'
_s2_junction = 'junction'
_s3_reservoir = 'reservoir'
_s4_tank = 'tank'
_s5_pipe = 'pipe'
_s6_pump = 'pump'
_s7_valve = 'valve'
_s8_tag = 'tag'
_s9_demand = 'demand'
_s10_status = 'status'
_s11_pattern = 'pattern'
_s12_curve = 'curve'
_s13_control = 'control'
_s14_rule = 'rule'
_s15_energy = 'energy'
_s15_pump_energy = 'pump_energy'
_s16_emitter = 'emitter'
_s17_quality = 'quality'
_s18_source = 'source'
_s19_reaction = 'reaction'
_s19_pipe_reaction = 'pipe_reaction'
_s19_tank_reaction = 'tank_reaction'
_s20_mixing = 'mixing'
_s21_time = 'time'
_s22_report = 'report'
_s23_option = 'option'
_s24_coordinate = 'coordinate'
_s25_vertex = 'vertex'
_s26_label = 'label'
_s27_backdrop = 'backdrop'
_s28_end = 'end'
def execute_add_command(name: str, cs: ChangeSet) -> ChangeSet:
type = cs.operations[0]['type']
if type == _s1_title:
return ChangeSet()
if type == _s2_junction:
return add_junction(name, cs)
elif type == _s3_reservoir:
return add_reservoir(name, cs)
elif type == _s4_tank:
return add_tank(name, cs)
elif type == _s5_pipe:
return add_pipe(name, cs)
elif type == _s6_pump:
return add_pump(name, cs)
elif type == _s7_valve:
return add_valve(name, cs)
elif type == _s8_tag:
return ChangeSet()
elif type == _s9_demand:
return ChangeSet()
elif type == _s10_status:
return ChangeSet()
elif type == _s11_pattern:
return add_pattern(name, cs)
elif type == _s12_curve:
return add_curve(name, cs)
elif type == _s13_control:
return ChangeSet()
elif type == _s14_rule:
return ChangeSet()
elif type == _s15_energy:
return ChangeSet()
elif type == _s15_pump_energy:
return ChangeSet()
elif type == _s16_emitter:
return ChangeSet()
elif type == _s17_quality:
return ChangeSet()
elif type == _s18_source:
return add_source(name, cs)
elif type == _s19_reaction:
return ChangeSet()
elif type == _s19_pipe_reaction:
return ChangeSet()
elif type == _s19_tank_reaction:
return ChangeSet()
elif type == _s20_mixing:
return add_mixing(name, cs)
elif type == _s21_time:
return ChangeSet()
elif type == _s22_report:
return ChangeSet()
elif type == _s23_option:
return ChangeSet()
elif type == _s24_coordinate:
return ChangeSet()
elif type == _s25_vertex:
return add_vertex(name, cs)
elif type == _s26_label:
return add_label(name, cs)
elif type == _s27_backdrop:
return ChangeSet()
elif type == _s28_end:
return ChangeSet()
return ChangeSet()
def execute_update_command(name: str, cs: ChangeSet) -> ChangeSet:
type = cs.operations[0]['type']
if type == _s1_title:
return set_title(name, cs)
if type == _s2_junction:
return set_junction(name, cs)
elif type == _s3_reservoir:
return set_reservoir(name, cs)
elif type == _s4_tank:
return set_tank(name, cs)
elif type == _s5_pipe:
return set_pipe(name, cs)
elif type == _s6_pump:
return set_pump(name, cs)
elif type == _s7_valve:
return set_valve(name, cs)
elif type == _s8_tag:
return set_tag(name, cs)
elif type == _s9_demand:
return set_demand(name, cs)
elif type == _s10_status:
return set_status(name, cs)
elif type == _s11_pattern:
return set_pattern(name, cs)
elif type == _s12_curve:
return set_curve(name, cs)
elif type == _s13_control:
return set_control(name, cs)
elif type == _s14_rule:
return set_rule(name, cs)
elif type == _s15_energy:
return set_energy(name, cs)
elif type == _s15_pump_energy:
return set_pump_energy(name, cs)
elif type == _s16_emitter:
return set_emitter(name, cs)
elif type == _s17_quality:
return set_quality(name, cs)
elif type == _s18_source:
return set_source(name, cs)
elif type == _s19_reaction:
return set_reaction(name, cs)
elif type == _s19_pipe_reaction:
return set_pipe_reaction(name, cs)
elif type == _s19_tank_reaction:
return set_tank_reaction(name, cs)
elif type == _s20_mixing:
return set_mixing(name, cs)
elif type == _s21_time:
return set_time(name, cs)
elif type == _s22_report: # no api now
return ChangeSet()
elif type == _s23_option:
return set_option(name, cs)
elif type == _s24_coordinate: # do not support update here
return ChangeSet()
elif type == _s25_vertex:
return set_vertex(name, cs)
elif type == _s26_label:
return set_label(name, cs)
elif type == _s27_backdrop:
return set_backdrop(name, cs)
elif type == _s28_end: # end
return ChangeSet()
return ChangeSet()
def execute_delete_command(name: str, cs: ChangeSet) -> ChangeSet:
type = cs.operations[0]['type']
if type == _s1_title:
return ChangeSet()
if type == _s2_junction:
return delete_junction(name, cs)
elif type == _s3_reservoir:
return delete_reservoir(name, cs)
elif type == _s4_tank:
return delete_tank(name, cs)
elif type == _s5_pipe:
return delete_pipe(name, cs)
elif type == _s6_pump:
return delete_pump(name, cs)
elif type == _s7_valve:
return delete_valve(name, cs)
elif type == _s8_tag:
return ChangeSet()
elif type == _s9_demand:
return ChangeSet()
elif type == _s10_status:
return ChangeSet()
elif type == _s11_pattern:
return delete_pattern(name, cs)
elif type == _s12_curve:
return delete_curve(name, cs)
elif type == _s13_control:
return ChangeSet()
elif type == _s14_rule:
return ChangeSet()
elif type == _s15_energy:
return ChangeSet()
elif type == _s15_pump_energy:
return ChangeSet()
elif type == _s16_emitter:
return ChangeSet()
elif type == _s17_quality:
return ChangeSet()
elif type == _s18_source:
return delete_source(name, cs)
elif type == _s19_reaction:
return ChangeSet()
elif type == _s19_pipe_reaction:
return ChangeSet()
elif type == _s19_tank_reaction:
return ChangeSet()
elif type == _s20_mixing:
return delete_mixing(name, cs)
elif type == _s21_time:
return ChangeSet()
elif type == _s22_report:
return ChangeSet()
elif type == _s23_option:
return ChangeSet()
elif type == _s24_coordinate:
return ChangeSet()
elif type == _s25_vertex:
return delete_vertex(name, cs)
elif type == _s26_label:
return delete_label(name, cs)
elif type == _s27_backdrop:
return ChangeSet()
elif type == _s28_end:
return ChangeSet()
return ChangeSet()
def execute_batch_commands(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
todo = {}
try:
for op in cs.operations:
todo = op
operation = op['operation']
if operation == API_ADD:
result.merge(execute_add_command(name, ChangeSet(op)))
elif operation == API_UPDATE:
result.merge(execute_update_command(name, ChangeSet(op)))
elif operation == API_DELETE:
result.merge(execute_delete_command(name, ChangeSet(op)))
except:
print(f'ERROR: Fail to execute {todo}!')
pass
return result
def cache_add_command(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == _s1_title:
return None
if type == _s2_junction:
return add_junction_cache(name, cs)
elif type == _s3_reservoir:
return add_reservoir_cache(name, cs)
elif type == _s4_tank:
return add_tank_cache(name, cs)
elif type == _s5_pipe:
return add_pipe_cache(name, cs)
elif type == _s6_pump:
return add_pump_cache(name, cs)
elif type == _s7_valve:
return add_valve_cache(name, cs)
elif type == _s8_tag:
return None
elif type == _s9_demand:
return None
elif type == _s10_status:
return None
elif type == _s11_pattern:
return add_pattern_cache(name, cs)
elif type == _s12_curve:
return add_curve_cache(name, cs)
elif type == _s13_control:
return None
elif type == _s14_rule:
return None
elif type == _s15_energy:
return None
elif type == _s15_pump_energy:
return None
elif type == _s16_emitter:
return None
elif type == _s17_quality:
return None
elif type == _s18_source:
return add_source_cache(name, cs)
elif type == _s19_reaction:
return None
elif type == _s19_pipe_reaction:
return None
elif type == _s19_tank_reaction:
return None
elif type == _s20_mixing:
return add_mixing_cache(name, cs)
elif type == _s21_time:
return None
elif type == _s22_report:
return None
elif type == _s23_option:
return None
elif type == _s24_coordinate:
return None
elif type == _s25_vertex:
return add_vertex_cache(name, cs)
elif type == _s26_label:
return add_label_cache(name, cs)
elif type == _s27_backdrop:
return None
elif type == _s28_end:
return None
return None
def cache_update_command(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == _s1_title:
return set_title_cache(name, cs)
if type == _s2_junction:
return set_junction_cache(name, cs)
elif type == _s3_reservoir:
return set_reservoir_cache(name, cs)
elif type == _s4_tank:
return set_tank_cache(name, cs)
elif type == _s5_pipe:
return set_pipe_cache(name, cs)
elif type == _s6_pump:
return set_pump_cache(name, cs)
elif type == _s7_valve:
return set_valve_cache(name, cs)
elif type == _s8_tag:
return set_tag_cache(name, cs)
elif type == _s9_demand:
return set_demand_cache(name, cs)
elif type == _s10_status:
return set_status_cache(name, cs)
elif type == _s11_pattern:
return set_pattern_cache(name, cs)
elif type == _s12_curve:
return set_curve_cache(name, cs)
elif type == _s13_control:
return set_control_cache(name, cs)
elif type == _s14_rule:
return set_rule_cache(name, cs)
elif type == _s15_energy:
return set_energy_cache(name, cs)
elif type == _s15_pump_energy:
return set_pump_energy_cache(name, cs)
elif type == _s16_emitter:
return set_emitter_cache(name, cs)
elif type == _s17_quality:
return set_quality_cache(name, cs)
elif type == _s18_source:
return set_source_cache(name, cs)
elif type == _s19_reaction:
return set_reaction_cache(name, cs)
elif type == _s19_pipe_reaction:
return set_pipe_reaction_cache(name, cs)
elif type == _s19_tank_reaction:
return set_tank_reaction_cache(name, cs)
elif type == _s20_mixing:
return set_mixing_cache(name, cs)
elif type == _s21_time:
return set_time_cache(name, cs)
elif type == _s22_report: # no api now
return None
elif type == _s23_option:
return set_option_cache(name, cs)
elif type == _s24_coordinate: # do not support update here
return None
elif type == _s25_vertex:
return set_vertex_cache(name, cs)
elif type == _s26_label:
return set_label_cache(name, cs)
elif type == _s27_backdrop:
return set_backdrop_cache(name, cs)
elif type == _s28_end: # end
return None
return None
def cache_delete_command(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == _s1_title:
return None
if type == _s2_junction:
return delete_junction_cache(name, cs)
elif type == _s3_reservoir:
return delete_reservoir_cache(name, cs)
elif type == _s4_tank:
return delete_tank_cache(name, cs)
elif type == _s5_pipe:
return delete_pipe_cache(name, cs)
elif type == _s6_pump:
return delete_pump_cache(name, cs)
elif type == _s7_valve:
return delete_valve_cache(name, cs)
elif type == _s8_tag:
return None
elif type == _s9_demand:
return None
elif type == _s10_status:
return None
elif type == _s11_pattern:
return delete_pattern_cache(name, cs)
elif type == _s12_curve:
return delete_curve_cache(name, cs)
elif type == _s13_control:
return None
elif type == _s14_rule:
return None
elif type == _s15_energy:
return None
elif type == _s15_pump_energy:
return None
elif type == _s16_emitter:
return None
elif type == _s17_quality:
return None
elif type == _s18_source:
return delete_source_cache(name, cs)
elif type == _s19_reaction:
return None
elif type == _s19_pipe_reaction:
return None
elif type == _s19_tank_reaction:
return None
elif type == _s20_mixing:
return delete_mixing_cache(name, cs)
elif type == _s21_time:
return None
elif type == _s22_report:
return None
elif type == _s23_option:
return None
elif type == _s24_coordinate:
return None
elif type == _s25_vertex:
return delete_vertex_cache(name, cs)
elif type == _s26_label:
return delete_label_cache(name, cs)
elif type == _s27_backdrop:
return None
elif type == _s28_end:
return None
return None
def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
redo_sql_s : list[str] = []
undo_sql_s : list[str] = []
redo_cs_s : list[dict[str, Any]] = []
undo_cs_s : list[dict[str, Any]] = []
try:
for op in cs.operations:
operation = op['operation']
r = None
if operation == API_ADD:
r = cache_add_command(name, ChangeSet(op))
elif operation == API_UPDATE:
r = cache_update_command(name, ChangeSet(op))
elif operation == API_DELETE:
r = cache_delete_command(name, ChangeSet(op))
if r == None:
print(f'ERROR: Build [{op}] returns None')
return ChangeSet()
redo_sql_s.append(r.redo_sql)
undo_sql_s.append(r.undo_sql)
redo_cs_s += r.redo_cs
undo_cs_s += r.undo_cs
except:
pass
redo_sql = '\n'.join(redo_sql_s)
undo_sql_s.reverse()
undo_sql = '\n'.join(undo_sql_s)
undo_cs_s.reverse()
try:
return execute_command(name, DbChangeSet(redo_sql, undo_sql, redo_cs_s, undo_cs_s))
except:
return ChangeSet()

21
api/operation.py → api/database.py
View File

@@ -60,6 +60,27 @@ class DbChangeSet:
self.redo_cs = redo_cs
self.undo_cs = undo_cs
@staticmethod
def from_list(css):
redo_sql_s : list[str] = []
undo_sql_s : list[str] = []
redo_cs_s : list[dict[str, Any]] = []
undo_cs_s : list[dict[str, Any]] = []
for r in css:
redo_sql_s.append(r.redo_sql)
undo_sql_s.append(r.undo_sql)
redo_cs_s += r.redo_cs
r.undo_cs.reverse() # reverse again...
undo_cs_s += r.undo_cs
redo_sql = '\n'.join(redo_sql_s)
undo_sql_s.reverse()
undo_sql = '\n'.join(undo_sql_s)
undo_cs_s.reverse()
return DbChangeSet(redo_sql, undo_sql, redo_cs_s, undo_cs_s)
def read(name: str, sql: str) -> Row:
with conn[name].cursor(row_factory=dict_row) as cur:

50
api/del_cmd.py Normal file
View File

@@ -0,0 +1,50 @@
from .del_cmd_raw import *
from .batch_cmd import execute_batch_command
def delete_junction_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'junction' }
raw_cmd = delete_junction_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)
def delete_reservoir_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'reservoir' }
raw_cmd = delete_reservoir_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)
def delete_tank_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'tank' }
raw_cmd = delete_tank_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)
def delete_pipe_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'pipe' }
raw_cmd = delete_pipe_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)
def delete_pump_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'pump' }
raw_cmd = delete_pump_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)
def delete_valve_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'valve' }
raw_cmd = delete_valve_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)
def delete_pattern_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'pattern' }
raw_cmd = delete_pattern_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)
def delete_curve_cascade(name: str, cs: ChangeSet) -> ChangeSet:
cs.operations[0] |= { 'operation' : API_DELETE, 'type' : 'curve' }
raw_cmd = delete_curve_cascade_batch_cmd(name, cs)
return execute_batch_command(name, raw_cmd)

214
api/del_cmd_raw.py Normal file
View File

@@ -0,0 +1,214 @@
from .database import *
from .sections import *
from .s0_base import *
from .s2_junctions import unset_junction_by_pattern
from .s3_reservoirs import unset_reservoir_by_pattern
from .s4_tanks import unset_tank_by_curve
from .s6_pumps import unset_pump_by_curve, unset_pump_by_pattern
from .s8_tags import delete_tag_by_node, delete_tag_by_link
from .s9_demands import delete_demand_by_junction, unset_demand_by_pattern
from .s10_status import delete_status_by_link
from .s15_energy import delete_pump_energy_by_pump, unset_pump_energy_by_pattern, unset_pump_energy_by_curve
from .s16_emitters import delete_emitter_by_junction
from .s17_quality import delete_quality_by_node
from .s18_sources import delete_source_by_node, unset_source_by_pattern
from .s19_reactions import delete_pipe_reaction_by_pipe, delete_tank_reaction_by_tank
from .s20_mixing import delete_mixing_by_tank
from .s25_vertices import delete_vertex_by_link
from .s26_labels import unset_label_by_node
def delete_junction_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from junctions where id = '{id}'")
if row == None:
return result
links = get_node_links(name, id)
for link in links:
if is_pipe(name, link):
result.merge(delete_pipe_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'pipe', 'id': link})))
if is_pump(name, link):
result.merge(delete_pump_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'pump', 'id': link})))
if is_valve(name, link):
result.merge(delete_valve_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'valve', 'id': link})))
result.merge(delete_tag_by_node(name, id))
result.merge(delete_demand_by_junction(name, id))
result.merge(delete_emitter_by_junction(name, id))
result.merge(delete_quality_by_node(name, id))
result.merge(delete_source_by_node(name, id))
result.merge(unset_label_by_node(name, id))
result.merge(cs)
return result
def delete_reservoir_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from reservoirs where id = '{id}'")
if row == None:
return result
links = get_node_links(name, id)
for link in links:
if is_pipe(name, link):
result.merge(delete_pipe_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'pipe', 'id': link})))
if is_pump(name, link):
result.merge(delete_pump_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'pump', 'id': link})))
if is_valve(name, link):
result.merge(delete_valve_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'valve', 'id': link})))
result.merge(delete_tag_by_node(name, id))
result.merge(delete_quality_by_node(name, id))
result.merge(delete_source_by_node(name, id))
result.merge(unset_label_by_node(name, id))
result.merge(cs)
return result
def delete_tank_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from tanks where id = '{id}'")
if row == None:
return result
links = get_node_links(name, id)
for link in links:
if is_pipe(name, link):
result.merge(delete_pipe_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'pipe', 'id': link})))
if is_pump(name, link):
result.merge(delete_pump_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'pump', 'id': link})))
if is_valve(name, link):
result.merge(delete_valve_cascade_batch_cmd(name, ChangeSet(g_delete_prefix | {'type': 'valve', 'id': link})))
result.merge(delete_tag_by_node(name, id))
result.merge(delete_quality_by_node(name, id))
result.merge(delete_source_by_node(name, id))
result.merge(delete_tank_reaction_by_tank(name, id))
result.merge(delete_mixing_by_tank(name, id))
result.merge(unset_label_by_node(name, id))
result.merge(cs)
return result
def delete_pipe_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from pipes where id = '{id}'")
if row == None:
return result
result.merge(delete_tag_by_link(name, id))
result.merge(delete_status_by_link(name, id))
result.merge(delete_pipe_reaction_by_pipe(name, id))
result.merge(delete_vertex_by_link(name, id))
result.merge(cs)
return result
def delete_pump_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from pumps where id = '{id}'")
if row == None:
return result
result.merge(delete_tag_by_link(name, id))
result.merge(delete_status_by_link(name, id))
result.merge(delete_pump_energy_by_pump(name, id))
result.merge(delete_vertex_by_link(name, id))
result.merge(cs)
return result
def delete_valve_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from valves where id = '{id}'")
if row == None:
return result
result.merge(delete_tag_by_link(name, id))
result.merge(delete_status_by_link(name, id))
result.merge(delete_vertex_by_link(name, id))
result.merge(cs)
return result
def delete_pattern_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from _pattern where id = '{id}'")
if row == None:
return result
result.merge(unset_junction_by_pattern(name, id))
result.merge(unset_reservoir_by_pattern(name, id))
result.merge(unset_pump_by_pattern(name, id))
result.merge(unset_demand_by_pattern(name, id))
result.merge(unset_pump_energy_by_pattern(name, id))
result.merge(unset_source_by_pattern(name, id))
result.merge(cs)
return result
def delete_curve_cascade_batch_cmd(name: str, cs: ChangeSet) -> ChangeSet:
result = ChangeSet()
id = cs.operations[0]['id']
row = try_read(name, f"select * from _curve where id = '{id}'")
if row == None:
return result
result.merge(unset_tank_by_curve(name, id))
result.merge(unset_pump_by_curve(name, id))
result.merge(unset_pump_energy_by_curve(name, id))
result.merge(cs)
return result
def del_cascade_cmd(name: str, cs: ChangeSet) -> ChangeSet:
type = cs.operations[0]['type']
if type == s2_junction:
return delete_junction_cascade_batch_cmd(name, cs)
elif type == s3_reservoir:
return delete_reservoir_cascade_batch_cmd(name, cs)
elif type == s4_tank:
return delete_tank_cascade_batch_cmd(name, cs)
elif type == s5_pipe:
return delete_pipe_cascade_batch_cmd(name, cs)
elif type == s6_pump:
return delete_pump_cascade_batch_cmd(name, cs)
elif type == s7_valve:
return delete_valve_cascade_batch_cmd(name, cs)
elif type == s11_pattern:
return delete_pattern_cascade_batch_cmd(name, cs)
elif type == s12_curve:
return delete_curve_cascade_batch_cmd(name, cs)
return cs

4
api/parser.py
View File

@@ -29,7 +29,8 @@ from .s25_vertices import *
from .s26_labels import *
from .s27_backdrop import *
from .s28_end import *
from .command import *
from .batch_cmds import *
section_name = ['TITLE', 'JUNCTIONS', 'RESERVOIRS', 'TANKS', 'PIPES',
'PUMPS', 'VALVES', 'TAGS', 'DEMANDS', 'STATUS',
@@ -38,6 +39,7 @@ section_name = ['TITLE', 'JUNCTIONS', 'RESERVOIRS', 'TANKS', 'PIPES',
'TIMES', 'REPORT', 'OPTIONS', 'COORDINATES', 'VERTICES',
'LABELS', 'BACKDROP', 'END']
def _parse_inp(inp: str) -> dict[str, list[str]]:
file: dict[str, list[str]] = {}
for s in section_name:

13
api/s10_status.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
LINK_STATUS_OPEN = 'OPEN'
@@ -39,7 +39,7 @@ class Status(object):
return { 'type': self.type, 'link': self.link, 'status': self.status, 'setting': self.setting }
def set_status_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_status_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Status(get_status(name, cs.operations[0]['link']))
raw_new = get_status(name, cs.operations[0]['link'])
@@ -65,7 +65,7 @@ def set_status_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_status(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_status_cache(name, cs))
return execute_command(name, set_status_cmd(name, cs))
class InpStatus:
@@ -121,3 +121,10 @@ def inp_out_status(name: str) -> list[str]:
if setting != '':
lines.append(f'{link} {setting}')
return lines
def delete_status_by_link(name: str, link: str) -> ChangeSet:
row = try_read(name, f"select * from status where link = '{link}'")
if row == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'status', 'link': link, 'status': None, 'setting': None})

14
api/s11_patterns.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_pattern_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -14,7 +14,7 @@ def get_pattern(name: str, id: str) -> dict[str, Any]:
return { 'id': id, 'factors': ps }
def set_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pattern_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
f_id = f"'{id}'"
@@ -42,10 +42,10 @@ def set_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pattern(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_pattern_cache(name, cs))
return execute_command(name, set_pattern_cmd(name, cs))
def add_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_pattern_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
f_id = f"'{id}'"
@@ -66,10 +66,10 @@ def add_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_pattern(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_pattern_cache(name, cs))
return execute_command(name, add_pattern_cmd(name, cs))
def delete_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_pattern_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
f_id = f"'{id}'"
@@ -90,7 +90,7 @@ def delete_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_pattern(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_pattern_cache(name, cs))
return execute_command(name, delete_pattern_cmd(name, cs))
def inp_in_pattern(section: list[str]) -> ChangeSet:

14
api/s12_curves.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
CURVE_TYPE_PUMP = 'PUMP'
CURVE_TYPE_EFFICIENCY = 'EFFICIENCY'
@@ -26,7 +26,7 @@ def get_curve(name: str, id: str) -> dict[str, Any]:
return d
def set_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_curve_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
f_id = f"'{id}'"
@@ -64,10 +64,10 @@ def set_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_curve(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_curve_cache(name, cs))
return execute_command(name, set_curve_cmd(name, cs))
def add_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_curve_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
f_id = f"'{id}'"
@@ -92,10 +92,10 @@ def add_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_curve(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_curve_cache(name, cs))
return execute_command(name, add_curve_cmd(name, cs))
def delete_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_curve_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
id = cs.operations[0]['id']
f_id = f"'{id}'"
@@ -118,7 +118,7 @@ def delete_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_curve(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_curve_cache(name, cs))
return execute_command(name, delete_curve_cmd(name, cs))
def inp_in_curve(section: list[str]) -> ChangeSet:

6
api/s13_controls.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_control_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -13,7 +13,7 @@ def get_control(name: str) -> dict[str, Any]:
return { 'controls': ds }
def set_control_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_control_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = get_control(name)
redo_sql = 'delete from controls;'
@@ -31,7 +31,7 @@ def set_control_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_control(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_control_cache(name, cs))
return execute_command(name, set_control_cmd(name, cs))
def inp_in_control(section: list[str]) -> ChangeSet:

6
api/s14_rules.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_rule_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -13,7 +13,7 @@ def get_rule(name: str) -> dict[str, Any]:
return { 'rules': ds }
def set_rule_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_rule_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = get_rule(name)
redo_sql = 'delete from rules;'
@@ -31,7 +31,7 @@ def set_rule_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_rule(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_rule_cache(name, cs))
return execute_command(name, set_rule_cmd(name, cs))
def inp_in_rule(section: list[str]) -> ChangeSet:

49
api/s15_energy.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
element_schema = {'type': 'str' , 'optional': True , 'readonly': False}
@@ -19,7 +19,7 @@ def get_energy(name: str) -> dict[str, Any]:
return d
def set_energy_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_energy_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
raw_old = get_energy(name)
old = {}
@@ -54,7 +54,7 @@ def set_energy_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_energy(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_energy_cache(name, cs))
return execute_command(name, set_energy_cmd(name, cs))
def get_pump_energy_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -94,7 +94,7 @@ class PumpEnergy(object):
return { 'type': self.type, 'pump': self.pump, 'price': self.price, 'pattern': self.pattern, 'effic': self.effic }
def set_pump_energy_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pump_energy_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = PumpEnergy(get_pump_energy(name, cs.operations[0]['pump']))
raw_new = get_pump_energy(name, cs.operations[0]['pump'])
@@ -128,7 +128,7 @@ def set_pump_energy_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pump_energy(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_pump_energy_cache(name, cs))
return execute_command(name, set_pump_energy_cmd(name, cs))
def inp_in_energy(section: list[str]) -> ChangeSet:
@@ -192,3 +192,42 @@ def inp_out_energy(name: str) -> list[str]:
lines.append(f'PUMP {pump} EFFIC {value}')
return lines
def delete_pump_energy_by_pump(name: str, pump: str) -> ChangeSet:
row1 = try_read(name, f"select * from energy_pump_price where pump = '{pump}'")
row2 = try_read(name, f"select * from energy_pump_pattern where pump = '{pump}'")
row3 = try_read(name, f"select * from energy_pump_effic where pump = '{pump}'")
if row1 == None and row2 == None and row3 == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'pump_energy', 'pump' : pump, 'price': None, 'pattern': None, 'effic': None})
def unset_pump_energy_by_pattern(name: str, pattern: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select * from energy_pump_pattern where pattern = '{pattern}'")
for row in rows:
pump = row['pump']
row1 = try_read(name, f"select * from energy_pump_price where pump = '{pump}'")
price = float(row1['price']) if row1 != None else None
row2 = try_read(name, f"select * from energy_pump_effic where pump = '{pump}'")
effic = str(row2['effic']) if row2 != None else None
cs.append(g_update_prefix | {'type': 'pump_energy', 'pump' : pump, 'price': price, 'pattern': None, 'effic': effic})
return ChangeSet()
def unset_pump_energy_by_curve(name: str, curve: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select * from energy_pump_effic where effic = '{curve}'")
for row in rows:
pump = row['pump']
row1 = try_read(name, f"select * from energy_pump_price where pump = '{pump}'")
price = float(row1['price']) if row1 != None else None
row2 = try_read(name, f"select * from energy_pump_pattern where pump = '{pump}'")
pattern = str(row2['pattern']) if row2 != None else None
cs.append(g_update_prefix | {'type': 'pump_energy', 'pump' : pump, 'price': price, 'pattern': pattern, 'effic': None})
return ChangeSet()

13
api/s16_emitters.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_emitter_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -30,7 +30,7 @@ class Emitter(object):
return { 'type': self.type, 'junction': self.junction, 'coefficient': self.coefficient }
def set_emitter_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_emitter_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Emitter(get_emitter(name, cs.operations[0]['junction']))
raw_new = get_emitter(name, cs.operations[0]['junction'])
@@ -56,7 +56,7 @@ def set_emitter_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_emitter(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_emitter_cache(name, cs))
return execute_command(name, set_emitter_cmd(name, cs))
class InpEmitter:
@@ -90,3 +90,10 @@ def inp_out_emitter(name: str) -> list[str]:
coefficient = obj['coefficient']
lines.append(f'{junction} {coefficient}')
return lines
def delete_emitter_by_junction(name: str, junction: str) -> ChangeSet:
row = try_read(name, f"select * from emitters where junction = '{junction}'")
if row == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type' : 'emitter', 'junction': junction, 'coefficient': None})

13
api/s17_quality.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_quality_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -30,7 +30,7 @@ class Quality(object):
return { 'type': self.type, 'node': self.node, 'quality': self.quality }
def set_quality_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_quality_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Quality(get_quality(name, cs.operations[0]['node']))
raw_new = get_quality(name, cs.operations[0]['node'])
@@ -56,7 +56,7 @@ def set_quality_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_quality(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_quality_cache(name, cs))
return execute_command(name, set_quality_cmd(name, cs))
class InpQuality:
@@ -90,3 +90,10 @@ def inp_out_quality(name: str) -> list[str]:
quality = obj['quality']
lines.append(f'{node} {quality}')
return lines
def delete_quality_by_node(name: str, node: str) -> ChangeSet:
row = try_read(name, f"select * from quality where node = '{node}'")
if row == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type' : 'quality', 'node': node, 'quality': None})

31
api/s18_sources.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
SOURCE_TYPE_CONCEN = 'CONCEN'
@@ -44,7 +44,7 @@ class Source(object):
return { 'type': self.type, 'node': self.node }
def set_source_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_source_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Source(get_source(name, cs.operations[0]['node']))
raw_new = get_source(name, cs.operations[0]['node'])
@@ -65,10 +65,10 @@ def set_source_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_source(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_source_cache(name, cs))
return execute_command(name, set_source_cmd(name, cs))
def add_source_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_source_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Source(cs.operations[0])
redo_sql = f"insert into sources (node, type, strength, pattern) values ({new.f_node}, {new.f_s_type}, {new.f_strength}, {new.f_pattern});"
@@ -81,10 +81,10 @@ def add_source_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_source(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_source_cache(name, cs))
return execute_command(name, add_source_cmd(name, cs))
def delete_source_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_source_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Source(get_source(name, cs.operations[0]['node']))
redo_sql = f"delete from sources where node = {old.f_node};"
@@ -97,7 +97,7 @@ def delete_source_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_source(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_source_cache(name, cs))
return execute_command(name, delete_source_cmd(name, cs))
class InpSource:
@@ -135,3 +135,20 @@ def inp_out_source(name: str) -> list[str]:
pattern = obj['pattern'] if obj['pattern'] != None else ''
lines.append(f'{node} {s_type} {strength} {pattern}')
return lines
def delete_source_by_node(name: str, node: str) -> ChangeSet:
row = try_read(name, f"select * from sources where node = '{node}'")
if row == None:
return ChangeSet()
return ChangeSet(g_delete_prefix | {'type' : 'source', 'node': node})
def unset_source_by_pattern(name: str, pattern: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select node from sources where pattern = '{pattern}'")
for row in rows:
cs.append(g_update_prefix | {'type': 'source', 'node': row['node'], 'pattern': None})
return cs

31
api/s19_reactions.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
element_schema = {'type': 'str' , 'optional': True , 'readonly': False}
@@ -22,7 +22,7 @@ def get_reaction(name: str) -> dict[str, Any]:
return d
def set_reaction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_reaction_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
raw_old = get_reaction(name)
old = {}
@@ -57,7 +57,7 @@ def set_reaction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_reaction(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_reaction_cache(name, cs))
return execute_command(name, set_reaction_cmd(name, cs))
def get_pipe_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -92,7 +92,7 @@ class PipeReaction(object):
return { 'type': self.type, 'pipe': self.pipe, 'bulk': self.bulk, 'wall': self.wall }
def set_pipe_reaction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pipe_reaction_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = PipeReaction(get_pipe_reaction(name, cs.operations[0]['pipe']))
raw_new = get_pipe_reaction(name, cs.operations[0]['pipe'])
@@ -122,7 +122,7 @@ def set_pipe_reaction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pipe_reaction(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_pipe_reaction_cache(name, cs))
return execute_command(name, set_pipe_reaction_cmd(name, cs))
def get_tank_reaction_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -152,7 +152,7 @@ class TankReaction(object):
return { 'type': self.type, 'tank': self.tank, 'value': self.value }
def set_tank_reaction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_tank_reaction_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = TankReaction(get_tank_reaction(name, cs.operations[0]['tank']))
raw_new = get_tank_reaction(name, cs.operations[0]['tank'])
@@ -178,7 +178,7 @@ def set_tank_reaction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_tank_reaction(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_tank_reaction_cache(name, cs))
return execute_command(name, set_tank_reaction_cmd(name, cs))
def inp_in_reaction(section: list[str]) -> ChangeSet:
@@ -238,4 +238,19 @@ def inp_out_reaction(name: str) -> list[str]:
value = obj['value']
lines.append(f'TANK {tank} {value}')
return lines
return lines
def delete_pipe_reaction_by_pipe(name: str, pipe: str) -> ChangeSet:
row1 = try_read(name, f"select * from reactions_pipe_bulk where pipe = '{pipe}'")
row2 = try_read(name, f"select * from reactions_pipe_wall where pipe = '{pipe}'")
if row1 == None and row2 == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'pipe_reaction', 'pipe': pipe, 'bulk': None, 'wall': None})
def delete_tank_reaction_by_tank(name: str, tank: str) -> ChangeSet:
row = try_read(name, f"select * from reactions_tank where tank = '{tank}'")
if row == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'tank_reaction', 'tank': tank, 'value': None})

6
api/s1_title.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_title_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -10,7 +10,7 @@ def get_title(name: str) -> dict[str, Any]:
return { 'value': title['value'] }
def set_title_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_title_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = cs.operations[0]['value']
old = get_title(name)['value']
@@ -24,7 +24,7 @@ def set_title_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_title(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_title_cache(name ,cs))
return execute_command(name, set_title_cmd(name ,cs))
class InpTitle:

21
api/s20_mixing.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
MIXING_MODEL_MIXED = 'MIXED'
@@ -40,7 +40,7 @@ class Mixing(object):
return { 'type': self.type, 'tank': self.tank }
def set_mixing_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_mixing_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Mixing(get_mixing(name, cs.operations[0]['tank']))
raw_new = get_mixing(name, cs.operations[0]['tank'])
@@ -61,10 +61,10 @@ def set_mixing_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_mixing(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_mixing_cache(name, cs))
return execute_command(name, set_mixing_cmd(name, cs))
def add_mixing_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_mixing_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Mixing(cs.operations[0])
redo_sql = f"insert into mixing (tank, model, value) values ({new.f_tank}, {new.f_model}, {new.f_value});"
@@ -77,10 +77,10 @@ def add_mixing_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_mixing(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_mixing_cache(name, cs))
return execute_command(name, add_mixing_cmd(name, cs))
def delete_mixing_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_mixing_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Mixing(get_mixing(name, cs.operations[0]['tank']))
redo_sql = f"delete from mixing where tank = {old.f_tank};"
@@ -93,7 +93,7 @@ def delete_mixing_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_mixing(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_mixing_cache(name, cs))
return execute_command(name, delete_mixing_cmd(name, cs))
class InpMixing:
@@ -129,3 +129,10 @@ def inp_out_mixing(name: str) -> list[str]:
value = obj['value'] if obj['value'] != None else ''
lines.append(f'{tank} {model} {value}')
return lines
def delete_mixing_by_tank(name: str, tank: str) -> ChangeSet:
row = try_read(name, f"select * from mixing where tank = '{tank}'")
if row == None:
return ChangeSet()
return ChangeSet(g_delete_prefix | {'type' : 'mixing', 'tank': tank})

6
api/s21_times.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
TIME_STATISTIC_NONE = 'NONE'
TIME_STATISTIC_AVERAGED = 'AVERAGED'
@@ -29,7 +29,7 @@ def get_time(name: str) -> dict[str, Any]:
return d
def set_time_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_time_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
raw_old = get_time(name)
old = {}
@@ -64,7 +64,7 @@ def set_time_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_time(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_time_cache(name, cs))
return execute_command(name, set_time_cmd(name, cs))
def inp_in_time(section: list[str]) -> ChangeSet:

2
api/s22_report.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def inp_out_report(name: str) -> list[str]:

6
api/s23_options.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
OPTION_UNITS_CFS = 'CFS'
OPTION_UNITS_GPM = 'GPM'
@@ -67,7 +67,7 @@ def get_option(name: str) -> dict[str, Any]:
return d
def set_option_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_option_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
raw_old = get_option(name)
old = {}
@@ -102,7 +102,7 @@ def set_option_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_option(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_option_cache(name, cs))
return execute_command(name, set_option_cmd(name, cs))
def inp_in_option(section: list[str]) -> ChangeSet:

2
api/s24_coordinates.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def _to_client_point(coord: str) -> dict[str, float]:

25
api/s25_vertices.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_vertex_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -16,7 +16,7 @@ def get_vertex(name: str, link: str) -> dict[str, Any]:
return { 'link': link, 'coords': cs }
def set_vertex_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_vertex_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
link = cs.operations[0]['link']
old = get_vertex(name, link)
@@ -44,34 +44,34 @@ def set_vertex_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_vertex(name: str, cs: ChangeSet) -> ChangeSet:
result = set_vertex_cache(name, cs)
result = set_vertex_cmd(name, cs)
result.redo_cs[0] |= g_update_prefix
result.undo_cs[0] |= g_update_prefix
return execute_command(name, result)
def add_vertex_cache(name: str, cs: ChangeSet) -> DbChangeSet:
result = set_vertex_cache(name, cs)
def add_vertex_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
result = set_vertex_cmd(name, cs)
result.redo_cs[0] |= g_add_prefix
result.undo_cs[0] |= g_delete_prefix
return result
def delete_vertex_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_vertex_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
cs.operations[0]['coords'] = []
result = set_vertex_cache(name, cs)
result = set_vertex_cmd(name, cs)
result.redo_cs[0] |= g_delete_prefix
result.undo_cs[0] |= g_add_prefix
return result
def add_vertex(name: str, cs: ChangeSet) -> ChangeSet:
result = add_vertex_cache(name, cs)
result = add_vertex_cmd(name, cs)
return execute_command(name, result)
def delete_vertex(name: str, cs: ChangeSet) -> ChangeSet:
result = delete_vertex_cache(name, cs)
result = delete_vertex_cmd(name, cs)
return execute_command(name, result)
@@ -102,3 +102,10 @@ def inp_out_vertex(name: str) -> list[str]:
y = obj['y']
lines.append(f"{link} {x} {y}")
return lines
def delete_vertex_by_link(name: str, link: str) -> ChangeSet:
row = try_read(name, f"select * from vertices where link = '{link}'")
if row == None:
return ChangeSet()
return ChangeSet(g_delete_prefix | {'type': 'vertex', 'link' : link})

24
api/s26_labels.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_label_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -43,7 +43,7 @@ class Label(object):
return { 'type': self.type, 'x': self.x, 'y': self.y }
def set_label_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_label_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Label(get_label(name, cs.operations[0]['x'], cs.operations[0]['y']))
raw_new = get_label(name, cs.operations[0]['x'], cs.operations[0]['y'])
@@ -64,10 +64,10 @@ def set_label_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_label(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_label_cache(name, cs))
return execute_command(name, set_label_cmd(name, cs))
def add_label_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_label_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Label(cs.operations[0])
redo_sql = f"insert into labels (x, y, label, node) values ({new.f_x}, {new.f_y}, {new.f_label}, {new.f_node});"
@@ -80,10 +80,10 @@ def add_label_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_label(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_label_cache(name, cs))
return execute_command(name, add_label_cmd(name, cs))
def delete_label_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_label_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Label(get_label(name, cs.operations[0]['x'], cs.operations[0]['y']))
redo_sql = f"delete from labels where x = {old.f_x} and y = {old.f_y};"
@@ -96,7 +96,7 @@ def delete_label_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_label(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_label_cache(name, cs))
return execute_command(name, delete_label_cmd(name, cs))
class InpLabel:
@@ -134,3 +134,13 @@ def inp_out_label(name: str) -> list[str]:
node = obj['node'] if obj['node'] != None else ''
lines.append(f'{x} {y} {label} {node}')
return lines
def unset_label_by_node(name: str, node: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select x, y from labels where node = '{node}'")
for row in rows:
cs.append(g_update_prefix | {'type': 'label', 'x': row['x'], 'y': row['y'], 'node': None})
return cs

6
api/s27_backdrop.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
def get_backdrop_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -10,7 +10,7 @@ def get_backdrop(name: str) -> dict[str, Any]:
return { 'content': e['content'] }
def set_backdrop_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_backdrop_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = get_backdrop(name)
redo_sql = f"update backdrop set content = '{cs.operations[0]['content']}' where content = '{old['content']}';"
@@ -23,7 +23,7 @@ def set_backdrop_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_backdrop(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_backdrop_cache(name, cs))
return execute_command(name, set_backdrop_cmd(name, cs))
class InpBackdrop:

24
api/s2_junctions.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
from .s24_coordinates import *
@@ -51,7 +51,7 @@ class Junction(object):
return { 'type': self.type, 'id': self.id }
def set_junction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_junction_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Junction(get_junction(name, cs.operations[0]['id']))
raw_new = get_junction(name, cs.operations[0]['id'])
@@ -75,10 +75,10 @@ def set_junction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_junction(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_junction_cache(name, cs))
return execute_command(name, set_junction_cmd(name, cs))
def add_junction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_junction_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Junction(cs.operations[0])
redo_sql = f"insert into _node (id, type) values ({new.f_id}, {new.f_type});"
@@ -96,10 +96,10 @@ def add_junction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_junction(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_junction_cache(name, cs))
return execute_command(name, add_junction_cmd(name, cs))
def delete_junction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_junction_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Junction(get_junction(name, cs.operations[0]['id']))
redo_sql = f"delete from coordinates where node = {old.f_id};"
@@ -117,7 +117,7 @@ def delete_junction_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_junction(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_junction_cache(name, cs))
return execute_command(name, delete_junction_cmd(name, cs))
class InpJunction:
@@ -157,3 +157,13 @@ def inp_out_junction(name: str) -> list[str]:
desc = ';'
lines.append(f'{id} {elev} {demand} {pattern} {desc}')
return lines
def unset_junction_by_pattern(name: str, pattern: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from junctions where pattern = '{pattern}'")
for row in rows:
cs.append(g_update_prefix | {'type': 'junction', 'id': row['id'], 'pattern': None})
return cs

24
api/s3_reservoirs.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
from .s24_coordinates import *
@@ -47,7 +47,7 @@ class Reservoir(object):
return { 'type': self.type, 'id': self.id }
def set_reservoir_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_reservoir_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Reservoir(get_reservoir(name, cs.operations[0]['id']))
raw_new = get_reservoir(name, cs.operations[0]['id'])
@@ -71,10 +71,10 @@ def set_reservoir_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_reservoir_cache(name, cs))
return execute_command(name, set_reservoir_cmd(name, cs))
def add_reservoir_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_reservoir_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Reservoir(cs.operations[0])
redo_sql = f"insert into _node (id, type) values ({new.f_id}, {new.f_type});"
@@ -92,10 +92,10 @@ def add_reservoir_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_reservoir_cache(name, cs))
return execute_command(name, add_reservoir_cmd(name, cs))
def delete_reservoir_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_reservoir_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Reservoir(get_reservoir(name, cs.operations[0]['id']))
redo_sql = f"delete from coordinates where node = {old.f_id};"
@@ -113,7 +113,7 @@ def delete_reservoir_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_reservoir_cache(name, cs))
return execute_command(name, delete_reservoir_cmd(name, cs))
class InpReservoir:
@@ -151,3 +151,13 @@ def inp_out_reservoir(name: str) -> list[str]:
desc = ';'
lines.append(f'{id} {head} {pattern} {desc}')
return lines
def unset_reservoir_by_pattern(name: str, pattern: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from reservoirs where pattern = '{pattern}'")
for row in rows:
cs.append(g_update_prefix | {'type': 'reservoir', 'id': row['id'], 'pattern': None})
return cs

24
api/s4_tanks.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
from .s24_coordinates import *
@@ -75,7 +75,7 @@ class Tank(object):
return { 'type': self.type, 'id': self.id }
def set_tank_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_tank_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Tank(get_tank(name, cs.operations[0]['id']))
raw_new = get_tank(name, cs.operations[0]['id'])
@@ -99,10 +99,10 @@ def set_tank_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_tank(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_tank_cache(name, cs))
return execute_command(name, set_tank_cmd(name, cs))
def add_tank_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_tank_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Tank(cs.operations[0])
redo_sql = f"insert into _node (id, type) values ({new.f_id}, {new.f_type});"
@@ -120,10 +120,10 @@ def add_tank_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_tank(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_tank_cache(name, cs))
return execute_command(name, add_tank_cmd(name, cs))
def delete_tank_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_tank_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Tank(get_tank(name, cs.operations[0]['id']))
redo_sql = f"delete from coordinates where node = {old.f_id};"
@@ -141,7 +141,7 @@ def delete_tank_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_tank(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_tank_cache(name, cs))
return execute_command(name, delete_tank_cmd(name, cs))
class InpTank:
@@ -191,3 +191,13 @@ def inp_out_tank(name: str) -> list[str]:
desc = ';'
lines.append(f'{id} {elevation} {init_level} {min_level} {max_level} {diameter} {min_vol} {vol_curve} {overflow} {desc}')
return lines
def unset_tank_by_curve(name: str, curve: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from tanks where vol_curve = '{curve}'")
for row in rows:
cs.append(g_update_prefix | {'type': 'tank', 'id': row['id'], 'vol_curve': None})
return cs

24
api/s5_pipes.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
@@ -61,7 +61,7 @@ class Pipe(object):
return { 'type': self.type, 'id': self.id }
def set_pipe_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pipe_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Pipe(get_pipe(name, cs.operations[0]['id']))
raw_new = get_pipe(name, cs.operations[0]['id'])
@@ -82,10 +82,10 @@ def set_pipe_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pipe(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_pipe_cache(name, cs))
return execute_command(name, set_pipe_cmd(name, cs))
def add_pipe_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_pipe_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Pipe(cs.operations[0])
redo_sql = f"insert into _link (id, type) values ({new.f_id}, {new.f_type});"
@@ -101,10 +101,10 @@ def add_pipe_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_pipe(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_pipe_cache(name, cs))
return execute_command(name, add_pipe_cmd(name, cs))
def delete_pipe_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_pipe_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Pipe(get_pipe(name, cs.operations[0]['id']))
redo_sql = f"delete from pipes where id = {old.f_id};"
@@ -120,7 +120,7 @@ def delete_pipe_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_pipe(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_pipe_cache(name, cs))
return execute_command(name, delete_pipe_cmd(name, cs))
class InpPipe:
@@ -169,3 +169,13 @@ def inp_out_pipe(name: str) -> list[str]:
desc = ';'
lines.append(f'{id} {node1} {node2} {length} {diameter} {roughness} {minor_loss} {status} {desc}')
return lines
'''def delete_pipe_by_node(name: str, node: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from pipes where node1 = '{node}' or node2 = '{node}'")
for row in rows:
cs.append(g_delete_prefix | {'type': 'pipe', 'id': row['id']})
return cs'''

44
api/s6_pumps.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
@@ -52,7 +52,7 @@ class Pump(object):
return { 'type': self.type, 'id': self.id }
def set_pump_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pump_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Pump(get_pump(name, cs.operations[0]['id']))
raw_new = get_pump(name, cs.operations[0]['id'])
@@ -73,10 +73,10 @@ def set_pump_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_pump(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_pump_cache(name, cs))
return execute_command(name, set_pump_cmd(name, cs))
def add_pump_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_pump_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Pump(cs.operations[0])
redo_sql = f"insert into _link (id, type) values ({new.f_id}, {new.f_type});"
@@ -92,10 +92,10 @@ def add_pump_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_pump(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_pump_cache(name, cs))
return execute_command(name, add_pump_cmd(name, cs))
def delete_pump_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_pump_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Pump(get_pump(name, cs.operations[0]['id']))
redo_sql = f"delete from pumps where id = {old.f_id};"
@@ -111,7 +111,7 @@ def delete_pump_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_pump(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_pump_cache(name, cs))
return execute_command(name, delete_pump_cmd(name, cs))
class InpPump:
@@ -160,3 +160,33 @@ def inp_out_pump(name: str) -> list[str]:
desc = ';'
lines.append(f'{id} {node1} {node2} {power} {head} {speed} {pattern} {desc}')
return lines
'''def delete_pump_by_node(name: str, node: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from pumps where node1 = '{node}' or node2 = '{node}'")
for row in rows:
cs.append(g_delete_prefix | {'type': 'pump', 'id': row['id']})
return cs'''
def unset_pump_by_curve(name: str, curve: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from pumps where head = '{curve}'")
for row in rows:
cs.append(g_update_prefix | {'type': 'pump', 'id': row['id'], 'head': None})
return cs
def unset_pump_by_pattern(name: str, pattern: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from pumps where pattern = '{pattern}'")
for row in rows:
cs.append(g_update_prefix | {'type': 'pump', 'id': row['id'], 'pattern': None})
return cs

24
api/s7_valves.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s0_base import *
@@ -60,7 +60,7 @@ class Valve(object):
return { 'type': self.type, 'id': self.id }
def set_valve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_valve_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Valve(get_valve(name, cs.operations[0]['id']))
raw_new = get_valve(name, cs.operations[0]['id'])
@@ -81,10 +81,10 @@ def set_valve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_valve(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_valve_cache(name, cs))
return execute_command(name, set_valve_cmd(name, cs))
def add_valve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_valve_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
new = Valve(cs.operations[0])
redo_sql = f"insert into _link (id, type) values ({new.f_id}, {new.f_type});"
@@ -100,10 +100,10 @@ def add_valve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def add_valve(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, add_valve_cache(name, cs))
return execute_command(name, add_valve_cmd(name, cs))
def delete_valve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_valve_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Valve(get_valve(name, cs.operations[0]['id']))
redo_sql = f"delete from valves where id = {old.f_id};"
@@ -119,7 +119,7 @@ def delete_valve_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def delete_valve(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, delete_valve_cache(name, cs))
return execute_command(name, delete_valve_cmd(name, cs))
class InpValve:
@@ -165,3 +165,13 @@ def inp_out_valve(name: str) -> list[str]:
desc = ';'
lines.append(f'{id} {node1} {node2} {diameter} {v_type} {setting} {minor_loss} {desc}')
return lines
'''def delete_valve_by_node(name: str, node: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select id from valves where node1 = '{node}' or node2 = '{node}'")
for row in rows:
cs.append(g_delete_prefix | {'type': 'valve', 'id': row['id']})
return cs'''

20
api/s8_tags.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
TAG_TYPE_NODE = 'NODE'
TAG_TYPE_LINK = 'LINK'
@@ -42,7 +42,7 @@ class Tag(object):
return { 'type': self.type, 't_type': self.t_type, 'id': self.id, 'tag': self.tag }
def set_tag_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_tag_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
old = Tag(get_tag(name, cs.operations[0]['t_type'], cs.operations[0]['id']))
raw_new = get_tag(name, cs.operations[0]['t_type'], cs.operations[0]['id'])
@@ -76,7 +76,7 @@ def set_tag_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_tag(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_tag_cache(name, cs))
return execute_command(name, set_tag_cmd(name, cs))
class InpTag:
@@ -118,3 +118,17 @@ def inp_out_tag(name: str) -> list[str]:
tag = obj['tag']
lines.append(f'{t_type} {id} {tag}')
return lines
def delete_tag_by_node(name: str, node: str) -> ChangeSet:
row = try_read(name, f"select * from tags_node where id = '{node}'")
if row == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'tag', 't_type': TAG_TYPE_NODE, 'id': node, 'tag': None })
def delete_tag_by_link(name: str, link: str) -> ChangeSet:
row = try_read(name, f"select * from tags_link where id = '{link}'")
if row == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'tag', 't_type': TAG_TYPE_LINK, 'id': link, 'tag': None })

42
api/s9_demands.py
View File

@@ -1,4 +1,4 @@
from .operation import *
from .database import *
from .s2_junctions import *
def get_demand_schema(name: str) -> dict[str, dict[str, Any]]:
@@ -21,7 +21,7 @@ def get_demand(name: str, junction: str) -> dict[str, Any]:
return { 'junction': junction, 'demands': ds }
def set_demand_cache(name: str, cs: ChangeSet) -> DbChangeSet:
def set_demand_cmd(name: str, cs: ChangeSet) -> DbChangeSet:
junction = cs.operations[0]['junction']
old = get_demand(name, junction)
new = { 'junction': junction, 'demands': [] }
@@ -55,34 +55,34 @@ def set_demand_cache(name: str, cs: ChangeSet) -> DbChangeSet:
undo_cs = []
undo_cs.append(g_update_prefix | { 'type': 'demand' } | old)
cache = None
cmd = None
if len(cs.operations[0]['demands']) > 0:
r = cs.operations[0]['demands'][0]
demand = float(r['demand'])
pattern = str(r['pattern']) if 'pattern' in r and r['pattern'] != None else None
cache = set_junction_cache(name, ChangeSet({'id': junction, 'demand': demand, 'pattern': pattern}))
cmd = set_junction_cmd(name, ChangeSet({'id': junction, 'demand': demand, 'pattern': pattern}))
else:
cache = set_junction_cache(name, ChangeSet({'id': junction, 'demand': None, 'pattern': None}))
cmd = set_junction_cmd(name, ChangeSet({'id': junction, 'demand': None, 'pattern': None}))
undo_sql = ''
if cache != None:
if cmd != None:
redo_sql += '\n'
redo_sql += cache.redo_sql
redo_sql += cmd.redo_sql
undo_sql += cache.undo_sql
undo_sql += cmd.undo_sql
undo_sql += '\n'
undo_sql += _undo_sql
redo_cs += cache.redo_cs
redo_cs += cmd.redo_cs
undo_cs += cache.undo_cs
undo_cs += cmd.undo_cs
undo_cs.reverse()
return DbChangeSet(redo_sql, undo_sql, redo_cs, undo_cs)
def set_demand(name: str, cs: ChangeSet) -> ChangeSet:
return execute_command(name, set_demand_cache(name, cs))
return execute_command(name, set_demand_cmd(name, cs))
class InpDemand:
@@ -152,3 +152,23 @@ def inp_out_demand(name: str) -> list[str]:
category = f";{obj['category']}" if obj['category'] != None else ';'
lines.append(f'{junction} {demand} {pattern} {category}')
return lines
def delete_demand_by_junction(name: str, junction: str) -> ChangeSet:
row = try_read(name, f"select * from demands where junction = '{junction}'")
if row == None:
return ChangeSet()
return ChangeSet(g_update_prefix | {'type': 'demand', 'junction': junction, 'demands': []})
def unset_demand_by_pattern(name: str, pattern: str) -> ChangeSet:
cs = ChangeSet()
rows = read_all(name, f"select distinct id from junctions where pattern = '{pattern}'")
for row in rows:
ds = get_demand(name, row['id'])
for d in ds['demands']:
d['pattern'] = None
cs.append(g_update_prefix | {'type': 'demand', 'junction': row['junction'], 'demands': ds})
return cs

31
api/sections.py Normal file
View File

@@ -0,0 +1,31 @@
s1_title = 'title'
s2_junction = 'junction'
s3_reservoir = 'reservoir'
s4_tank = 'tank'
s5_pipe = 'pipe'
s6_pump = 'pump'
s7_valve = 'valve'
s8_tag = 'tag'
s9_demand = 'demand'
s10_status = 'status'
s11_pattern = 'pattern'
s12_curve = 'curve'
s13_control = 'control'
s14_rule = 'rule'
s15_energy = 'energy'
s15_pump_energy = 'pump_energy'
s16_emitter = 'emitter'
s17_quality = 'quality'
s18_source = 'source'
s19_reaction = 'reaction'
s19_pipe_reaction = 'pipe_reaction'
s19_tank_reaction = 'tank_reaction'
s20_mixing = 'mixing'
s21_time = 'time'
s22_report = 'report'
s23_option = 'option'
s24_coordinate = 'coordinate'
s25_vertex = 'vertex'
s26_label = 'label'
s27_backdrop = 'backdrop'
s28_end = 'end'

2
script/sql/create/15.energy.sql
View File

@@ -28,6 +28,7 @@ create table energy_pump_pattern
);
-- delete when delete pump
-- delete when delete pattern
create table energy_pump_effic
(
@@ -36,3 +37,4 @@ create table energy_pump_effic
);
-- delete when delete pump
-- delete when delete curve

18
tjnetwork.py
View File

@@ -173,9 +173,11 @@ def pick_operation(name: str, operation: int, discard: bool = False) -> ChangeSe
def sync_with_server(name: str, operation: int) -> ChangeSet:
return api.sync_with_server(name, operation)
# combine commands as one undo/redo unit
def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
return api.execute_batch_command(name, cs)
# execute command one by one
def execute_batch_commands(name: str, cs: ChangeSet) -> ChangeSet:
return api.execute_batch_commands(name, cs)
@@ -265,7 +267,7 @@ def add_junction(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_junction(name, cs)
def delete_junction(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_junction(name, cs)
return api.delete_junction_cascade(name, cs)
############################################################
@@ -286,7 +288,7 @@ def add_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_reservoir(name, cs)
def delete_reservoir(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_reservoir(name, cs)
return api.delete_reservoir_cascade(name, cs)
############################################################
@@ -307,7 +309,7 @@ def add_tank(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_tank(name, cs)
def delete_tank(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_tank(name, cs)
return api.delete_tank_cascade(name, cs)
############################################################
@@ -328,7 +330,7 @@ def add_pipe(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_pipe(name, cs)
def delete_pipe(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_pipe(name, cs)
return api.delete_pipe_cascade(name, cs)
############################################################
@@ -349,7 +351,7 @@ def add_pump(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_pump(name, cs)
def delete_pump(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_pump(name, cs)
return api.delete_pump_cascade(name, cs)
############################################################
@@ -370,7 +372,7 @@ def add_valve(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_valve(name, cs)
def delete_valve(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_valve(name, cs)
return api.delete_valve_cascade(name, cs)
############################################################
@@ -438,7 +440,7 @@ def add_pattern(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_pattern(name, cs)
def delete_pattern(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_pattern(name, cs)
return api.delete_pattern_cascade(name, cs)
############################################################
@@ -459,7 +461,7 @@ def add_curve(name: str, cs: ChangeSet) -> ChangeSet:
return api.add_curve(name, cs)
def delete_curve(name: str, cs: ChangeSet) -> ChangeSet:
return api.delete_curve(name, cs)
return api.delete_curve_cascade(name, cs)
############################################################