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