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

Accept Merge Request #120: (api -> master)

Browse Source 
Merge Request: Code refactor for change set

Created By: @王琼钰
Accepted By: @王琼钰
URL: https://tjwater.coding.net/p/tjwatercloud/d/TJWaterServer/git/merge/120
This commit is contained in:
王琼钰
2022-12-17 10:10:03 +08:00
parent dcf3398d47 4238a550f9
commit 4ab35709a8
27 changed files with 152 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
api/command.py
View File

@@ -290,7 +290,7 @@ def execute_batch_commands(name: str, cs: ChangeSet) -> ChangeSet:
return result
def cache_add_command(name: str, cs: ChangeSet) -> SqlChangeSet | None:
def cache_add_command(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == _s1_title:
@@ -359,7 +359,7 @@ def cache_add_command(name: str, cs: ChangeSet) -> SqlChangeSet | None:
return None
def cache_update_command(name: str, cs: ChangeSet) -> SqlChangeSet | None:
def cache_update_command(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == _s1_title:
@@ -378,8 +378,8 @@ def cache_update_command(name: str, cs: ChangeSet) -> SqlChangeSet | None:
return set_valve_cache(name, cs)
elif type == _s8_tag:
return set_tag_cache(name, cs)
elif type == _s9_demand: # exception, batch command ...
return None
elif type == _s9_demand:
return set_demand_cache(name, cs)
elif type == _s10_status:
return set_status_cache(name, cs)
elif type == _s11_pattern:
@@ -428,7 +428,7 @@ def cache_update_command(name: str, cs: ChangeSet) -> SqlChangeSet | None:
return None
def cache_delete_command(name: str, cs: ChangeSet) -> SqlChangeSet | None:
def cache_delete_command(name: str, cs: ChangeSet) -> DbChangeSet | None:
type = cs.operations[0]['type']
if type == _s1_title:
@@ -498,10 +498,10 @@ def cache_delete_command(name: str, cs: ChangeSet) -> SqlChangeSet | None:
def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
redo_sql_s = []
undo_sql_s = []
redo_cs_s = []
undo_cs_s = []
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:
@@ -513,8 +513,6 @@ def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
r = cache_add_command(name, ChangeSet(op))
elif operation == API_UPDATE:
r = cache_update_command(name, ChangeSet(op))
if op['type'] == 'demand':
r = set_demand_cache(name, ChangeSet(op))
elif operation == API_DELETE:
r = cache_delete_command(name, ChangeSet(op))
@@ -522,18 +520,10 @@ def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
print(f'ERROR: Build [{op}] returns None')
return ChangeSet()
if op['type'] == 'demand':
redo_sql_s.append(r.redo_sql)
undo_sql_s.append(r.undo_sql)
for d in r.redo_cs:
redo_cs_s.append(d)
for d in r.undo_cs.reverse(): # need reverse again...
undo_cs_s.append(r.undo_cs)
else:
redo_sql_s.append(r.redo_sql)
undo_sql_s.append(r.undo_sql)
redo_cs_s.append(r.redo_cs)
undo_cs_s.append(r.undo_cs)
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
@@ -546,6 +536,6 @@ def execute_batch_command(name: str, cs: ChangeSet) -> ChangeSet:
undo_cs_s.reverse()
try:
return execute_batch(name, redo_sql, undo_sql, redo_cs_s, undo_cs_s)
return execute_command(name, DbChangeSet(redo_sql, undo_sql, redo_cs_s, undo_cs_s))
except:
return ChangeSet()

82
api/operation.py
View File

@@ -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:

4
api/s10_status.py
View File

@@ -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:

12
api/s11_patterns.py
View File

@@ -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:

12
api/s12_curves.py
View File

@@ -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:

4
api/s13_controls.py
View File

@@ -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:

4
api/s14_rules.py
View File

@@ -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:

8
api/s15_energy.py
View File

@@ -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:

4
api/s16_emitters.py
View File

@@ -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:

4
api/s17_quality.py
View File

@@ -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:

12
api/s18_sources.py
View File

@@ -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:

12
api/s19_reactions.py
View File

@@ -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:

4
api/s1_title.py
View File

@@ -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:

12
api/s20_mixing.py
View File

@@ -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:

4
api/s21_times.py
View File

@@ -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:

4
api/s23_options.py
View File

@@ -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:

47
api/s25_vertices.py
View File

@@ -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)

12
api/s26_labels.py
View File

@@ -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:

4
api/s27_backdrop.py
View File

@@ -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:

12
api/s2_junctions.py
View File

@@ -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:

12
api/s3_reservoirs.py
View File

@@ -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:

12
api/s4_tanks.py
View File

@@ -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:

12
api/s5_pipes.py
View File

@@ -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:

12
api/s6_pumps.py
View File

@@ -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:

12
api/s7_valves.py
View File

@@ -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:

4
api/s8_tags.py
View File

@@ -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:

15
api/s9_demands.py
View File

@@ -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) -> BatchSqlChangeSet:
def set_demand_cache(name: str, cs: ChangeSet) -> DbChangeSet:
junction = cs.operations[0]['junction']
old = get_demand(name, junction)
new = { 'junction': junction, 'demands': [] }
@@ -40,7 +40,6 @@ def set_demand_cache(name: str, cs: ChangeSet) -> BatchSqlChangeSet:
redo_sql += f"\ninsert into demands (junction, demand, pattern, category) values ({f_junction}, {f_demand}, {f_pattern}, {f_category});"
new['demands'].append({ 'demand': demand, 'pattern': pattern, 'category': category })
undo_sql = ''
_undo_sql = f"delete from demands where junction = {f_junction};"
for r in old['demands']:
demand = float(r['demand'])
@@ -56,7 +55,7 @@ def set_demand_cache(name: str, cs: ChangeSet) -> BatchSqlChangeSet:
undo_cs = []
undo_cs.append(g_update_prefix | { 'type': 'demand' } | old)
cache = None | SqlChangeSet
cache = None
if len(cs.operations[0]['demands']) > 0:
r = cs.operations[0]['demands'][0]
demand = float(r['demand'])
@@ -65,6 +64,7 @@ def set_demand_cache(name: str, cs: ChangeSet) -> BatchSqlChangeSet:
else:
cache = set_junction_cache(name, ChangeSet({'id': junction, 'demand': None, 'pattern': None}))
undo_sql = ''
if cache != None:
redo_sql += '\n'
redo_sql += cache.redo_sql
@@ -73,17 +73,16 @@ def set_demand_cache(name: str, cs: ChangeSet) -> BatchSqlChangeSet:
undo_sql += '\n'
undo_sql += _undo_sql
redo_cs.append(cache.redo_cs)
redo_cs += cache.redo_cs
undo_cs.append(cache.undo_cs)
undo_cs += cache.undo_cs
undo_cs.reverse()
return BatchSqlChangeSet(redo_sql, undo_sql, redo_cs, undo_cs)
return DbChangeSet(redo_sql, undo_sql, redo_cs, undo_cs)
def set_demand(name: str, cs: ChangeSet) -> ChangeSet:
css = set_demand_cache(name, cs)
return execute_batch(name, css.redo_sql, css.undo_sql, css.redo_cs, css.undo_cs)
return execute_command(name, set_demand_cache(name, cs))
class InpDemand: