def discover_choosers():
logger.debug("Discovering choosers for model fields...")
# ~ logger.debug("Instantiate model reports...")
for model in get_models():
# ~ n = 0
allfields = model._meta.fields
for field in allfields:
check_for_chooser(model, field)
def setup_params_choosers(self):
if self.parameters:
for k, fld in self.parameters.items():
if isinstance(fld, models.ForeignKey):
msg = "Invalid target %s in parameter {} of {}".format(k, self)
fld.remote_field.model = resolve_model(fld.remote_field.model,
strict=msg)
fields.set_default_verbose_name(fld)
check_for_chooser(self, fld)
def make_remote_field(model, name):
parts = name.split('__')
if len(parts) == 1:
return
# It's going to be a RemoteField
# logger.warning("20151203 RemoteField %s in %s", name, cls)
from lino.core import store
cls = model
field_chain = []
editable = False
leaf_chooser = None
for n in parts:
if model is None:
return
# raise Exception(
# "Invalid remote field {0} for {1}".format(name, cls))
if isinstance(model, str):
# Django 1.9 no longer resolves the
# rel.model of ForeignKeys on abstract
# models, so we do it here.
model = resolve_model(model)
# logger.warning("20151203 %s", model)
fld = model.get_data_elem(n)
if fld is None:
return
# raise Exception(
# "Invalid RemoteField %s.%s (no field %s in %s)" %
# (full_model_name(model), name, n, full_model_name(model)))
# make sure that the atomizer gets created.
store.get_atomizer(model, fld, fld.name)
if isinstance(fld, VirtualField):
fld.lino_resolve_type()
leaf_chooser = choosers.check_for_chooser(model, fld)
field_chain.append(fld)
if isinstance(fld, models.OneToOneRel):
editable = True
if getattr(fld, 'remote_field', None):
model = fld.remote_field.model
else:
model = None
if leaf_chooser is not None:
d = choosers.get_choosers_dict(cls)
d[name] = leaf_chooser
def getter(obj, ar=None):
try:
for fld in field_chain:
if obj is None:
return None
obj = fld._lino_atomizer.full_value_from_object(
obj, ar)
return obj
except Exception as e:
# raise
msg = "Error while computing {}: {} ({} in {})"
raise Exception(msg.format(
name, e, fld, field_chain))
# ~ if False: # only for debugging
if True: # see 20130802
logger.exception(e)
return str(e)
return None
if not editable:
rf = RemoteField(getter, name, fld)
# choosers.check_for_chooser(model, rf)
return rf
def setter(obj, value):
# logger.info("20180712 %s setter() %s", name, value)
# all intermediate fields are OneToOneRel
target = obj
try:
for fld in field_chain:
# print("20180712a %s" % fld)
if isinstance(fld, models.OneToOneRel):
reltarget = getattr(target, fld.name, None)
if reltarget is None:
rkw = { fld.field.name: target}
# print(
# "20180712 create {}({})".format(
# fld.related_model, rkw))
reltarget = fld.related_model(**rkw)
reltarget.full_clean()
reltarget.save()
setattr(target, fld.name, reltarget)
target.full_clean()
target.save()
# print("20180712b {}.{} = {}".format(
# target, fld.name, reltarget))
target = reltarget
else:
setattr(target, fld.name, value)
target.full_clean()
target.save()
# print(
# "20180712c setattr({},{},{}".format(
# target, fld.name, value))
return True
except Exception as e:
raise e.__class__(
"Error while setting %s: %s" % (name, e))
# ~ if False: # only for debugging
if True: # see 20130802
logger.exception(e)
return str(e)
return False
rf = RemoteField(getter, name, fld, setter)
# choosers.check_for_chooser(model, rf)
return rf