From: Joseph Spiros <joseph.spiros@ithinksw.com>
Date: Tue, 24 Aug 2010 13:10:18 +0000 (-0400)
Subject: Merge branch 'new_page_admin' of git://github.com/melinath/philo into melinath
X-Git-Tag: philo-0.9~34^2
X-Git-Url: http://git.ithinksw.org/philo.git/commitdiff_plain/2af3cb7d8e4986e326c3b91233bc0aaa9c7d7c58?hp=18964182c79e9bf76245d96cf1b1218e8ac21d84

Merge branch 'new_page_admin' of git://github.com/melinath/philo into melinath

* 'new_page_admin' of git://github.com/melinath/philo:
  Implemented object deletion on null values. Added ModelChoiceWidget to ContentReferences.
  Display of current values functional.
  Display of ContainerFormSets functional; display of their values is not; saving of values, however, is.
  Initial new page admin commit. Working on faking the admin out through inlines instead of ModelAdmin methods.
---

diff --git a/admin/pages.py b/admin/pages.py
index 52238da..03b943f 100644
--- a/admin/pages.py
+++ b/admin/pages.py
@@ -5,7 +5,27 @@ from philo.admin import widgets
 from philo.admin.base import COLLAPSE_CLASSES
 from philo.admin.nodes import ViewAdmin
 from philo.models.pages import Page, Template, Contentlet, ContentReference
-from philo.forms import TemplateForm
+from philo.forms import TemplateForm, ContentletInlineFormSet, ContentReferenceInlineFormSet, ContentletForm, ContentReferenceForm
+
+
+class ContentletInline(admin.StackedInline):
+	model = Contentlet
+	extra = 0
+	max_num = 0
+	formset = ContentletInlineFormSet
+	form = ContentletForm
+	can_delete = False
+	template = 'admin/philo/edit_inline/tabular_container.html'
+
+
+class ContentReferenceInline(admin.StackedInline):
+	model = ContentReference
+	extra = 0
+	max_num = 0
+	formset = ContentReferenceInlineFormSet
+	form = ContentReferenceForm
+	can_delete = False
+	template = 'admin/philo/edit_inline/tabular_container.html'
 
 
 class PageAdmin(ViewAdmin):
@@ -18,80 +38,7 @@ class PageAdmin(ViewAdmin):
 	list_display = ('title', 'template')
 	list_filter = ('template',)
 	search_fields = ['title', 'contentlets__content']
