From b715f330ddce0bad9764048ece24ba446ba36378 Mon Sep 17 00:00:00 2001 From: "WQY\\qiong" Date: Sat, 17 Dec 2022 09:23:08 +0800 Subject: [PATCH] Code refactor for change set --- api/operation.py | 82 ++++++++------------------------------------ api/s10_status.py | 4 +-- api/s11_patterns.py | 12 +++---- api/s12_curves.py | 12 +++---- api/s13_controls.py | 4 +-- api/s14_rules.py | 4 +-- api/s15_energy.py | 8 ++--- api/s16_emitters.py | 4 +-- api/s17_quality.py | 4 +-- api/s18_sources.py | 12 +++---- api/s19_reactions.py | 12 +++---- api/s1_title.py | 4 +-- api/s20_mixing.py | 12 +++---- api/s21_times.py | 4 +-- api/s23_options.py | 4 +-- api/s25_vertices.py | 47 ++++++++++++------------- api/s26_labels.py | 12 +++---- api/s27_backdrop.py | 4 +-- api/s2_junctions.py | 12 +++---- api/s3_reservoirs.py | 12 +++---- api/s4_tanks.py | 12 +++---- api/s5_pipes.py | 12 +++---- api/s6_pumps.py | 12 +++---- api/s7_valves.py | 12 +++---- api/s8_tags.py | 4 +-- 25 files changed, 131 insertions(+), 190 deletions(-) diff --git a/api/operation.py b/api/operation.py index 44cf20e..addcba8 100644 --- a/api/operation.py +++ b/api/operation.py @@ -17,6 +17,13 @@ class ChangeSet: if ps != None: self.append(ps) + @staticmethod + def from_list(ps: list[dict[str, Any]]): + cs = ChangeSet() + for _cs in ps: + cs.append(_cs) + return cs + def add(self, ps: dict[str, Any]): self.operations.append(g_add_prefix | ps) return self @@ -46,14 +53,7 @@ class ChangeSet: return self -class SqlChangeSet: - def __init__(self, redo_sql: str, undo_sql: str, redo_cs: dict[str, Any], undo_cs: dict[str, Any]) -> None: - self.redo_sql = redo_sql - self.undo_sql = undo_sql - self.redo_cs = redo_cs - self.undo_cs = undo_cs - -class BatchSqlChangeSet: +class DbChangeSet: def __init__(self, redo_sql: str, undo_sql: str, redo_cs: list[dict[str, Any]], undo_cs: list[dict[str, Any]]) -> None: self.redo_sql = redo_sql self.undo_sql = undo_sql @@ -91,7 +91,7 @@ def get_current_operation(name: str) -> int: return int(read(name, 'select id from current_operation')['id']) -def execute_command(name: str, command: SqlChangeSet) -> ChangeSet: +def execute_command(name: str, command: DbChangeSet) -> ChangeSet: write(name, command.redo_sql) parent = get_current_operation(name) @@ -104,27 +104,7 @@ def execute_command(name: str, command: SqlChangeSet) -> ChangeSet: current = read(name, 'select max(id) as id from operation')['id'] write(name, f"update current_operation set id = {current}") - return ChangeSet(command.redo_cs) - - -def execute_batch(name: str, redo_sql: str, undo_sql: str, redo_cs_s: list[dict[str, Any]], undo_cs_s: list[dict[str, Any]]) -> ChangeSet: - write(name, redo_sql) - - parent = get_current_operation(name) - redo_sql = redo_sql.replace("'", "''") - undo_sql = undo_sql.replace("'", "''") - redo_cs_str = str(redo_cs_s).replace("'", "''") - undo_cs_str = str(undo_cs_s).replace("'", "''") - write(name, f"insert into operation (id, redo, undo, parent, redo_cs, undo_cs) values (default, '{redo_sql}', '{undo_sql}', {parent}, '{redo_cs_str}', '{undo_cs_str}')") - - current = read(name, 'select max(id) as id from operation')['id'] - write(name, f"update current_operation set id = {current}") - - cs = ChangeSet() - for r_cs in redo_cs_s: - cs.append(r_cs) - - return cs + return ChangeSet.from_list(command.redo_cs) def execute_undo(name: str, discard: bool = False) -> ChangeSet: @@ -144,14 +124,7 @@ def execute_undo(name: str, discard: bool = False) -> ChangeSet: write(name, f"update operation set redo_child = {row['id']} where id = {row['parent']}") e = eval(row['undo_cs']) - if isinstance(e, type({})): - return ChangeSet(e) - - cs = ChangeSet() - for _cs in e: - cs.append(_cs) - - return cs + return ChangeSet.from_list(e) def execute_redo(name: str) -> ChangeSet: @@ -165,14 +138,7 @@ def execute_redo(name: str) -> ChangeSet: write(name, f"update current_operation set id = {row['id']} where id = {row['parent']}") e = eval(row['redo_cs']) - if isinstance(e, type({})): - return ChangeSet(e) - - cs = ChangeSet() - for _cs in e: - cs.append(_cs) - - return cs + return ChangeSet.from_list(e) def have_snapshot(name: str, tag: str) -> bool: @@ -244,28 +210,8 @@ def pick_snapshot(name: str, tag: str, discard: bool) -> ChangeSet: def _get_change_set(name: str, operation: int, undo: bool) -> ChangeSet: row = read(name, f'select * from operation where id = {operation}') - - cs = ChangeSet() - if undo: - e = eval(row['undo_cs']) - if isinstance(e, type({})): - return ChangeSet(e) - - cs = ChangeSet() - for _cs in e: - cs.append(_cs) - - return cs - else: - e = eval(row['redo_cs']) - if isinstance(e, type({})): - return ChangeSet(e) - - cs = ChangeSet() - for _cs in e: - cs.append(_cs) - - return cs + field= 'undo_cs' if undo else 'redo_cs' + return ChangeSet.from_list(eval(row[field])) def sync_with_server(name: str, operation: int) -> ChangeSet: diff --git a/api/s10_status.py b/api/s10_status.py index 8b48305..5375b67 100644 --- a/api/s10_status.py +++ b/api/s10_status.py @@ -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) -> SqlChangeSet: +def set_status_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Status(get_status(name, cs.operations[0]['link'])) raw_new = get_status(name, cs.operations[0]['link']) @@ -61,7 +61,7 @@ def set_status_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_status(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s11_patterns.py b/api/s11_patterns.py index 9c3d4b7..e6970ed 100644 --- a/api/s11_patterns.py +++ b/api/s11_patterns.py @@ -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) -> SqlChangeSet: +def set_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet: id = cs.operations[0]['id'] f_id = f"'{id}'" @@ -38,14 +38,14 @@ def set_pattern_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | { 'type': 'pattern' } | new undo_cs = g_update_prefix | { 'type': 'pattern' } | old - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_pattern(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_pattern_cache(name, cs)) -def add_pattern_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet: id = cs.operations[0]['id'] f_id = f"'{id}'" @@ -62,14 +62,14 @@ def add_pattern_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | { 'type': 'pattern' } | new undo_cs = g_delete_prefix | { 'type': 'pattern' } | { 'id': id } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_pattern(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_pattern_cache(name, cs)) -def delete_pattern_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_pattern_cache(name: str, cs: ChangeSet) -> DbChangeSet: id = cs.operations[0]['id'] f_id = f"'{id}'" @@ -86,7 +86,7 @@ def delete_pattern_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | { 'type': 'pattern' } | { 'id': id } undo_cs = g_add_prefix | { 'type': 'pattern' } | old - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_pattern(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s12_curves.py b/api/s12_curves.py index 117278f..7391e1c 100644 --- a/api/s12_curves.py +++ b/api/s12_curves.py @@ -26,7 +26,7 @@ def get_curve(name: str, id: str) -> dict[str, Any]: return d -def set_curve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet: id = cs.operations[0]['id'] f_id = f"'{id}'" @@ -60,14 +60,14 @@ def set_curve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | { 'type': 'curve' } | new undo_cs = g_update_prefix | { 'type': 'curve' } | old - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_curve(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_curve_cache(name, cs)) -def add_curve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet: id = cs.operations[0]['id'] f_id = f"'{id}'" @@ -88,14 +88,14 @@ def add_curve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | { 'type': 'curve' } | new undo_cs = g_delete_prefix | { 'type': 'curve' } | { 'id' : id } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_curve(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_curve_cache(name, cs)) -def delete_curve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_curve_cache(name: str, cs: ChangeSet) -> DbChangeSet: id = cs.operations[0]['id'] f_id = f"'{id}'" @@ -114,7 +114,7 @@ def delete_curve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | { 'type': 'curve' } | { 'id' : id } undo_cs = g_add_prefix | { 'type': 'curve' } | old - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_curve(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s13_controls.py b/api/s13_controls.py index 5ee1320..4e65cab 100644 --- a/api/s13_controls.py +++ b/api/s13_controls.py @@ -13,7 +13,7 @@ def get_control(name: str) -> dict[str, Any]: return { 'controls': ds } -def set_control_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_control_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = get_control(name) redo_sql = 'delete from controls;' @@ -27,7 +27,7 @@ def set_control_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | { 'type': 'control', 'controls': cs.operations[0]['controls'] } undo_cs = g_update_prefix | { 'type': 'control', 'controls': old['controls'] } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_control(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s14_rules.py b/api/s14_rules.py index 6d9e7d4..fb9c6a1 100644 --- a/api/s14_rules.py +++ b/api/s14_rules.py @@ -13,7 +13,7 @@ def get_rule(name: str) -> dict[str, Any]: return { 'rules': ds } -def set_rule_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_rule_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = get_rule(name) redo_sql = 'delete from rules;' @@ -27,7 +27,7 @@ def set_rule_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | { 'type': 'rule', 'rules': cs.operations[0]['rules'] } undo_cs = g_update_prefix | { 'type': 'rule', 'rules': old['rules'] } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_rule(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s15_energy.py b/api/s15_energy.py index 231a898..1329958 100644 --- a/api/s15_energy.py +++ b/api/s15_energy.py @@ -19,7 +19,7 @@ def get_energy(name: str) -> dict[str, Any]: return d -def set_energy_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_energy_cache(name: str, cs: ChangeSet) -> DbChangeSet: raw_old = get_energy(name) old = {} @@ -50,7 +50,7 @@ def set_energy_cache(name: str, cs: ChangeSet) -> SqlChangeSet: undo_sql += f"update energy set value = '{value}' where key = '{key}';" undo_cs |= { key: value } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_energy(name: str, cs: ChangeSet) -> ChangeSet: @@ -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) -> SqlChangeSet: +def set_pump_energy_cache(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']) @@ -124,7 +124,7 @@ def set_pump_energy_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_pump_energy(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s16_emitters.py b/api/s16_emitters.py index 2b0c25d..fda699f 100644 --- a/api/s16_emitters.py +++ b/api/s16_emitters.py @@ -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) -> SqlChangeSet: +def set_emitter_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Emitter(get_emitter(name, cs.operations[0]['junction'])) raw_new = get_emitter(name, cs.operations[0]['junction']) @@ -52,7 +52,7 @@ def set_emitter_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_emitter(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s17_quality.py b/api/s17_quality.py index d373c12..2df0ff1 100644 --- a/api/s17_quality.py +++ b/api/s17_quality.py @@ -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) -> SqlChangeSet: +def set_quality_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Quality(get_quality(name, cs.operations[0]['node'])) raw_new = get_quality(name, cs.operations[0]['node']) @@ -52,7 +52,7 @@ def set_quality_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_quality(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s18_sources.py b/api/s18_sources.py index 43a82ce..29c1fa7 100644 --- a/api/s18_sources.py +++ b/api/s18_sources.py @@ -44,7 +44,7 @@ class Source(object): return { 'type': self.type, 'node': self.node } -def set_source_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_source_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Source(get_source(name, cs.operations[0]['node'])) raw_new = get_source(name, cs.operations[0]['node']) @@ -61,14 +61,14 @@ def set_source_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_source(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_source_cache(name, cs)) -def add_source_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_source_cache(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});" @@ -77,14 +77,14 @@ def add_source_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_source(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_source_cache(name, cs)) -def delete_source_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_source_cache(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};" @@ -93,7 +93,7 @@ def delete_source_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_source(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s19_reactions.py b/api/s19_reactions.py index 500cf4e..6fbc358 100644 --- a/api/s19_reactions.py +++ b/api/s19_reactions.py @@ -22,7 +22,7 @@ def get_reaction(name: str) -> dict[str, Any]: return d -def set_reaction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_reaction_cache(name: str, cs: ChangeSet) -> DbChangeSet: raw_old = get_reaction(name) old = {} @@ -53,7 +53,7 @@ def set_reaction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: undo_sql += f"update reactions set value = '{value}' where key = '{key}';" undo_cs |= { key: value } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_reaction(name: str, cs: ChangeSet) -> ChangeSet: @@ -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) -> SqlChangeSet: +def set_pipe_reaction_cache(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']) @@ -118,7 +118,7 @@ def set_pipe_reaction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_pipe_reaction(name: str, cs: ChangeSet) -> ChangeSet: @@ -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) -> SqlChangeSet: +def set_tank_reaction_cache(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']) @@ -174,7 +174,7 @@ def set_tank_reaction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_tank_reaction(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s1_title.py b/api/s1_title.py index 59962a0..2db45e7 100644 --- a/api/s1_title.py +++ b/api/s1_title.py @@ -10,7 +10,7 @@ def get_title(name: str) -> dict[str, Any]: return { 'value': title['value'] } -def set_title_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_title_cache(name: str, cs: ChangeSet) -> DbChangeSet: new = cs.operations[0]['value'] old = get_title(name)['value'] @@ -20,7 +20,7 @@ def set_title_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | { 'type': 'title', 'value': new } undo_cs = g_update_prefix | { 'type': 'title', 'value': old } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_title(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s20_mixing.py b/api/s20_mixing.py index 6432571..f1ee3ce 100644 --- a/api/s20_mixing.py +++ b/api/s20_mixing.py @@ -40,7 +40,7 @@ class Mixing(object): return { 'type': self.type, 'tank': self.tank } -def set_mixing_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_mixing_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Mixing(get_mixing(name, cs.operations[0]['tank'])) raw_new = get_mixing(name, cs.operations[0]['tank']) @@ -57,14 +57,14 @@ def set_mixing_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_mixing(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_mixing_cache(name, cs)) -def add_mixing_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_mixing_cache(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});" @@ -73,14 +73,14 @@ def add_mixing_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_mixing(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_mixing_cache(name, cs)) -def delete_mixing_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_mixing_cache(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};" @@ -89,7 +89,7 @@ def delete_mixing_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_mixing(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s21_times.py b/api/s21_times.py index 11cc6fc..fd67a80 100644 --- a/api/s21_times.py +++ b/api/s21_times.py @@ -29,7 +29,7 @@ def get_time(name: str) -> dict[str, Any]: return d -def set_time_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_time_cache(name: str, cs: ChangeSet) -> DbChangeSet: raw_old = get_time(name) old = {} @@ -60,7 +60,7 @@ def set_time_cache(name: str, cs: ChangeSet) -> SqlChangeSet: undo_sql += f"update times set value = '{value}' where key = '{key}';" undo_cs |= { key: value } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_time(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s23_options.py b/api/s23_options.py index 8ad5612..50c5f9b 100644 --- a/api/s23_options.py +++ b/api/s23_options.py @@ -67,7 +67,7 @@ def get_option(name: str) -> dict[str, Any]: return d -def set_option_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_option_cache(name: str, cs: ChangeSet) -> DbChangeSet: raw_old = get_option(name) old = {} @@ -98,7 +98,7 @@ def set_option_cache(name: str, cs: ChangeSet) -> SqlChangeSet: undo_sql += f"update options set value = '{value}' where key = '{key}';" undo_cs |= { key: value } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_option(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s25_vertices.py b/api/s25_vertices.py index dac67e5..bb0b551 100644 --- a/api/s25_vertices.py +++ b/api/s25_vertices.py @@ -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) -> SqlChangeSet: +def set_vertex_cache(name: str, cs: ChangeSet) -> DbChangeSet: link = cs.operations[0]['link'] old = get_vertex(name, link) @@ -40,43 +40,38 @@ def set_vertex_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = { 'type': 'vertex' } | new undo_cs = { 'type': 'vertex' } | old - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) - - -def add_vertex_cache(name: str, cs: ChangeSet) -> SqlChangeSet: - result = set_vertex_cache(name, cs) - result.redo_cs |= g_add_prefix - result.undo_cs |= g_delete_prefix - return result - - -def delete_vertex_cache(name: str, cs: ChangeSet) -> SqlChangeSet: - cs.operations[0]['coords'] = [] - result = set_vertex_cache(name, cs) - result.redo_cs |= g_delete_prefix - result.undo_cs |= g_add_prefix - return result + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_vertex(name: str, cs: ChangeSet) -> ChangeSet: result = set_vertex_cache(name, cs) - result.redo_cs |= g_update_prefix - result.undo_cs |= g_update_prefix + result.redo_cs[0] |= g_update_prefix + result.undo_cs[0] |= g_update_prefix return execute_command(name, result) -def add_vertex(name: str, cs: ChangeSet) -> ChangeSet: +def add_vertex_cache(name: str, cs: ChangeSet) -> DbChangeSet: result = set_vertex_cache(name, cs) - result.redo_cs |= g_add_prefix - result.undo_cs |= g_delete_prefix + 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: + cs.operations[0]['coords'] = [] + result = set_vertex_cache(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) return execute_command(name, result) def delete_vertex(name: str, cs: ChangeSet) -> ChangeSet: - cs.operations[0]['coords'] = [] - result = set_vertex_cache(name, cs) - result.redo_cs |= g_delete_prefix - result.undo_cs |= g_add_prefix + result = delete_vertex_cache(name, cs) return execute_command(name, result) diff --git a/api/s26_labels.py b/api/s26_labels.py index 42c84cd..784c815 100644 --- a/api/s26_labels.py +++ b/api/s26_labels.py @@ -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) -> SqlChangeSet: +def set_label_cache(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']) @@ -60,14 +60,14 @@ def set_label_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_label(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_label_cache(name, cs)) -def add_label_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_label_cache(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});" @@ -76,14 +76,14 @@ def add_label_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_xy_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_label(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_label_cache(name, cs)) -def delete_label_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_label_cache(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};" @@ -92,7 +92,7 @@ def delete_label_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_xy_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_label(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s27_backdrop.py b/api/s27_backdrop.py index 6509da4..8c1b0f7 100644 --- a/api/s27_backdrop.py +++ b/api/s27_backdrop.py @@ -10,7 +10,7 @@ def get_backdrop(name: str) -> dict[str, Any]: return { 'content': e['content'] } -def set_backdrop_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_backdrop_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = get_backdrop(name) redo_sql = f"update backdrop set content = '{cs.operations[0]['content']}' where content = '{old['content']}';" @@ -19,7 +19,7 @@ def set_backdrop_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | { 'type': 'backdrop', 'content': cs.operations[0]['content'] } undo_cs = g_update_prefix | { 'type': 'backdrop', 'content': old['content'] } - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_backdrop(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s2_junctions.py b/api/s2_junctions.py index c2275fe..2366a59 100644 --- a/api/s2_junctions.py +++ b/api/s2_junctions.py @@ -51,7 +51,7 @@ class Junction(object): return { 'type': self.type, 'id': self.id } -def set_junction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_junction_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Junction(get_junction(name, cs.operations[0]['id'])) raw_new = get_junction(name, cs.operations[0]['id']) @@ -71,14 +71,14 @@ def set_junction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_junction(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_junction_cache(name, cs)) -def add_junction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_junction_cache(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});" @@ -92,14 +92,14 @@ def add_junction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_junction(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_junction_cache(name, cs)) -def delete_junction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_junction_cache(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};" @@ -113,7 +113,7 @@ def delete_junction_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_junction(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s3_reservoirs.py b/api/s3_reservoirs.py index 01715ec..ef43e51 100644 --- a/api/s3_reservoirs.py +++ b/api/s3_reservoirs.py @@ -47,7 +47,7 @@ class Reservoir(object): return { 'type': self.type, 'id': self.id } -def set_reservoir_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_reservoir_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Reservoir(get_reservoir(name, cs.operations[0]['id'])) raw_new = get_reservoir(name, cs.operations[0]['id']) @@ -67,14 +67,14 @@ def set_reservoir_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_reservoir(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_reservoir_cache(name, cs)) -def add_reservoir_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_reservoir_cache(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});" @@ -88,14 +88,14 @@ def add_reservoir_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_reservoir(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_reservoir_cache(name, cs)) -def delete_reservoir_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_reservoir_cache(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};" @@ -109,7 +109,7 @@ def delete_reservoir_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_reservoir(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s4_tanks.py b/api/s4_tanks.py index 6662034..e01df3b 100644 --- a/api/s4_tanks.py +++ b/api/s4_tanks.py @@ -75,7 +75,7 @@ class Tank(object): return { 'type': self.type, 'id': self.id } -def set_tank_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_tank_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Tank(get_tank(name, cs.operations[0]['id'])) raw_new = get_tank(name, cs.operations[0]['id']) @@ -95,14 +95,14 @@ def set_tank_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_tank(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_tank_cache(name, cs)) -def add_tank_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_tank_cache(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});" @@ -116,14 +116,14 @@ def add_tank_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_tank(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_tank_cache(name, cs)) -def delete_tank_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_tank_cache(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};" @@ -137,7 +137,7 @@ def delete_tank_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_tank(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s5_pipes.py b/api/s5_pipes.py index afabea7..2d3ea1b 100644 --- a/api/s5_pipes.py +++ b/api/s5_pipes.py @@ -61,7 +61,7 @@ class Pipe(object): return { 'type': self.type, 'id': self.id } -def set_pipe_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_pipe_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Pipe(get_pipe(name, cs.operations[0]['id'])) raw_new = get_pipe(name, cs.operations[0]['id']) @@ -78,14 +78,14 @@ def set_pipe_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_pipe(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_pipe_cache(name, cs)) -def add_pipe_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_pipe_cache(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});" @@ -97,14 +97,14 @@ def add_pipe_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_pipe(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_pipe_cache(name, cs)) -def delete_pipe_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_pipe_cache(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};" @@ -116,7 +116,7 @@ def delete_pipe_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_pipe(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s6_pumps.py b/api/s6_pumps.py index 5a07be8..715d59c 100644 --- a/api/s6_pumps.py +++ b/api/s6_pumps.py @@ -52,7 +52,7 @@ class Pump(object): return { 'type': self.type, 'id': self.id } -def set_pump_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_pump_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Pump(get_pump(name, cs.operations[0]['id'])) raw_new = get_pump(name, cs.operations[0]['id']) @@ -69,14 +69,14 @@ def set_pump_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_pump(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_pump_cache(name, cs)) -def add_pump_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_pump_cache(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});" @@ -88,14 +88,14 @@ def add_pump_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_pump(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_pump_cache(name, cs)) -def delete_pump_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_pump_cache(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};" @@ -107,7 +107,7 @@ def delete_pump_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_pump(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s7_valves.py b/api/s7_valves.py index 659a7e4..241b96d 100644 --- a/api/s7_valves.py +++ b/api/s7_valves.py @@ -60,7 +60,7 @@ class Valve(object): return { 'type': self.type, 'id': self.id } -def set_valve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def set_valve_cache(name: str, cs: ChangeSet) -> DbChangeSet: old = Valve(get_valve(name, cs.operations[0]['id'])) raw_new = get_valve(name, cs.operations[0]['id']) @@ -77,14 +77,14 @@ def set_valve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_valve(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, set_valve_cache(name, cs)) -def add_valve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def add_valve_cache(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});" @@ -96,14 +96,14 @@ def add_valve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_add_prefix | new.as_dict() undo_cs = g_delete_prefix | new.as_id_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def add_valve(name: str, cs: ChangeSet) -> ChangeSet: return execute_command(name, add_valve_cache(name, cs)) -def delete_valve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: +def delete_valve_cache(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};" @@ -115,7 +115,7 @@ def delete_valve_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_delete_prefix | old.as_id_dict() undo_cs = g_add_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def delete_valve(name: str, cs: ChangeSet) -> ChangeSet: diff --git a/api/s8_tags.py b/api/s8_tags.py index a191eca..c54dfef 100644 --- a/api/s8_tags.py +++ b/api/s8_tags.py @@ -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) -> SqlChangeSet: +def set_tag_cache(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']) @@ -72,7 +72,7 @@ def set_tag_cache(name: str, cs: ChangeSet) -> SqlChangeSet: redo_cs = g_update_prefix | new.as_dict() undo_cs = g_update_prefix | old.as_dict() - return SqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs) + return DbChangeSet(redo_sql, undo_sql, [redo_cs], [undo_cs]) def set_tag(name: str, cs: ChangeSet) -> ChangeSet: