Ticket #7048: DeletableFileFields-02.diff

django/forms/models.py

@@ -7 +7 @@
-from django.utils.datastructures import SortedDict
-from django.utils.text import get_text_list, capfirst
-from django.utils.translation import ugettext_lazy as _
+from django.core.files.uploadedfile import UploadedFile
+from django.core.files import directories
-
-from util import ValidationError, ErrorList
-from forms import BaseForm, get_declared_fields
-
+FileField, DeletableFileField, 
-from widgets import Select, SelectMultiple, HiddenInput, MultipleHiddenInput
-from widgets import media_property
-from formsets import BaseFormSet, formset_factory, DELETION_FIELD_NAME
@@ -20 +22 @@
-except NameError:
-    from sets import Set as set     # Python 2.3 fallback
-
+import os
+
-__all__ = (
-    'ModelForm', 'BaseModelForm', 'model_to_dict', 'fields_for_model',
-    'save_instance', 'form_for_fields', 'ModelChoiceField',
@@ -27 +31 @@
-)
-
-
+def delete_file_field_file(file_field, model_instance, delete_from_disk=False, delete_empty_directories=False):
+    """
+    Deletes the file of a model instances FileField. But only if no other 
+    instances are pointing to it and it is not the default.
+    """
+    file_obj = getattr(model_instance, file_field.attname)
+    if not file_obj:
+        return
+    
+    # check whether we need to delete the file from disk or just clear the field
+    if delete_from_disk:
+        # create a queryset to determine if the file is being referenced
+        # by *another* instance.
+        queryset = model_instance.__class__._default_manager.\
+            filter(**{file_field.attname: file_obj.name}).\
+            exclude(pk=model_instance.pk)
+        # delete the file if is not referenced elsewhere and is not the default
+        if not queryset and file_obj.name != file_field.default:
+            file_path = file_obj.path
+            file_obj.delete(save=False)
+            if delete_empty_directories:
+                from django.conf import settings
+                directories.delete_empty_directories(stop_dir=settings.MEDIA_ROOT, dir=os.path.dirname(file_path))
+            
+    # TODO: look into this more. initially it was using None, but that
+    # was not working as the model field is null=False since there
+    # seems to be no reason why when the database field is a varchar.
+    setattr(model_instance, file_field.attname, u"")
+
+
-def save_instance(form, instance, fields=None, fail_message='saved',
-                  commit=True, exclude=None):
-    """
@@ -52 +86 @@
-            continue
-        # Defer saving file-type fields until after the other fields, so a
-        # callable upload_to can use the values from other fields.
-
+ or isinstance(f, DeletableFileField)
-            file_field_list.append(f)
-        else:
-            f.save_form_data(instance, cleaned_data[f.name])
-            
-    for f in file_field_list:
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        
-    # Wrap up the saving of m2m data as a function.
-    def save_m2m():
@@ -169 +218 @@
-        self.model = getattr(options, 'model', None)
-        self.fields = getattr(options, 'fields', None)
-        self.exclude = getattr(options, 'exclude', None)
+        self.files_add_delete_option = getattr(options, 'files_add_delete_option', True)
+        self.files_delete_from_disk = getattr(options, 'files_delete_from_disk', True)
+        self.files_delete_empty_dirs = getattr(options, 'files_delete_empty_dirs', False)
-
-
-class ModelFormMetaclass(type):
-    def __new__(cls, name, bases, attrs):
-        formfield_callback = attrs.pop('formfield_callback',
@@ -196 +247 @@
-            # Override default model fields with any custom declared ones
-            # (plus, include all the other declared fields).
-            fields.update(declared_fields)
+            
+            if opts.files_add_delete_option:
+                # wrap form FileFields in DeletableFileFields to show current file and get delete checkboxes (but only if blank=True)
+                for field_name, field in fields.items():
+                    if isinstance(field, FileField):
+                        fields[field_name] = DeletableFileField(file_field_to_wrap=field, show_delete_checkbox=opts.model._meta.get_field(field_name).blank)
-        else:
-            fields = declared_fields
-        new_class.declared_fields = declared_fields
@@ -322 +379 @@
-    __metaclass__ = ModelFormMetaclass
-
-def modelform_factory(model, form=ModelForm, fields=None, exclude=None,
-
+, **kwargs
-    # HACK: we should be able to construct a ModelForm without creating
-    # and passing in a temporary inner class
-    class Meta:
@@ -330 +387 @@
-    setattr(Meta, 'model', model)
-    setattr(Meta, 'fields', fields)
-    setattr(Meta, 'exclude', exclude)
+    # only add the options to the Meta class that are actually passed in via kwargs as the defaults are already in ModelFormOptions!
+    for attr in ('files_add_delete_option', 'files_delete_from_disk', 'files_delete_empty_dirs'):
+        if attr in kwargs:
+            setattr(Meta, attr, kwargs[attr])
-    class_name = model.__name__ + 'Form'
-    return ModelFormMetaclass(class_name, (form,), {'Meta': Meta,
-                              'formfield_callback': formfield_callback})

django/forms/fields.py

@@ -28 +28 @@
-from django.utils.encoding import smart_unicode, smart_str
-
-from util import ErrorList, ValidationError
-
+, DeletableFileInput, DeleteCheckboxInput
-from django.core.files.uploadedfile import SimpleUploadedFile as UploadedFile
-
-__all__ = (
@@ -36 +36 @@
-    'DEFAULT_DATE_INPUT_FORMATS', 'DateField',
-    'DEFAULT_TIME_INPUT_FORMATS', 'TimeField',
-    'DEFAULT_DATETIME_INPUT_FORMATS', 'DateTimeField', 'TimeField',
-
+DeletableFileField', '
-    'BooleanField', 'NullBooleanField', 'ChoiceField', 'MultipleChoiceField',
-    'ComboField', 'MultiValueField', 'FloatField', 'DecimalField',
-    'SplitDateTimeField', 'IPAddressField', 'FilePathField', 'SlugField',
@@ -525 +525 @@
-            f.seek(0)
-        return f
-
+class DeletableFileField(Field):
+    """
+    A Field that adds a delete checkbox to a FileField and shows the current value. file_field_to_wrap is the
+    FileField subclass or its instance to be wrapped. If show_delete_checkbox is set to False the field just
+    displays the current value and no delete checkbox. It returns a tupel with the actual FileField value and
+    the state of the delete checkbox.
+    """
+    def __init__(self, file_field_to_wrap=FileField, show_delete_checkbox=True, *args, **kwargs):
+        self.fields = (
+            isinstance(file_field_to_wrap, type) and file_field_to_wrap() or file_field_to_wrap, # instantiate if it is a class
+            BooleanField(widget=DeleteCheckboxInput, required=False),
+        )
+        # get widgets from the fields and pass them to our MultiWidget
+        defaults = {
+            'widget': DeletableFileInput([f.widget for f in self.fields], show_delete_checkbox=show_delete_checkbox),
+            'required': self.fields[0].required, # this is just for display purposes, the actual check is performed by the FileField
+        }
+        defaults.update(kwargs)
+        super(DeletableFileField, self).__init__(*args, **defaults)
+    
+    def clean(self, value, initial=None):
+        return (self.fields[0].clean(value[0], initial), self.fields[1].clean(value[1]))
+
-url_re = re.compile(
-    r'^https?://' # http:// or https://
-    r'(?:(?:[A-Z0-9-]+\.)+[A-Z]{2,6}|' #domain...

django/forms/forms.py

@@ -9 +9 @@
-from django.utils.encoding import StrAndUnicode, smart_unicode, force_unicode
-from django.utils.safestring import mark_safe
-
-
+, DeletableFileField
-from widgets import Media, media_property, TextInput, Textarea
-from util import flatatt, ErrorDict, ErrorList, ValidationError
-
@@ -224 +224 @@
-            # widgets split data over several HTML fields.
-            value = field.widget.value_from_datadict(self.data, self.files, self.add_prefix(name))
-            try:
-FileField
+(FileField, DeletableFileField)
-                    initial = self.initial.get(name, field.initial)
-                    value = field.clean(value, initial)
-                else:

django/forms/widgets.py

@@ -16 +16 @@
-from django.utils.encoding import StrAndUnicode, force_unicode
-from django.utils.safestring import mark_safe
-from django.utils import datetime_safe
+from django.utils.translation import ugettext as _
+from django.core.files.uploadedfile import UploadedFile
-from datetime import time
-from util import flatatt
-from urlparse import urljoin
-
-__all__ = (
-    'Media', 'MediaDefiningClass', 'Widget', 'TextInput', 'PasswordInput',
-
+ 'DeletableFileInput', 'DeleteCheckboxInput',
-    'FileInput', 'DateTimeInput', 'TimeInput', 'Textarea', 'CheckboxInput',
-    'Select', 'NullBooleanSelect', 'SelectMultiple', 'RadioSelect',
-    'CheckboxSelectMultiple', 'MultiWidget',
@@ -650 +652 @@
-        return media
-    media = property(_get_media)
-
+class DeletableFileInput(MultiWidget):
+    """
+    A MultiWidget for the use with the DeletableFileField. The contained widgets are
+    specified by the fields constructor. If the value of the model FileField is None or
+    UploadedFile the rendered widget of the form FileField is just passed through.
+    """
+    def __init__(self, widgets, attrs=None, show_delete_checkbox=True):
+        self.show_delete_checkbox = show_delete_checkbox
+        super(DeletableFileInput, self).__init__(widgets, attrs)
+    
+    def render(self, name, value, attrs=None):
+        self.show_checkbox = False
+        return super(DeletableFileInput, self).render(name, value, attrs)
+        
+    def decompress(self, value):
+        # decompress() is only called when we have initial data (not POST data)
+        # so we can be sure we have a proper File object here
+        if value:
+            self.show_checkbox = True
+            self.current_file = value
+            return [value, False]
+        # the value for DeleteCheckboxInput doesn't really matter as we won't show it anyway
+        return [None, None]
+    
+    def format_output(self, rendered_widgets):
+        """
+        Adds a link to the current file and wraps everything in spans to afford formatting.
+        """
+        # this is a bit strange as we to do the actual test in decompress()
+        # but we don't have the value of the model FileField here so ...
+        if not self.show_checkbox:
+            return rendered_widgets[0]
+        # current file
+        output = [u'<span class="%s"><span class="%s">%s <a target="_blank" href="%s">%s</a></span><br/>' % (
+            u'deletable-file-input',
+            u'deletable-file-input-current',
+            _('Currently:'),
+            self.current_file.url,
+            self.current_file,
+        )]
+        # file input
+        output.append('<span class="%s">%s %s</span><br/>' % (
+            u'deletable-file-input-file-field',
+            _('Change:'),
+            rendered_widgets[0], # the FileFields widget
+        ))
+        # delete checkbox
+        if self.show_delete_checkbox:
+            output.append('<span class="%s">%s</span>' % (
+                u'deletable-file-input-delete-checkbox',
+                rendered_widgets[1], # the checkbox
+            ))
+        output.append('</span>')
+        return u''.join(output)
+
+class DeleteCheckboxInput(CheckboxInput):
+    """
+    A CheckboxInput with a delete label next to it. It only renders if value is not None.
+    """
+    def render(self, name, value, attrs=None):
+        if value == None:
+            return u''
+        return u'%s <label for="%s">%s</label>' % (
+            super(DeleteCheckboxInput, self).render(name, value, attrs),
+            attrs["id"],
+            _("Delete"),
+        )
+
-class SplitDateTimeWidget(MultiWidget):
-    """
-    A Widget that splits datetime input into two <input type="text"> boxes.

