X-Git-Url: http://git.ithinksw.org/philo.git/blobdiff_plain/353614c3d8e5af2872d2d0ef0c494e36548f6370..43a0fca55725921fd0748de90479ee2fa9cdbc6f:/contrib/penfield/embed.py?ds=inline

diff --git a/contrib/penfield/embed.py b/contrib/penfield/embed.py
index b279fc7..7f875cc 100644
--- a/contrib/penfield/embed.py
+++ b/contrib/penfield/embed.py
@@ -32,7 +32,57 @@ class TemplateField(models.TextField):
 		return Template(value)
 
 
+class Embed(models.Model):
+	embedder_content_type = models.ForeignKey(ContentType, related_name="embedder_related")
+	embedder_object_id = models.PositiveIntegerField()
+	embedder = generic.GenericForeignKey("embedder_content_type", "embedder_object_id")
+	
+	embedded_content_type = models.ForeignKey(ContentType, related_name="embedded_related")
+	embedded_object_id = models.PositiveIntegerField()
+	embedded = generic.GenericForeignKey("embedded_content_type", "embedded_object_id")
+	
+	def delete(self):
+		# This needs to be called manually.
+		super(Embed, self).delete()
+		
+		# Cycle through all the fields in the embedder and remove all references
+		# to the embedded object.
+		embedder = self.embedder
+		for field in embedder._meta.fields:
+			if isinstance(field, EmbedField):
+				attr = getattr(embedder, field.attname)
+				setattr(embedder, field.attname, attr.replace(self.get_embed_tag(), ''))
+		
+		embedder.save()
+	
+	def get_embed_tag(self):
+		"""Convenience function to construct the embed tag that would create this instance."""
+		ct = self.embedded_content_type
+		return "{%% embed %s.%s %s %%}" % (ct.app_label, ct.model, self.embedded_object_id)
+	
+	class Meta:
+		app_label = 'penfield'
+
+
+def sync_embedded_instances(model_instance, embedded_instances):
+	model_instance_ct = ContentType.objects.get_for_model(model_instance)
+	
+	# Cycle through all the embedded instances and make sure that they are linked to
+	# the model instance. Track their pks.
+	new_embed_pks = []
+	for embedded_instance in embedded_instances:
+		embedded_instance_ct = ContentType.objects.get_for_model(embedded_instance)
+		new_embed = Embed.objects.get_or_create(embedder_content_type=model_instance_ct, embedder_object_id=model_instance.id, embedded_content_type=embedded_instance_ct, embedded_object_id=embedded_instance.id)[0]
+		new_embed_pks.append(new_embed.pk)
+	
+	# Then, delete all embed objects related to this model instance which do not relate
+	# to one of the newly embedded instances.
+	Embed.objects.filter(embedder_content_type=model_instance_ct, embedder_object_id=model_instance.id).exclude(pk__in=new_embed_pks).delete()
+
+
 class EmbedField(TemplateField):
+	_embedded_instances = set()
+	
 	def validate_template(self, template):
 		"""Check to be sure that the embedded instances and templates all exist."""
 		for node in template.nodelist:
@@ -47,30 +97,32 @@ class EmbedField(TemplateField):
 					embedded_template = loader.get_template(node.template_name)
 					self.validate_template(embedded_template)
 				elif node.object_pk is not None:
-					embedded_instance = node.model.objects.get(pk=node.object_pk)
+					self._embedded_instances.add(node.model.objects.get(pk=node.object_pk))
 	
-	def to_template(self, value):
-		return Template("{% load embed %}" + value)
+	def pre_save(self, model_instance, add):
+		if not hasattr(model_instance, '_embedded_instances'):
+			model_instance._embedded_instances = set()
+		model_instance._embedded_instances |= self._embedded_instances
+		return getattr(model_instance, self.attname)
 
 
-class Embed(models.Model):
-	embedder_embed_field = models.CharField(max_length=255)
-	
-	embedder_contenttype = models.ForeignKey(ContentType, related_name="embedder_related")
-	embedder_object_id = models.PositiveIntegerField()
-	embedder = generic.GenericForeignKey("embedder_contenttype", "embedder_object_id")
-	
-	embedded_contenttype = models.ForeignKey(ContentType, related_name="embedded_related")
-	embedded_object_id = models.PositiveIntegerField()
-	embedded = generic.GenericForeignKey("embedded_contenttype", "embedded_object_id")
-	
-	def delete(self):
-		# Unclear whether this would be called by a cascading deletion.
-		
-		super(Embed, self).delete()
-	
-	class Meta:
-		app_label = 'penfield'
+# Add a post-save signal function to run the syncer.
+def post_save_embed_sync(sender, instance, **kwargs):
+	if hasattr(instance, '_embedded_instances') and instance._embedded_instances:
+		sync_embedded_instances(instance, instance._embedded_instances)
+models.signals.post_save.connect(post_save_embed_sync)
+
+
+# Deletions can't cascade automatically without a GenericRelation - but there's no good way of
+# knowing what models should have one. Anything can be embedded! Also, cascading would probably
+# bypass the Embed model's delete method.
+def post_delete_cascade(sender, instance, **kwargs):
+	ct = ContentType.objects.get_for_model(sender)
+	embeds = Embed.objects.filter(embedded_content_type=ct, embedded_object_id=instance.id)
+	for embed in embeds:
+		embed.delete()
+	Embed.objects.filter(embedder_content_type=ct, embedder_object_id=instance.id).delete()
+models.signals.post_delete.connect(post_delete_cascade)
 
 
 class Test(models.Model):