diff --git a/api/__init__.py b/api/__init__.py index 68ff11a..3eaedbf 100644 --- a/api/__init__.py +++ b/api/__init__.py @@ -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 diff --git a/api/batch_cmd.py b/api/batch_cmd.py new file mode 100644 index 0000000..1bc30cf --- /dev/null +++ b/api/batch_cmd.py @@ -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() diff --git a/api/batch_cmds.py b/api/batch_cmds.py new file mode 100644 index 0000000..1f8f77f --- /dev/null +++ b/api/batch_cmds.py @@ -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 diff --git a/api/command.py b/api/command.py deleted file mode 100644 index 30b266b..0000000 --- a/api/command.py +++ /dev/null @@ -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() diff --git a/api/operation.py b/api/database.py similarity index 92% rename from api/operation.py rename to api/database.py index addcba8..f2cba43 100644 --- a/api/operation.py +++ b/api/database.py @@ -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: diff --git a/api/del_cmd.py b/api/del_cmd.py new file mode 100644 index 0000000..8597b0a --- /dev/null +++ b/api/del_cmd.py @@ -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) diff --git a/api/del_cmd_raw.py b/api/del_cmd_raw.py new file mode 100644 index 0000000..5531435 --- /dev/null +++ b/api/del_cmd_raw.py @@ -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 diff --git a/api/parser.py b/api/parser.py index 32cf36b..8187882 100644 --- a/api/parser.py +++ b/api/parser.py @@ -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: diff --git a/api/s10_status.py b/api/s10_status.py index 5375b67..c242fa4 100644 --- a/api/s10_status.py +++ b/api/s10_status.py @@ -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}) diff --git a/api/s11_patterns.py b/api/s11_patterns.py index e6970ed..e2bc1d5 100644 --- a/api/s11_patterns.py +++ b/api/s11_patterns.py @@ -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: diff --git a/api/s12_curves.py b/api/s12_curves.py index 7391e1c..823ecc5 100644 --- a/api/s12_curves.py +++ b/api/s12_curves.py @@ -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: diff --git a/api/s13_controls.py b/api/s13_controls.py index 4e65cab..e052033 100644 --- a/api/s13_controls.py +++ b/api/s13_controls.py @@ -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: diff --git a/api/s14_rules.py b/api/s14_rules.py index fb9c6a1..848c8fd 100644 --- a/api/s14_rules.py +++ b/api/s14_rules.py @@ -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: diff --git a/api/s15_energy.py b/api/s15_energy.py index 1329958..e9c7dc5 100644 --- a/api/s15_energy.py +++ b/api/s15_energy.py @@ -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() diff --git a/api/s16_emitters.py b/api/s16_emitters.py index fda699f..7245cf9 100644 --- a/api/s16_emitters.py +++ b/api/s16_emitters.py @@ -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}) diff --git a/api/s17_quality.py b/api/s17_quality.py index 2df0ff1..3d716b2 100644 --- a/api/s17_quality.py +++ b/api/s17_quality.py @@ -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}) diff --git a/api/s18_sources.py b/api/s18_sources.py index 432a4ee..7730916 100644 --- a/api/s18_sources.py +++ b/api/s18_sources.py @@ -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 diff --git a/api/s19_reactions.py b/api/s19_reactions.py index 6fbc358..f48c8d8 100644 --- a/api/s19_reactions.py +++ b/api/s19_reactions.py @@ -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 \ No newline at end of file + 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}) diff --git a/api/s1_title.py b/api/s1_title.py index 2db45e7..c650cc9 100644 --- a/api/s1_title.py +++ b/api/s1_title.py @@ -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: diff --git a/api/s20_mixing.py b/api/s20_mixing.py index f1ee3ce..d02aa0f 100644 --- a/api/s20_mixing.py +++ b/api/s20_mixing.py @@ -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}) diff --git a/api/s21_times.py b/api/s21_times.py index fd67a80..2631cb9 100644 --- a/api/s21_times.py +++ b/api/s21_times.py @@ -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: diff --git a/api/s22_report.py b/api/s22_report.py index 3308543..6fc4f38 100644 --- a/api/s22_report.py +++ b/api/s22_report.py @@ -1,4 +1,4 @@ -from .operation import * +from .database import * def inp_out_report(name: str) -> list[str]: diff --git a/api/s23_options.py b/api/s23_options.py index 50c5f9b..cb388da 100644 --- a/api/s23_options.py +++ b/api/s23_options.py @@ -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: diff --git a/api/s24_coordinates.py b/api/s24_coordinates.py index 409e693..ee9cfe0 100644 --- a/api/s24_coordinates.py +++ b/api/s24_coordinates.py @@ -1,4 +1,4 @@ -from .operation import * +from .database import * def _to_client_point(coord: str) -> dict[str, float]: diff --git a/api/s25_vertices.py b/api/s25_vertices.py index bb0b551..1eabb10 100644 --- a/api/s25_vertices.py +++ b/api/s25_vertices.py @@ -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}) diff --git a/api/s26_labels.py b/api/s26_labels.py index 784c815..172f352 100644 --- a/api/s26_labels.py +++ b/api/s26_labels.py @@ -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 diff --git a/api/s27_backdrop.py b/api/s27_backdrop.py index 8c1b0f7..1e1d3cb 100644 --- a/api/s27_backdrop.py +++ b/api/s27_backdrop.py @@ -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: diff --git a/api/s2_junctions.py b/api/s2_junctions.py index 2366a59..ee0fd78 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -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 diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index ef43e51..425f874 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -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 diff --git a/api/s4_tanks.py b/api/s4_tanks.py index e01df3b..8d64205 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -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 diff --git a/api/s5_pipes.py b/api/s5_pipes.py index 2d3ea1b..dc101cf 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -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''' diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 715d59c..1f9dce8 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -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 diff --git a/api/s7_valves.py b/api/s7_valves.py index 241b96d..a56cb7d 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -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''' diff --git a/api/s8_tags.py b/api/s8_tags.py index c54dfef..9dd8a32 100644 --- a/api/s8_tags.py +++ b/api/s8_tags.py @@ -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 }) diff --git a/api/s9_demands.py b/api/s9_demands.py index bf184f6..edb476c 100644 --- a/api/s9_demands.py +++ b/api/s9_demands.py @@ -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 diff --git a/api/sections.py b/api/sections.py new file mode 100644 index 0000000..f56beab --- /dev/null +++ b/api/sections.py @@ -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' \ No newline at end of file diff --git a/script/sql/create/15.energy.sql b/script/sql/create/15.energy.sql index 67b4ada..13a5c7b 100644 --- a/script/sql/create/15.energy.sql +++ b/script/sql/create/15.energy.sql @@ -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 diff --git a/tjnetwork.py b/tjnetwork.py index f5bc86c..72c20af 100644 --- a/tjnetwork.py +++ b/tjnetwork.py @@ -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) ############################################################