django/core/files/directories.py

@@ +1 @@
+import os
+
+def delete_empty_directories(stop_dir, dir):
+    """
+    Deletes *empty* directories starting with dir and working it's way up till it hits stop_dir.
+    """
+    # normalize paths
+    stop_dir = os.path.abspath(stop_dir)
+    dir = os.path.abspath(dir)
+    if not os.path.exists(stop_dir):
+        raise Exception("stop_dir ('%s') is not a valid directory." % stop_dir)
+    try:
+        while True:
+            if dir == stop_dir or len(dir) < 4:
+                return
+            os.rmdir(dir)
+            dir = os.path.dirname(dir)
+    except OSError:
+        # stop if we have not enough permissions or dir is not empty
+        pass

django/contrib/admin/media/css/forms.css

@@ -146 +146 @@
-    display: inline !important;
-}
-
+/* DELETABLE FILE INPUTS */
+
+.deletable-file-input {
+    display: block;
+    padding-left: 9.818181em; /* should match the 9em that inputs get pushed to the side by labels */
+}
+
+.deletable-file-input-delete-checkbox {
+    display: block;
+}
+
+.deletable-file-input-delete-checkbox label {
+    display:inline; float:none;
+}
+
-/* MONOSPACE TEXTAREAS */
-
-fieldset.monospace textarea {

django/contrib/admin/options.py

@@ -105 +105 @@
-            kwargs['widget'] = widgets.AdminTextInputWidget
-            return db_field.formfield(**kwargs)
-    
-        # For FileFields and ImageFields add a link to the current file.
-        if isinstance(db_field, models.ImageField) or isinstance(db_field, models.FileField):
-            kwargs['widget'] = widgets.AdminFileWidget
-            return db_field.formfield(**kwargs)
-
-        # For ForeignKey or ManyToManyFields, use a special widget.
-        if isinstance(db_field, (models.ForeignKey, models.ManyToManyField)):
-            if isinstance(db_field, models.ForeignKey) and db_field.name in self.raw_id_fields:

django/contrib/admin/widgets.py

@@ -80 +80 @@
-class AdminRadioSelect(forms.RadioSelect):
-    renderer = AdminRadioFieldRenderer
-
-class AdminFileWidget(forms.FileInput):
-    """
-    A FileField Widget that shows its current value if it has one.
-    """
-    def __init__(self, attrs={}):
-        super(AdminFileWidget, self).__init__(attrs)
-
-    def render(self, name, value, attrs=None):
-        output = []
-        if value and hasattr(value, "url"):
-            output.append('%s <a target="_blank" href="%s">%s</a> <br />%s ' % \
-                (_('Currently:'), value.url, value, _('Change:')))
-        output.append(super(AdminFileWidget, self).render(name, value, attrs))
-        return mark_safe(u''.join(output))
-
-class ForeignKeyRawIdWidget(forms.TextInput):
-    """
-    A Widget for displaying ForeignKeys in the "raw_id" interface rather than

docs/topics/forms/modelforms.txt

@@ -382 +382 @@
-Chances are these notes won't affect you unless you're trying to do something
-tricky with subclassing.
-
+Making ``FileField``s deletable
+===============================
+
+``files_add_delete_option``
+---------------------------
+
+This option is ``True`` by default.
+
+When set to ``True``, all ``FileField``s get delete checkboxes if they have the
+option ``blank=True``. The current file is also displayed above the field, regardless
+of the value of ``blank``.
+
+``files_delete_empty_dirs``
+---------------------------
+
+This option is ``False`` by default.
+
+When set to ``True``, Django removes *empty* directories after each file is deleted. It
+starts with the directory of the file and then moves it's way up till it reaches the
+``MEDIA_ROOT`` folder. **Warning**: This may delete more directories than you want.
+Use with caution!
+
+For example, if Django deletes the following file:
+
+    /media-root/foo/bar/file.png
+    
+It will first try to delete ``/media-root/foo/bar/`` and then ``/media-root/foo/``.
+
+``files_delete_from_disk``
+---------------------------
+
+This option is ``True`` by default.
+
+When set to ``True``, files of ``FileField`` are deleted from the disk. This happens
+when a FileField is updated or when it is cleared. The latter is only possible if
+``files_add_delete_option`` is ``True``.
+
-.. _model-formsets:
-
-Model Formsets