-	
-	def get_fieldsets(self, request, obj=None, **kwargs):
-		fieldsets = list(self.fieldsets)
-		if obj: # if no obj, creating a new page, thus no template set, thus no containers
-			template = obj.template
-			if template.documentation:
-				fieldsets.append(('Template Documentation', {
-					'description': template.documentation
-				}))
-			contentlet_containers, contentreference_containers = template.containers
-			for container_name in contentlet_containers:
-				fieldsets.append((('Container: %s' % container_name), {
-					'fields': (('contentlet_container_content_%s' % container_name), ('contentlet_container_dynamic_%s' % container_name)),
-					'classes': ['monospace']
-				}))
-			for container_name, container_content_type in contentreference_containers:
-				fieldsets.append((('Container: %s' % container_name), {
-					'fields': (('contentreference_container_%s' % container_name),)
-				}))
-		return fieldsets
-	
-	def get_form(self, request, obj=None, **kwargs):
-		form = super(PageAdmin, self).get_form(request, obj, **kwargs)
-		if obj: # if no obj, creating a new page, thus no template set, thus no containers
-			page = obj
-			template = page.template
-			contentlet_containers, contentreference_containers = template.containers
-			for container_name in contentlet_containers:
-				initial_content = None
-				initial_dynamic = False
-				try:
-					contentlet = page.contentlets.get(name__exact=container_name)
-					initial_content = contentlet.content
-					initial_dynamic = contentlet.dynamic
-				except Contentlet.DoesNotExist:
-					pass
-				form.base_fields[('contentlet_container_content_%s' % container_name)] = forms.CharField(label='Content', widget=forms.Textarea(), initial=initial_content, required=False)
-				form.base_fields[('contentlet_container_dynamic_%s' % container_name)] = forms.BooleanField(label='Dynamic', help_text='Specify whether this content contains dynamic template code', initial=initial_dynamic, required=False)
-			for container_name, container_content_type in contentreference_containers:
-				initial_content = None
-				try:
-					initial_content = page.contentreferences.get(name__exact=container_name, content_type=container_content_type).content.pk
-				except (ContentReference.DoesNotExist, AttributeError):
-					pass
-				form.base_fields[('contentreference_container_%s' % container_name)] = forms.ModelChoiceField(label='References', widget=widgets.ModelLookupWidget(container_content_type), initial=initial_content, required=False, queryset=container_content_type.model_class().objects.all())
-		return form
-	
-	def save_model(self, request, page, form, change):
-		page.save()
-		template = page.template
-		contentlet_containers, contentreference_containers = template.containers
-		for container_name in contentlet_containers:
-			if (('contentlet_container_content_%s' % container_name) in form.cleaned_data) and (('contentlet_container_dynamic_%s' % container_name) in form.cleaned_data):
-				content = form.cleaned_data[('contentlet_container_content_%s' % container_name)]
-				dynamic = form.cleaned_data[('contentlet_container_dynamic_%s' % container_name)]
-				contentlet, created = page.contentlets.get_or_create(name=container_name, defaults={'content': content, 'dynamic': dynamic})
-				if not created:
-					contentlet.content = content
-					contentlet.dynamic = dynamic
-					contentlet.save()
-		for container_name, container_content_type in contentreference_containers:
-			if ('contentreference_container_%s' % container_name) in form.cleaned_data:
-				content = form.cleaned_data[('contentreference_container_%s' % container_name)]
-				try:
-					contentreference = page.contentreferences.get(name=container_name)
-				except ContentReference.DoesNotExist:
-					contentreference = ContentReference(name=container_name, page=page, content_type=container_content_type)
-				else:
-					if content == None:
-						contentreference.delete()
-				
-				if content is not None:
-					contentreference.content_id = content.id
-					contentreference.save()
+	inlines = [ContentletInline, ContentReferenceInline] + ViewAdmin.inlines
 
 
 class TemplateAdmin(admin.ModelAdmin):
diff --git a/forms.py b/forms.py
index 8050d39..57e772d 100644
--- a/forms.py
+++ b/forms.py
@@ -1,8 +1,12 @@
-from django.core.exceptions import ValidationError
-from django.forms.models import model_to_dict, fields_for_model, ModelFormMetaclass, ModelForm
+from django import forms
+from django.contrib.admin.widgets import AdminTextareaWidget
+from django.core.exceptions import ValidationError, ObjectDoesNotExist
+from django.forms.models import model_to_dict, fields_for_model, ModelFormMetaclass, ModelForm, BaseInlineFormSet
+from django.forms.formsets import TOTAL_FORM_COUNT
 from django.template import loader, loader_tags, TemplateDoesNotExist, Context, Template as DjangoTemplate
 from django.utils.datastructures import SortedDict
-from philo.models import Entity, Template
+from philo.admin.widgets import ModelLookupWidget
+from philo.models import Entity, Template, Contentlet, ContentReference
 from philo.models.fields import RelationshipField
 from philo.utils import fattr
 
