def filtering(self, table: str, kwargs: ImmutableMultiDict) -> dict:
model = models.get(table, models["Device"])
properties = table_properties[table]
operator = and_ if kwargs.get("form[operator]", "all") == "all" else or_
try:
order_property = properties[int(kwargs["order[0][column]"])]
except IndexError:
order_property = "name"
order = getattr(getattr(model, order_property), kwargs["order[0][dir]"])()
constraints = []
for property in filtering_properties[table]:
value = kwargs.get(f"form[{property}]")
if not value:
continue
filter = kwargs.get(f"form[{property}_filter]")
if filter == "equality":
constraint = getattr(model, property) == value
elif filter == "inclusion" or DIALECT == "sqlite":
constraint = getattr(model, property).contains(value)
else:
regex_operator = "regexp" if DIALECT == "mysql" else "~"
constraint = getattr(model, property).op(regex_operator)(value)
constraints.append(constraint)
relation = table.capitalize() if table != "configuration" else "Device"
for related_model, relation_properties in relationships[relation].items():
relation_ids = [
int(id) for id in kwargs.getlist(f"form[{related_model}][]")
]
if not relation_ids:
continue
if relation_properties["list"]:
filter = kwargs.get(f"form[{related_model}_filter]")
constraint = getattr(model, related_model).any(
models[relation_properties["model"]].id.in_(relation_ids)
)
if filter == "not_any":
constraint = ~constraint
else:
constraint = or_(
getattr(model, related_model).has(id=relation_id)
for relation_id in relation_ids
)
constraints.append(constraint)
result = Session.query(model).filter(operator(*constraints)).order_by(order)
try:
return {
"draw": int(kwargs["draw"]),
"recordsTotal": Session.query(func.count(model.id)).scalar(),
"recordsFiltered": get_query_count(result),
"data": [
[getattr(obj, property) for property in properties]
+ obj.generate_row(table)
for obj in result.limit(int(kwargs["length"]))
.offset(int(kwargs["start"]))
.all()
],
}
except InterfaceError:
return {"error": "Filtering error: wrong input"}
def filtering(self, table: str, kwargs: ImmutableMultiDict) -> dict:
model = models.get(table, models["Device"])
properties = table_properties[table]
operator = and_ if kwargs.get("form[operator]",
"all") == "all" else or_
try:
order_property = properties[int(kwargs["order[0][column]"])]
except IndexError:
order_property = "name"
order = getattr(getattr(model, order_property),
kwargs["order[0][dir]"])()
constraints = []
for property in filtering_properties[table]:
value = kwargs.get(f"form[{property}]")
if not value:
continue
filter = kwargs.get(f"form[{property}_filter]")
if filter == "equality":
constraint = getattr(model, property) == value
elif filter == "inclusion" or DIALECT == "sqlite":
constraint = getattr(model, property).contains(value)
else:
regex_operator = "regexp" if DIALECT == "mysql" else "~"
constraint = getattr(model, property).op(regex_operator)(value)
constraints.append(constraint)
result = Session.query(model).filter(
operator(*constraints)).order_by(order)
if table in ("device", "link", "configuration"):
pools = [int(id) for id in kwargs.getlist("form[pools][]")]
if pools:
result = result.filter(
model.pools.any(models["pool"].id.in_(pools)))
if table == "service":
workflows = [int(id) for id in kwargs.getlist("form[workflows][]")]
if workflows:
result = result.filter(
model.workflows.any(models["workflow"].id.in_(workflows)))
if table == "workflow":
services = [int(id) for id in kwargs.getlist("form[services][]")]
if services:
result = result.filter(
model.jobs.any(models["service"].id.in_(services)))
try:
return {
"draw":
int(kwargs["draw"]),
"recordsTotal":
len(Session.query(model).all()),
"recordsFiltered":
len(result.all()),
"data": [[getattr(obj, property)
for property in properties] + obj.generate_row(table)
for obj in result.limit(int(kwargs["length"])).offset(
int(kwargs["start"])).all()],
}
except InterfaceError:
return {"error": "Filtering error: wrong input"}
def table_filtering(self, table, **kwargs):
model = models[table]
ordering = getattr(
getattr(
model,
kwargs["columns"][int(kwargs["order"][0]["column"])]["data"],
None,
),
kwargs["order"][0]["dir"],
None,
)
constraints = self.build_filtering_constraints(table, **kwargs)
if table == "result":
constraints.append(
getattr(
models["result"],
"device"
if kwargs["instance"]["type"] == "device" else "service",
).has(id=kwargs["instance"]["id"]))
if kwargs.get("runtime"):
constraints.append(
models["result"].parent_runtime == kwargs["runtime"])
if table == "service":
workflow_id = kwargs["form"].get("workflow-filtering")
if workflow_id:
constraints.append(models["service"].workflows.any(
models["workflow"].id == int(workflow_id)))
else:
if kwargs["form"].get("parent-filtering", "true") == "true":
constraints.append(~models["service"].workflows.any())
if table == "run":
constraints.append(
models["run"].parent_runtime == models["run"].runtime)
result = Session.query(model).filter(and_(*constraints))
if ordering:
result = result.order_by(ordering())
return {
"draw":
int(kwargs["draw"]),
"recordsTotal":
Session.query(func.count(model.id)).scalar(),
"recordsFiltered":
get_query_count(result),
"data": [
obj.table_properties(**kwargs) for obj in result.limit(
int(kwargs["length"])).offset(int(kwargs["start"])).all()
],
}
def delete(model: str, **kwargs: Any) -> dict:
instance = Session.query(models[model]).filter_by(**kwargs).first()
if hasattr(instance, "type") and instance.type == "Task":
instance.delete_task()
serialized_instance = instance.serialized
Session.delete(instance)
return serialized_instance
def delete(model, allow_none=False, **kwargs):
instance = Session.query(models[model]).filter_by(**kwargs).first()
if allow_none and not instance:
return None
instance.delete()
serialized_instance = instance.serialized
Session.delete(instance)
return serialized_instance
def fetch(model, allow_none=False, all_matches=False, **kwargs):
query = Session.query(models[model]).filter_by(**kwargs)
result = query.all() if all_matches else query.first()
if result or allow_none:
return result
else:
raise Exception(f"There is no {model} in the database "
f"with the following characteristics: {kwargs}")
def delete(model: str, allow_none: Any = False, **kwargs: Any) -> Any:
instance = Session.query(models[model]).filter_by(**kwargs).first()
if allow_none and not instance:
return None
if hasattr(instance, "type") and instance.type == "Task":
instance.delete_task()
serialized_instance = instance.serialized
Session.delete(instance)
return serialized_instance
def table_filtering(self, table, **kwargs):
model, properties = models[table], table_properties[table]
operator = and_ if kwargs["form"].get("operator",
"all") == "all" else or_
column_index = int(kwargs["order"][0]["column"])
if column_index < len(properties):
order_property = getattr(model, properties[column_index])
order_function = getattr(order_property, kwargs["order"][0]["dir"],
None)
else:
order_function = None
constraints = self.build_filtering_constraints(table, **kwargs)
if table == "result":
if kwargs["instance"]["type"] == "workflow":
constraints.append(
or_(
models["result"].service.has(
id=kwargs["instance"]["id"]),
models["result"].workflow.has(
id=kwargs["instance"]["id"]),
))
else:
constraints.append(
models["result"].service.has(id=kwargs["instance"]["id"]))
if kwargs.get("runtime"):
constraints.append(
models["result"].parent_runtime == kwargs["runtime"])
result = Session.query(model).filter(operator(*constraints))
if order_function:
result = result.order_by(order_function())
return {
"draw":
int(kwargs["draw"]),
"recordsTotal":
Session.query(func.count(model.id)).scalar(),
"recordsFiltered":
get_query_count(result),
"data": [[
getattr(obj, f"table_{property}", getattr(obj, property))
for property in properties
] + obj.generate_row(table) for obj in result.limit(
int(kwargs["length"])).offset(int(kwargs["start"])).all()],
}
def visible(cls) -> List:
if cls.__tablename__ == "Pool" and user.pools:
return user.pools
elif cls.__tablename__ in ("Device", "Link") and user.pools:
objects: set = set()
for pool in user.pools:
objects |= set(getattr(pool, f"{cls.class_type}s"))
return list(objects)
else:
return Session.query(cls).all()
def view_filtering(self, **kwargs):
return {
obj_type: [
d.view_properties
for d in Session.query(models[obj_type]).filter(
and_(*self.build_filtering_constraints(obj_type, **
form))).all()
]
for obj_type, form in kwargs.items()
}
def table_filtering(self, table, kwargs):
model, properties = models[table], table_properties[table]
operator = and_ if kwargs.get("form[operator]",
"all") == "all" else or_
column_index = int(kwargs["order[0][column]"])
if column_index < len(properties):
order_property = getattr(model, properties[column_index])
order_function = getattr(order_property, kwargs["order[0][dir]"],
None)
else:
order_function = None
constraints = self.build_filtering_constraints(table, kwargs)
if table == "result":
constraints.append(
getattr(
models["result"],
"service" if "service" in kwargs["instance[type]"] else
kwargs["instance[type]"],
).has(id=kwargs["instance[id]"]))
if kwargs.get("service[runtime]"):
constraints.append(models["result"].parent_runtime ==
kwargs.get("service[runtime]"))
elif table == "configuration" and kwargs.get("instance[id]"):
constraints.append(
getattr(models[table],
"device").has(id=kwargs["instance[id]"]))
result = Session.query(model).filter(operator(*constraints))
if order_function:
result = result.order_by(order_function())
return {
"draw":
int(kwargs["draw"]),
"recordsTotal":
Session.query(func.count(model.id)).scalar(),
"recordsFiltered":
get_query_count(result),
"data": [[
getattr(obj, f"table_{property}", getattr(obj, property))
for property in properties
] + obj.generate_row(table) for obj in result.limit(
int(kwargs["length"])).offset(int(kwargs["start"])).all()],
}
def multiselect_filtering(self, type, **params):
model = models[type]
results = Session.query(model).filter(model.name.contains(params.get("term")))
return {
"items": [
{"text": result.ui_name, "id": str(result.id)}
for result in results.limit(10)
.offset((int(params["page"]) - 1) * 10)
.all()
],
"total_count": results.count(),
}
def result_log_deletion(self, **kwargs):
date_time_object = datetime.strptime(kwargs["date_time"],
"%d/%m/%Y %H:%M:%S")
date_time_string = date_time_object.strftime("%Y-%m-%d %H:%M:%S.%f")
for model in kwargs["deletion_types"]:
if model == "result":
field_name = "runtime"
elif model == "changelog":
field_name = "time"
session_query = Session.query(models[model]).filter(
getattr(models[model], field_name) < date_time_string)
session_query.delete(synchronize_session=False)
Session.commit()
def init_parameters(self):
parameters = Session.query(models["parameters"]).one_or_none()
if not parameters:
parameters = models["parameters"]()
parameters.update(
**{
property: getattr(self, property)
for property in model_properties["parameters"]
if hasattr(self, property)
})
Session.add(parameters)
Session.commit()
else:
for parameter in parameters.get_properties():
setattr(self, parameter, getattr(parameters, parameter))
def recursive_search(run: "Run"):
if not run:
return None
query = Session.query(models["run"]).filter(
models["run"].parent_runtime == run.parent_runtime)
if workflow or self.workflow:
name = workflow or self.workflow.name
query.filter(models["run"].workflow.has(
models["workflow"].name == name))
runs = filter_run(query, "scoped_name") or filter_run(
query, "name")
results = list(filter(None, [run.result(device) for run in runs]))
if not results:
return recursive_search(run.restart_run)
else:
return results.pop().result
def view_filtering(self, filter_type: str, **kwargs: Any) -> List[dict]:
obj_type = filter_type.split("_")[0]
model = models[obj_type]
constraints = []
for property in filtering_properties[obj_type]:
value = kwargs[property]
if not value:
continue
filter = kwargs.get(f"form[{property}_filter]")
if filter == "equality":
constraint = getattr(model, property) == value
elif filter == "inclusion" or DIALECT == "sqlite":
constraint = getattr(model, property).contains(value)
else:
operator = "regexp" if DIALECT == "mysql" else "~"
constraint = getattr(model, property).op(operator)(value)
constraints.append(constraint)
result = Session.query(model).filter(and_(*constraints))
pools = [int(id) for id in kwargs["pools"]]
if pools:
result = result.filter(model.pools.any(models["pool"].id.in_(pools)))
return [d.view_properties for d in result.all()]
def count(model: str, **kwargs: Any) -> Tuple[Any]:
return Session.query(func.count(
models[model].id)).filter_by(**kwargs).scalar()
def update_parameters(self, **kwargs):
Session.query(models["parameters"]).one().update(**kwargs)
self.__dict__.update(**kwargs)
def count(model, **kwargs):
return Session.query(func.count(models[model].id)).filter_by(**kwargs).scalar()
def view_filtering(self, obj_type, **kwargs):
constraints = self.build_filtering_constraints(obj_type, **kwargs)
result = Session.query(models[obj_type]).filter(and_(*constraints))
return [d.view_properties for d in result.all()]
def get_relationship_count(obj: Any, relation: str) -> int:
related_model = models[relationships[obj.type][relation]["model"]]
return Session.query(func.count(
related_model.id)).with_parent(obj).scalar()
def config(self) -> dict:
parameters = Session.query(models["Parameters"]).one_or_none()
return parameters.get_properties() if parameters else {}
def fetch_all(model: str) -> Tuple[Any]:
return Session.query(models[model]).all()