from django.core.exceptions import ObjectDoesNotExist from django import oldforms from django.core import validators from django.db.models.fields import FileField, AutoField from django.db.models import signals from django.utils.functional import curry from django.utils.datastructures import DotExpandedDict from django.utils.text import capfirst from django.utils.encoding import smart_str from django.utils.translation import ugettext as _ from django.utils import datetime_safe def add_manipulators(sender, **kwargs): cls = sender cls.add_to_class('AddManipulator', AutomaticAddManipulator) cls.add_to_class('ChangeManipulator', AutomaticChangeManipulator) signals.class_prepared.connect(add_manipulators) class ManipulatorDescriptor(object): # This class provides the functionality that makes the default model # manipulators (AddManipulator and ChangeManipulator) available via the # model class. def __init__(self, name, base): self.man = None # Cache of the manipulator class. self.name = name self.base = base def __get__(self, instance, model=None): if instance != None: raise AttributeError, "Manipulator cannot be accessed via instance" else: if not self.man: # Create a class that inherits from the "Manipulator" class # given in the model class (if specified) and the automatic # manipulator. bases = [self.base] if hasattr(model, 'Manipulator'): bases = [model.Manipulator] + bases self.man = type(self.name, tuple(bases), {}) self.man._prepare(model) return self.man class AutomaticManipulator(oldforms.Manipulator): def _prepare(cls, model): cls.model = model cls.manager = model._default_manager cls.opts = model._meta for field_name_list in cls.opts.unique_together: setattr(cls, 'isUnique%s' % '_'.join(field_name_list), curry(manipulator_validator_unique_together, field_name_list, cls.opts)) for f in cls.opts.fields: if f.unique_for_date: setattr(cls, 'isUnique%sFor%s' % (f.name, f.unique_for_date), curry(manipulator_validator_unique_for_date, f, cls.opts.get_field(f.unique_for_date), cls.opts, 'date')) if f.unique_for_month: setattr(cls, 'isUnique%sFor%s' % (f.name, f.unique_for_month), curry(manipulator_validator_unique_for_date, f, cls.opts.get_field(f.unique_for_month), cls.opts, 'month')) if f.unique_for_year: setattr(cls, 'isUnique%sFor%s' % (f.name, f.unique_for_year), curry(manipulator_validator_unique_for_date, f, cls.opts.get_field(f.unique_for_year), cls.opts, 'year')) _prepare = classmethod(_prepare) def contribute_to_class(cls, other_cls, name): setattr(other_cls, name, ManipulatorDescriptor(name, cls)) contribute_to_class = classmethod(contribute_to_class) def __init__(self, follow=None): self.follow = self.opts.get_follow(follow) self.fields = [] for f in self.opts.fields + self.opts.many_to_many: if self.follow.get(f.name, False): self.fields.extend(f.get_manipulator_fields(self.opts, self, self.change)) # Add fields for related objects. for f in self.opts.get_all_related_objects(): if self.follow.get(f.name, False): fol = self.follow[f.name] self.fields.extend(f.get_manipulator_fields(self.opts, self, self.change, fol)) # Add field for ordering. if self.change and self.opts.get_ordered_objects(): self.fields.append(oldforms.CommaSeparatedIntegerField(field_name="order_")) def save(self, new_data): # TODO: big cleanup when core fields go -> use recursive manipulators. params = {} for f in self.opts.fields: # Fields with auto_now_add should keep their original value in the change stage. auto_now_add = self.change and getattr(f, 'auto_now_add', False) if self.follow.get(f.name, None) and not auto_now_add: param = f.get_manipulator_new_data(new_data) else: if self.change: param = getattr(self.original_object, f.attname) else: param = f.get_default() params[f.attname] = param if self.change: params[self.opts.pk.attname] = self.obj_key # First, create the basic object itself. new_object = self.model(**params) # Now that the object's been created, save any uploaded files. for f in self.opts.fields: if isinstance(f, FileField): f.save_file(new_data, new_object, self.change and self.original_object or None, self.change, rel=False, save=False) # Now save the object new_object.save() # Calculate which primary fields have changed. if self.change: self.fields_added, self.fields_changed, self.fields_deleted = [], [], [] for f in self.opts.fields: if not f.primary_key and smart_str(getattr(self.original_object, f.attname)) != smart_str(getattr(new_object, f.attname)): self.fields_changed.append(f.verbose_name) # Save many-to-many objects. Example: Set sites for a poll. for f in self.opts.many_to_many: if self.follow.get(f.name, None): if not f.rel.edit_inline: new_vals = new_data.getlist(f.name) # First, clear the existing values. rel_manager = getattr(new_object, f.name) rel_manager.clear() # Then, set the new values. for n in new_vals: rel_manager.add(f.rel.to._default_manager.get(pk=n)) # TODO: Add to 'fields_changed' expanded_data = DotExpandedDict(dict(new_data)) # Save many-to-one objects. Example: Add the Choice objects for a Poll. for related in self.opts.get_all_related_objects(): # Create obj_list, which is a DotExpandedDict such as this: # [('0', {'id': ['940'], 'choice': ['This is the first choice']}), # ('1', {'id': ['941'], 'choice': ['This is the second choice']}), # ('2', {'id': [''], 'choice': ['']})] child_follow = self.follow.get(related.name, None) if child_follow: obj_list = expanded_data.get(related.var_name, {}).items() if not obj_list: continue obj_list.sort(lambda x, y: cmp(int(x[0]), int(y[0]))) # For each related item... for _, rel_new_data in obj_list: params = {} # Keep track of which core=True fields were provided. # If all core fields were given, the related object will be saved. # If none of the core fields were given, the object will be deleted. # If some, but not all, of the fields were given, the validator would # have caught that. all_cores_given, all_cores_blank = True, True # Get a reference to the old object. We'll use it to compare the # old to the new, to see which fields have changed. old_rel_obj = None if self.change: if rel_new_data[related.opts.pk.name][0]: try: old_rel_obj = getattr(self.original_object, related.get_accessor_name()).get(**{'%s__exact' % related.opts.pk.name: rel_new_data[related.opts.pk.attname][0]}) except ObjectDoesNotExist: pass for f in related.opts.fields: if f.core and not isinstance(f, FileField) and f.get_manipulator_new_data(rel_new_data, rel=True) in (None, ''): all_cores_given = False elif f.core and not isinstance(f, FileField) and f.get_manipulator_new_data(rel_new_data, rel=True) not in (None, ''): all_cores_blank = False # If this field isn't editable, give it the same value it had # previously, according to the given ID. If the ID wasn't # given, use a default value. FileFields are also a special # case, because they'll be dealt with later. if f == related.field: param = getattr(new_object, related.field.rel.get_related_field().attname) elif (not self.change) and isinstance(f, AutoField): param = None elif self.change and (isinstance(f, FileField) or not child_follow.get(f.name, None)): if old_rel_obj: param = getattr(old_rel_obj, f.column) else: param = f.get_default() else: param = f.get_manipulator_new_data(rel_new_data, rel=True) if param != None: params[f.attname] = param # Create the related item. new_rel_obj = related.model(**params) # If all the core fields were provided (non-empty), save the item. if all_cores_given: new_rel_obj.save() # Save any uploaded files. for f in related.opts.fields: if child_follow.get(f.name, None): if isinstance(f, FileField) and rel_new_data.get(f.name, False): f.save_file(rel_new_data, new_rel_obj, self.change and old_rel_obj or None, old_rel_obj is not None, rel=True) # Calculate whether any fields have changed. if self.change: if not old_rel_obj: # This object didn't exist before. self.fields_added.append('%s "%s"' % (related.opts.verbose_name, new_rel_obj)) else: for f in related.opts.fields: if not f.primary_key and f != related.field and smart_str(getattr(old_rel_obj, f.attname)) != smart_str(getattr(new_rel_obj, f.attname)): self.fields_changed.append('%s for %s "%s"' % (f.verbose_name, related.opts.verbose_name, new_rel_obj)) # Save many-to-many objects. for f in related.opts.many_to_many: if child_follow.get(f.name, None) and not f.rel.edit_inline: new_value = rel_new_data[f.attname] setattr(new_rel_obj, f.name, f.rel.to.objects.filter(pk__in=new_value)) if self.change: self.fields_changed.append('%s for %s "%s"' % (f.verbose_name, related.opts.verbose_name, new_rel_obj)) # If, in the change stage, all of the core fields were blank and # the primary key (ID) was provided, delete the item. if self.change and all_cores_blank and old_rel_obj: new_rel_obj.delete() self.fields_deleted.append('%s "%s"' % (related.opts.verbose_name, old_rel_obj)) # Save the order, if applicable. if self.change and self.opts.get_ordered_objects(): order = new_data['order_'] and map(int, new_data['order_'].split(',')) or [] for rel_opts in self.opts.get_ordered_objects(): getattr(new_object, 'set_%s_order' % rel_opts.object_name.lower())(order) return new_object def get_related_objects(self): return self.opts.get_followed_related_objects(self.follow) def flatten_data(self): new_data = {} obj = self.change and self.original_object or None for f in self.opts.get_data_holders(self.follow): fol = self.follow.get(f.name) new_data.update(f.flatten_data(fol, obj)) return new_data class AutomaticAddManipulator(AutomaticManipulator): change = False class AutomaticChangeManipulator(AutomaticManipulator): change = True def __init__(self, obj_key, follow=None): self.obj_key = obj_key try: self.original_object = self.manager.get(pk=obj_key) except ObjectDoesNotExist: # If the object doesn't exist, this might be a manipulator for a # one-to-one related object that hasn't created its subobject yet. # For example, this might be a Restaurant for a Place that doesn't # yet have restaurant information. if self.opts.one_to_one_field: # Sanity check -- Make sure the "parent" object exists. # For example, make sure the Place exists for the Restaurant. # Let the ObjectDoesNotExist exception propagate up. limit_choices_to = self.opts.one_to_one_field.rel.limit_choices_to lookup_kwargs = {'%s__exact' % self.opts.one_to_one_field.rel.field_name: obj_key} self.opts.one_to_one_field.rel.to.get_model_module().complex_filter(limit_choices_to).get(**lookup_kwargs) params = dict([(f.attname, f.get_default()) for f in self.opts.fields]) params[self.opts.pk.attname] = obj_key self.original_object = self.opts.get_model_module().Klass(**params) else: raise super(AutomaticChangeManipulator, self).__init__(follow=follow) def manipulator_validator_unique_together(field_name_list, opts, self, field_data, all_data): from django.db.models.fields.related import ManyToOneRel from django.utils.text import get_text_list field_list = [opts.get_field(field_name) for field_name in field_name_list] if isinstance(field_list[0].rel, ManyToOneRel): kwargs = {'%s__%s__iexact' % (field_name_list[0], field_list[0].rel.field_name): field_data} else: kwargs = {'%s__iexact' % field_name_list[0]: field_data} for f in field_list[1:]: # This is really not going to work for fields that have different # form fields, e.g. DateTime. # This validation needs to occur after html2python to be effective. field_val = all_data.get(f.name, None) if field_val is None: # This will be caught by another validator, assuming the field # doesn't have blank=True. return if isinstance(f.rel, ManyToOneRel): kwargs['%s__pk' % f.name] = field_val else: kwargs['%s__iexact' % f.name] = field_val try: old_obj = self.manager.get(**kwargs) except ObjectDoesNotExist: return if hasattr(self, 'original_object') and self.original_object._get_pk_val() == old_obj._get_pk_val(): pass else: raise validators.ValidationError, _("%(object)s with this %(type)s already exists for the given %(field)s.") % \ {'object': capfirst(opts.verbose_name), 'type': field_list[0].verbose_name, 'field': get_text_list([f.verbose_name for f in field_list[1:]], _('and'))} def manipulator_validator_unique_for_date(from_field, date_field, opts, lookup_type, self, field_data, all_data): from django.db.models.fields.related import ManyToOneRel date_str = all_data.get(date_field.get_manipulator_field_names('')[0], None) date_val = oldforms.DateField.html2python(date_str) if date_val is None: return # Date was invalid. This will be caught by another validator. lookup_kwargs = {'%s__year' % date_field.name: date_val.year} if isinstance(from_field.rel, ManyToOneRel): lookup_kwargs['%s__pk' % from_field.name] = field_data else: lookup_kwargs['%s__iexact' % from_field.name] = field_data if lookup_type in ('month', 'date'): lookup_kwargs['%s__month' % date_field.name] = date_val.month if lookup_type == 'date': lookup_kwargs['%s__day' % date_field.name] = date_val.day try: old_obj = self.manager.get(**lookup_kwargs) except ObjectDoesNotExist: return else: if hasattr(self, 'original_object') and self.original_object._get_pk_val() == old_obj._get_pk_val(): pass else: format_string = (lookup_type == 'date') and '%B %d, %Y' or '%B %Y' date_val = datetime_safe.new_datetime(date_val) raise validators.ValidationError, "Please enter a different %s. The one you entered is already being used for %s." % \ (from_field.verbose_name, date_val.strftime(format_string))