@@ -94,7 +98,7 @@ class EntityForm(EntityFormBase): # Would inherit from ModelForm directly if it
 def validate_template(template):
 	"""
 	Makes sure that the template and all included or extended templates are valid.
-	"""	
+	""" 
 	for node in template.nodelist:
 		try:
 			if isinstance(node, loader_tags.ExtendsNode):
@@ -119,4 +123,173 @@ class TemplateForm(ModelForm):
 		return code
 
 	class Meta:
-		model = Template
\ No newline at end of file
+		model = Template
+
+
+class ContainerForm(ModelForm):
+	def __init__(self, *args, **kwargs):
+		super(ContainerForm, self).__init__(*args, **kwargs)
+		self.verbose_name = self.instance.name.replace('_', ' ')
+
+
+class ContentletForm(ContainerForm):
+	content = forms.CharField(required=False, widget=AdminTextareaWidget)
+	
+	def should_delete(self):
+		return not bool(self.cleaned_data['content'])
+	
+	class Meta:
+		model = Contentlet
+		fields = ['name', 'content', 'dynamic']
+
+
+class ContentReferenceForm(ContainerForm):
+	def __init__(self, *args, **kwargs):
+		super(ContentReferenceForm, self).__init__(*args, **kwargs)
+		try:
+			self.fields['content_id'].widget = ModelLookupWidget(self.instance.content_type)
+		except ObjectDoesNotExist:
+			# This will happen when an empty form (which we will never use) gets instantiated.
+			pass
+	
+	def should_delete(self):
+		return (self.cleaned_data['content_id'] is None)
+	
+	class Meta:
+		model = ContentReference
+		fields = ['name', 'content_id']
+
+
+class ContainerInlineFormSet(BaseInlineFormSet):
+	def __init__(self, containers, data=None, files=None, instance=None, save_as_new=False, prefix=None, queryset=None):
+		# Unfortunately, I need to add some things to BaseInline between its __init__ and its super call, so
+		# a lot of this is repetition.
+		
+		# Start cribbed from BaseInline
+		from django.db.models.fields.related import RelatedObject
+		self.save_as_new = save_as_new
+		# is there a better way to get the object descriptor?
+		self.rel_name = RelatedObject(self.fk.rel.to, self.model, self.fk).get_accessor_name()
+		if self.fk.rel.field_name == self.fk.rel.to._meta.pk.name:
+			backlink_value = self.instance
+		else:
+			backlink_value = getattr(self.instance, self.fk.rel.field_name)
+		if queryset is None:
+			queryset = self.model._default_manager
+		qs = queryset.filter(**{self.fk.name: backlink_value})
+		# End cribbed from BaseInline
+		
+		self.container_instances, qs = self.get_container_instances(containers, qs)
+		self.extra_containers = containers
+		self.extra = len(self.extra_containers)
+		super(BaseInlineFormSet, self).__init__(data, files, prefix=prefix, queryset=qs)
+	
+	def get_container_instances(self, containers, qs):
+		raise NotImplementedError
+	
+	def total_form_count(self):
+		if self.data or self.files:
+			return self.management_form.cleaned_data[TOTAL_FORM_COUNT]
+		else:
+			return self.initial_form_count() + self.extra
+	
+	def save_existing_objects(self, commit=True):
+		self.changed_objects = []
+		self.deleted_objects = []
+		if not self.get_queryset():
+			return []
+
+		saved_instances = []
+		for form in self.initial_forms:
+			pk_name = self._pk_field.name
+			raw_pk_value = form._raw_value(pk_name)
+
+			# clean() for different types of PK fields can sometimes return
+			# the model instance, and sometimes the PK. Handle either.
+			pk_value = form.fields[pk_name].clean(raw_pk_value)
+			pk_value = getattr(pk_value, 'pk', pk_value)
+
+			obj = self._existing_object(pk_value)
+			if form.should_delete():
+				self.deleted_objects.append(obj)
+				obj.delete()
+				continue
+			if form.has_changed():
+				self.changed_objects.append((obj, form.changed_data))
+				saved_instances.append(self.save_existing(form, obj, commit=commit))
+				if not commit:
+					self.saved_forms.append(form)
+		return saved_instances
+
+	def save_new_objects(self, commit=True):
+		self.new_objects = []
+		for form in self.extra_forms:
+			if not form.has_changed():
+				continue
+			# If someone has marked an add form for deletion, don't save the
+			# object.
+			if form.should_delete():
+				continue
+			self.new_objects.append(self.save_new(form, commit=commit))
+			if not commit:
+				self.saved_forms.append(form)
+		return self.new_objects
+
+
+class ContentletInlineFormSet(ContainerInlineFormSet):
+	def __init__(self, data=None, files=None, instance=None, save_as_new=False, prefix=None, queryset=None):
+		if instance is None:
+			self.instance = self.fk.rel.to()
+		else:
+			self.instance = instance
+		
+		try:
+			containers = list(self.instance.containers[0])
+		except ObjectDoesNotExist:
+			containers = []
+	
+		super(ContentletInlineFormSet, self).__init__(containers, data, files, instance, save_as_new, prefix, queryset)
+	
+	def get_container_instances(self, containers, qs):
+		qs = qs.filter(name__in=containers)
+		container_instances = []
+		for container in qs:
+			container_instances.append(container)
+			containers.remove(container.name)
+		return container_instances, qs
+	
+	def _construct_form(self, i, **kwargs):
+		if i >= self.initial_form_count(): # and not kwargs.get('instance'):
+			kwargs['instance'] = self.model(name=self.extra_containers[i - self.initial_form_count() - 1])
+		
+		return super(ContentletInlineFormSet, self)._construct_form(i, **kwargs)
+
+
+class ContentReferenceInlineFormSet(ContainerInlineFormSet):
+	def __init__(self, data=None, files=None, instance=None, save_as_new=False, prefix=None, queryset=None):
+		if instance is None:
+			self.instance = self.fk.rel.to()
+		else:
+			self.instance = instance
+		
+		try:
+			containers = list(self.instance.containers[1])
+		except ObjectDoesNotExist:
+			containers = []
+	
+		super(ContentReferenceInlineFormSet, self).__init__(containers, data, files, instance, save_as_new, prefix, queryset)
+	
+	def get_container_instances(self, containers, qs):
+		qs = qs.filter(name__in=[c[0] for c in containers])
+		container_instances = []
+		for container in qs:
+			container_instances.append(container)
+			containers.remove((container.name, container.content_type))
+		return container_instances, qs
+
+	def _construct_form(self, i, **kwargs):
+		if i >= self.initial_form_count(): # and not kwargs.get('instance'):
+			name, content_type = self.extra_containers[i - self.initial_form_count() - 1]
+			kwargs['instance'] = self.model(name=name, content_type=content_type)
+
+		return super(ContentReferenceInlineFormSet, self)._construct_form(i, **kwargs)
\ No newline at end of file
diff --git a/models/pages.py b/models/pages.py
index 7476f18..4260761 100644
--- a/models/pages.py
+++ b/models/pages.py
@@ -98,6 +98,12 @@ class Page(View):
 	template = models.ForeignKey(Template, related_name='pages')
 	title = models.CharField(max_length=255)
 	
+	def get_containers(self):
+		if not hasattr(self, '_containers'):
+			self._containers = self.template.containers
+		return self._containers
+	containers = property(get_containers)
+	
 	def render_to_string(self, node=None, request=None, path=None, subpath=None, extra_context=None):
 		context = {}
 		context.update(extra_context or {})
diff --git a/templates/admin/philo/edit_inline/tabular_container.html b/templates/admin/philo/edit_inline/tabular_container.html
new file mode 100644
index 0000000..f93e52f
--- /dev/null
+++ b/templates/admin/philo/edit_inline/tabular_container.html
@@ -0,0 +1,125 @@
+{% load i18n adminmedia %}
+{{ inline_admin_formset.formset.management_form }}
+{% if inline_admin_formset.formset.forms %}
+<div class="inline-group" id="{{ inline_admin_formset.formset.prefix }}-group">
+  <div class="tabular inline-related {% if forloop.last %}last-related{% endif %}">
+<fieldset class="module{% if inline_admin_formset.classes %} {{ inline_admin_formset.classes|join:' ' }}{% endif %}">
+   <h2>{{ inline_admin_formset.opts.verbose_name_plural|capfirst }}</h2>
+   {{ inline_admin_formset.formset.non_form_errors }}
+   <table>
+	 <thead><tr>
+	 {% for field in inline_admin_formset.fields %}
+	   {% if not field.widget.is_hidden %}
+		 <th{% if field.required %} class="required"{% endif %}>{{ field.label|capfirst }}</th>
+	   {% endif %}
+	 {% endfor %}
+	 {% if inline_admin_formset.formset.can_delete %}<th>{% trans "Delete?" %}</th>{% endif %}
+	 </tr></thead>
+
+	 <tbody>
+	 {% for inline_admin_form in inline_admin_formset %}
+		{% if inline_admin_form.has_auto_field %}{{ inline_admin_form.pk_field.field }}{% endif %}
+		{{ inline_admin_form.fk_field.field }}
+		{% spaceless %}
+		{% for fieldset in inline_admin_form %}
+		{% for line in fieldset %}
+		  {% for field in line %}
+			{% if field.is_hidden %} {{ field.field }} {% endif %}
+		  {% endfor %}
+		{% endfor %}
+		{% endfor %}
+		{{ inline_admin_form.form.name.as_hidden }}
+		{% endspaceless %}
+		{% if inline_admin_form.form.non_field_errors %}
+		<tr><td colspan="{{ inline_admin_form.field_count }}">{{ inline_admin_form.form.non_field_errors }}</td></tr>
+		{% endif %}
+		<tr class="{% cycle "row1" "row2" %} {% if forloop.last %} empty-form{% endif %}"
+			 id="{{ inline_admin_formset.formset.prefix }}-{% if not forloop.last %}{{ forloop.counter0 }}{% else %}empty{% endif %}">
+			<th>{{ inline_admin_form.form.verbose_name|capfirst }}:</th>
+		{% for fieldset in inline_admin_form %}
+		  {% for line in fieldset %}
+			{% for field in line %}
+			  {% if field.field.name != 'name' %}
+			  <td class="{{ field.field.name }}">
+			  {% if field.is_readonly %}
+				  <p>{{ field.contents }}</p>
+			  {% else %}
+				  {{ field.field.errors.as_ul }}
+				  {{ field.field }}
+			  {% endif %}
+			  </td>
+			  {% endif %}
+			{% endfor %}
+		  {% endfor %}
+		{% endfor %}
+		{% if inline_admin_formset.formset.can_delete %}
+		  <td class="delete">{% if inline_admin_form.original %}{{ inline_admin_form.deletion_field.field }}{% endif %}</td>
+		{% endif %}
+		</tr>
+	 {% endfor %}
+	 </tbody>
+   </table>
+</fieldset>
+  </div>
+</div>
+
+<script type="text/javascript">
+(function($) {
+	$(document).ready(function($) {
+		var rows = "#{{ inline_admin_formset.formset.prefix }}-group .tabular.inline-related tbody tr";
+		var alternatingRows = function(row) {
+			$(rows).not(".add-row").removeClass("row1 row2")
+				.filter(":even").addClass("row1").end()
+				.filter(rows + ":odd").addClass("row2");
+		}
+		var reinitDateTimeShortCuts = function() {
+			// Reinitialize the calendar and clock widgets by force
+			if (typeof DateTimeShortcuts != "undefined") {
+				$(".datetimeshortcuts").remove();
+				DateTimeShortcuts.init();
+			}
+		}
+		var updateSelectFilter = function() {
+			// If any SelectFilter widgets are a part of the new form,
+			// instantiate a new SelectFilter instance for it.
+			if (typeof SelectFilter != "undefined"){
+				$(".selectfilter").each(function(index, value){
+				  var namearr = value.name.split('-');
+				  SelectFilter.init(value.id, namearr[namearr.length-1], false, "{% admin_media_prefix %}");
+				})
+				$(".selectfilterstacked").each(function(index, value){
+				  var namearr = value.name.split('-');
+				  SelectFilter.init(value.id, namearr[namearr.length-1], true, "{% admin_media_prefix %}");
+				})
+			}
+		}
+		var initPrepopulatedFields = function(row) {
+			row.find('.prepopulated_field').each(function() {
+				var field = $(this);
+				var input = field.find('input, select, textarea');
+				var dependency_list = input.data('dependency_list') || [];
+				var dependencies = row.find(dependency_list.join(',')).find('input, select, textarea');
+				if (dependencies.length) {
+					input.prepopulate(dependencies, input.attr('maxlength'));
+				}
+			});
+		}
+		$(rows).formset({
+			prefix: "{{ inline_admin_formset.formset.prefix }}",
+			addText: "{% blocktrans with inline_admin_formset.opts.verbose_name|title as verbose_name %}Add another {{ verbose_name }}{% endblocktrans %}",
+			formCssClass: "dynamic-{{ inline_admin_formset.formset.prefix }}",
+			deleteCssClass: "inline-deletelink",
+			deleteText: "{% trans "Remove" %}",
+			emptyCssClass: "empty-form",
+			removed: alternatingRows,
+			added: (function(row) {
+				initPrepopulatedFields(row);
+				reinitDateTimeShortCuts();
+				updateSelectFilter();
+				alternatingRows(row);
+			})
+		});
+	});
+})(django.jQuery);
+</script>
+{% endif %}