def _compute_diffs(self):
prev_db_value = self.previous_version.serializable_value(
self.field.name)
current_db_value = self.current_version.serializable_value(
self.field.name)
related_model = self.field.remote_field.model
related_dataloader_cls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(
related_model)
dataloader = related_dataloader_cls(self.dataloader_cache)
if prev_db_value is None:
previous_instance = None
current_instance = yield dataloader.load(current_db_value)
elif current_db_value is None:
previous_instance = yield dataloader.load(prev_db_value)
current_instance = None
else:
previous_instance, current_instance = yield dataloader.load_many(
[prev_db_value, current_db_value])
joint, before, after = text_compare_inline(
get_str_val(previous_instance),
get_str_val(current_instance),
)
return joint, before, after
def resolve_edited_by(parent, info):
user_id = parent["instance"].edited_by_id
if user_id is None:
return None
User = get_user_model()
UserDataloader = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(
User)
user_dataloader = UserDataloader(info.context.dataloaders)
return user_dataloader.load(user_id)
def resolve_right_version(parent, info):
model = parent["model"]
id = parent["right_id"]
if id is None:
return None
LoaderCls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(model)
version = yield LoaderCls(info.context.dataloaders).load(id)
return {"instance": version}
def foreign_key_display_value(version, field_obj, dataloader_cache):
related_id = version.serializable_value(field_obj.name)
if related_id is None:
return tm("empty")
related_model = field_obj.related_model
related_dataloader_cls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(
related_model)
related_dataloader = related_dataloader_cls(dataloader_cache)
related_instance = yield related_dataloader.load(related_id)
return get_str_val(related_instance)
def m2m_display_value(version, field_obj, dataloader_cache):
id_list = version.get_m2m_ids(field_obj.name)
if not id_list:
return tm("empty")
related_model = field_obj.related_model
related_dataloader_cls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(
related_model)
related_dataloader = related_dataloader_cls(dataloader_cache)
related_instances = yield related_dataloader.load_many(id_list)
sorted_names = sorted([inst.name for inst in related_instances])
return "".join([f"<p>{name}</p>" for name in sorted_names])
def test_pk_loader_factory(dataloader_test):
b1 = BookFactory()
b2 = BookFactory()
dataloader_cache = {}
BookLoaderCls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(Book)
with assert_max_queries(0):
book1_prom = BookLoaderCls(dataloader_cache).load(b1.pk)
book2_prom = BookLoaderCls(dataloader_cache).load(b2.pk)
with assert_max_queries(1):
resolved_b1, resolved_b2 = Promise.all([book1_prom, book2_prom]).get()
assert b1 == resolved_b1
assert b2 == resolved_b2
def _compute_diffs(self):
prev_id_list = self.previous_version.serializable_value(
self.field.name)
current_id_list = self.current_version.serializable_value(
self.field.name)
related_model = self.field.related_model
related_dataloader_cls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(
related_model)
related_dataloader = related_dataloader_cls(self.dataloader_cache)
prev_instances, current_instances = yield Promise.all([
related_dataloader.load_many(prev_id_list),
related_dataloader.load_many(current_id_list),
])
get_name = lambda inst: inst.name
before_list = sorted([*prev_instances], key=get_name)
after_list = sorted([*current_instances], key=get_name)
joint, before, after = list_diff(before_list, after_list)
return (joint, before, after)
def resolve_diffs(parent, info):
if not parent["right_id"]:
return [DeleteDiff()]
if not parent["left_id"]:
return [CreateDiff()]
history_model = parent["model"]
live_model = history_model.live_model
fields_to_diff = get_diffable_fields_for_model(live_model)
LoaderCls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(
history_model)
loader_inst = LoaderCls(info.context.dataloaders)
left_ver = yield loader_inst.load(parent["left_id"])
right_ver = yield loader_inst.load(parent["right_id"])
field_diff_objs = []
for f in fields_to_diff:
field_diff_obj = get_field_diff_for_version_pair(
right_ver, left_ver, f, info.context.dataloaders)
if field_diff_obj is not None:
field_diff_objs.append(field_diff_obj)
return field_diff_objs
def resolve_eternal(parent, info):
model = parent["model"].live_model
id = parent["eternal_id"]
LoaderCls = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(model)
return LoaderCls(info.context.dataloaders).load(id)
def resolve_edited_by(parent, info):
UserModel = get_user_model()
UserDataloader = PrimaryKeyDataLoaderFactory.get_model_by_id_loader(UserModel)
user_dataloader = UserDataloader(info.context.dataloaders)
return user_dataloader.load(parent["instance"].edited_by_id)