| class BoundRelatedObject(object): |
| def __init__(self, related_object, field_mapping, original): |
| self.relation = related_object |
| self.field_mappings = field_mapping[related_object.name] |
| |
| def template_name(self): |
| raise NotImplementedError |
| |
| def __repr__(self): |
| return repr(self.__dict__) |
| |
| class RelatedObject(object): |
| def __init__(self, parent_model, model, field): |
| self.parent_model = parent_model |
| self.model = model |
| self.opts = model._meta |
| self.field = field |
| self.edit_inline = field.rel.edit_inline |
| self.name = '%s:%s' % (self.opts.app_label, self.opts.module_name) |
| self.var_name = self.opts.object_name.lower() |
| |
| def flatten_data(self, follow, obj=None): |
| new_data = {} |
| rel_instances = self.get_list(obj) |
| for i, rel_instance in enumerate(rel_instances): |
| instance_data = {} |
| for f in self.opts.fields + self.opts.many_to_many: |
| # TODO: Fix for recursive manipulators. |
| fol = follow.get(f.name, None) |
| if fol: |
| field_data = f.flatten_data(fol, rel_instance) |
| for name, value in field_data.items(): |
| instance_data['%s.%d.%s' % (self.var_name, i, name)] = value |
| new_data.update(instance_data) |
| return new_data |
| |
| def extract_data(self, data): |
| """ |
| Pull out the data meant for inline objects of this class, |
| i.e. anything starting with our module name. |
| """ |
| return data # TODO |
| |
| def get_list(self, parent_instance=None): |
| "Get the list of this type of object from an instance of the parent class." |
| if parent_instance is not None: |
| attr = getattr(parent_instance, self.get_accessor_name()) |
| if self.field.rel.multiple: |
| # For many-to-many relationships, return a list of objects |
| # corresponding to the xxx_num_in_admin options of the field |
| objects = list(attr.all()) |
| |
| count = len(objects) + self.field.rel.num_extra_on_change |
| if self.field.rel.min_num_in_admin: |
| count = max(count, self.field.rel.min_num_in_admin) |
| if self.field.rel.max_num_in_admin: |
| count = min(count, self.field.rel.max_num_in_admin) |
| |
| change = count - len(objects) |
| if change > 0: |
| return objects + [None] * change |
| if change < 0: |
| return objects[:change] |
| else: # Just right |
| return objects |
| else: |
| # A one-to-one relationship, so just return the single related |
| # object |
| return [attr] |
| else: |
| if self.field.rel.min_num_in_admin: |
| return [None] * max(self.field.rel.num_in_admin, self.field.rel.min_num_in_admin) |
| else: |
| return [None] * self.field.rel.num_in_admin |
| |
| def get_db_prep_lookup(self, lookup_type, value): |
| # Defer to the actual field definition for db prep |
| return self.field.get_db_prep_lookup(lookup_type, value) |
| |
| def editable_fields(self): |
| "Get the fields in this class that should be edited inline." |
| return [f for f in self.opts.fields + self.opts.many_to_many if f.editable and f != self.field] |
| |
| def get_follow(self, override=None): |
| if isinstance(override, bool): |
| if override: |
| over = {} |
| else: |
| return None |
| else: |
| if override: |
| over = override.copy() |
| elif self.edit_inline: |
| over = {} |
| else: |
| return None |
| |
| over[self.field.name] = False |
| return self.opts.get_follow(over) |
| |
| def get_manipulator_fields(self, opts, manipulator, change, follow): |
| if self.field.rel.multiple: |
| if change: |
| attr = getattr(manipulator.original_object, self.get_accessor_name()) |
| count = attr.count() |
| count += self.field.rel.num_extra_on_change |
| else: |
| count = self.field.rel.num_in_admin |
| if self.field.rel.min_num_in_admin: |
| count = max(count, self.field.rel.min_num_in_admin) |
| if self.field.rel.max_num_in_admin: |
| count = min(count, self.field.rel.max_num_in_admin) |
| else: |
| count = 1 |
| |
| fields = [] |
| for i in range(count): |
| for f in self.opts.fields + self.opts.many_to_many: |
| if follow.get(f.name, False): |
| prefix = '%s.%d.' % (self.var_name, i) |
| fields.extend(f.get_manipulator_fields(self.opts, manipulator, change, |
| name_prefix=prefix, rel=True)) |
| return fields |
| |
| def __repr__(self): |
| return "<RelatedObject: %s related to %s>" % (self.name, self.field.name) |
| |
| def bind(self, field_mapping, original, bound_related_object_class=BoundRelatedObject): |
| return bound_related_object_class(self, field_mapping, original) |
| |
| def get_accessor_name(self): |
| # This method encapsulates the logic that decides what name to give an |
| # accessor descriptor that retrieves related many-to-one or |
| # many-to-many objects. It uses the lower-cased object_name + "_set", |
| # but this can be overridden with the "related_name" option. |
| if self.field.rel.multiple: |
| # If this is a symmetrical m2m relation on self, there is no reverse accessor. |
| if getattr(self.field.rel, 'symmetrical', False) and self.model == self.parent_model: |
| return None |
| return self.field.rel.related_name or (self.opts.object_name.lower() + '_set') |
| else: |
| return self.field.rel.related_name or (self.opts.object_name.lower()) |
