def _collect_index_fields(self, in_multi=False):
"""
collects fields which will be indexed
:param str model_name: base Model's name
:param bool in_multi: if we are in a ListNode or not
:return: [(field_name, solr_type, is_indexed, is_stored, is_multi]
"""
result = []
# if not model_name:
# model_name = self._get_bucket_name()
multi = in_multi or isinstance(self, ListNode)
for name in self._linked_models:
# obj = getattr(self, name) ### obj.has_many_values()
result.append((un_camel_id(name), 'string', True, False, multi))
for name, field_ins in self._fields.items():
field_name = self._path_of(name)
result.append((field_name,
field_ins.solr_type,
field_ins.index,
field_ins.store,
multi))
for mdl_ins in self._nodes:
result.extend(
getattr(self, mdl_ins)._collect_index_fields(multi))
return result
def _get_models(self, result):
for lnk in self._model.get_links(is_set=False):
if self._filter_out(lnk['field']):
continue
model = lnk['mdl']
model_instance = getattr(self._model, lnk['field'])
result.append({
'name':
un_camel_id(lnk['field']),
'model_name':
model.__name__,
'type':
'model',
'title':
model_instance.get_verbose_name(),
'value':
model_instance.key,
'content': (self.__class__(model_instance,
models=False,
list_nodes=False,
nodes=False)._serialize()
if self._model.is_in_db() else None),
'required':
None,
'default':
None,
})
def _node_schema(self, node, parent_name):
result = []
# node_data = {'models': [], 'fields': []}
for lnk in node.get_links():
model_instance = getattr(node, lnk['field'])
result.append({
'name': un_camel_id(lnk['field']),
'model_name': model_instance.__class__.__name__,
'type': 'model',
'title': model_instance.Meta.verbose_name,
'required': None,
})
for name, field in node._fields.items():
choices = getattr(field, 'choices', None)
typ = 'select' if choices else self.customize_types.get(
name, field.solr_type)
data = {
'name':
name,
'type':
typ,
'title':
field.title,
'required':
field.required,
'default':
field.default() if callable(field.default) else field.default,
}
if choices:
data['titleMap'] = self.get_choices(choices)
result.append(data)
return result
def _node_schema(self, node, parent_name):
result = []
# node_data = {'models': [], 'fields': []}
for lnk in node.get_links():
model_instance = getattr(node, lnk['field'])
result.append({'name': un_camel_id(lnk['field']),
'model_name': model_instance.__class__.__name__,
'type': 'model',
'title': model_instance.Meta.verbose_name,
'required': None,})
for name, field in node._fields.items():
choices = getattr(field, 'choices', None)
typ = 'select' if choices else self.customize_types.get(name, field.solr_type)
data = {
'name': name,
'type': typ,
'title': field.title,
'required': field.required,
'default': field.default() if callable(field.default) else field.default,
}
if choices:
data['titleMap'] = self.get_choices(choices)
result.append(data)
return result
def _clean_linked_model_value(self, dct):
# get vales of linked models
dct['_cache'] = {}
for name in self._linked_models:
link_mdl = getattr(self, name)
# print("LM: ", link_mdl)
link_mdl.processed_nodes = self.processed_nodes
_name = un_camel(name)
dct[un_camel_id(name)] = link_mdl.key or ''
if link_mdl.is_in_db() and not link_mdl._is_auto_created:
dct['_cache'][_name] = link_mdl.clean_value()
else:
dct['_cache'][_name] = {}
dct['_cache'][_name]['key'] = link_mdl.key
def _node_data(self, nodes, parent_name):
results = []
for real_node in nodes:
result = {}
# node_data = {'models': [], 'fields': []}
for lnk in real_node.get_links():
model_instance = getattr(real_node, lnk['field'])
result[un_camel_id(lnk['field'])] = {'key': model_instance.key,
'verbose_name': model_instance.get_verbose_name(),
'unicode': six.text_type(model_instance)
}
for name, field in real_node._fields.items():
result[name] = self._serialize_value(real_node._field_values.get(name))
results.append(result)
return results
def _node_data(self, nodes, parent_name):
results = []
for real_node in nodes:
result = {}
# node_data = {'models': [], 'fields': []}
for lnk in real_node.get_links():
model_instance = getattr(real_node, lnk['field'])
result[un_camel_id(lnk['field'])] = {'key': model_instance.key,
'verbose_name': model_instance.get_verbose_name(),
'unicode': six.text_type(model_instance)
}
for name, field in real_node._fields.items():
result[name] = self._serialize_value(real_node._field_values.get(name))
results.append(result)
return results
def clean_value(self):
dct = {}
for name in self._nodes:
dct[un_camel(name)] = getattr(self, name).clean_value()
if self._linked_models:
dct['_cache'] = {}
for name in self._linked_models:
obj = getattr(self, name)
dct[un_camel_id(name)] = obj.key or ''
if obj.key:
dct['_cache'][un_camel(name)] = obj.clean_value()
dct['_cache'][un_camel(name)]['key'] = obj.key
for name, field_ins in self._fields.items():
# if field_ins
dct[un_camel(name)] = field_ins.clean_value(self._field_values[name])
return dct
def _collect_index_fields(self, base_name=None, in_multi=False):
result = []
if not base_name:
base_name = self._get_bucket_name()
for name in self._linked_models:
obj = getattr(self, name)
result.append((un_camel_id(name), 'string', True, True, obj.has_many_values()))
multi = in_multi or isinstance(self, ListNode)
for name, field_ins in self._fields.items():
field_name = self._path_of(name).replace(base_name + '.', '')
result.append((field_name,
field_ins.solr_type,
field_ins.index,
field_ins.store,
multi))
for mdl_ins in self._nodes:
result.extend(getattr(self, mdl_ins)._collect_index_fields(base_name, multi))
return result
def _get_models(self, result):
for lnk in self._model.get_links(is_set=False):
if self._filter_out(lnk['field']):
continue
model = lnk['mdl']
model_instance = getattr(self._model, lnk['field'])
result.append({'name': un_camel_id(lnk['field']),
'model_name': model.__name__,
'type': 'model',
'title': model_instance.get_verbose_name(),
'value': model_instance.key,
'content': (self.__class__(model_instance,
models=False,
list_nodes=False,
nodes=False)._serialize()
if self._model.is_in_db() else None),
'required': None,
'default': None,
})
def _save_backlinked_models(self):
# FIXME: when called from a deleted object,
# we should also remove it from target model's cache
for name, mdl in self._get_reverse_links():
for obj in mdl.objects.filter(**{un_camel_id(name): self.key}):
if obj.key in self.saved_models:
continue
setattr(obj, name, self)
obj.saved_models = self.saved_models
obj.save()
for pointer, name, mdl in self._get_forward_links():
cached_obj = getattr(self, pointer)
if not cached_obj.is_in_db():
continue
# This is an undefined linked model slot, we just pass it
# Currently we don't have any mechanism to enforce definition of
# fields or linked models.
# TODO: Add blank=False validation for fields and linked models
obj = mdl.objects.get(cached_obj.key)
back_linking_model = getattr(obj, name, None)
if obj.key in self.saved_models:
# to prevent circular saves, but may cause missed cache updates
# we need more tests
continue
if back_linking_model:
# this is a 1-to-1 relation
setattr(obj, name, self)
obj.saved_models = self.saved_models
obj.save()
else:
# this is a 1-to-many relation, other side is a ListNode
# named like object_set
object_set = getattr(obj, '%s_set' % name)
object_set.add(**{name: self})
obj.saved_models = self.saved_models
obj.save()
def save(self):
self.objects.save_model()
for name, mdl in self._get_reverse_links():
for obj in mdl.objects.filter(**{un_camel_id(name):self.key}):
setattr(obj, name, self)
obj.save()
