from django.views.debug import technical_500_response
import sys
from django.conf import settings

class UserBasedExceptionMiddleware(object):
    def process_exception(self, request, exception):
        if request.user.is_superuser or request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
            return technical_500_response(request, *sys.exc_info())

class MyModel(models.Model):
    site = models.ManyToManyField(Site)
    on_site = CurrentSiteManager()
    
    foobar = ... # A unique field
    
    def save(self, *args, **kwargs):
        if self.id == None: # new item should be created.
            # manually check a unique togeher, because django can't do this with a M2M field.
            # Obsolete if unique_together work with ManyToMany: http://code.djangoproject.com/ticket/702
            exist = MyModel.on_site.filter(foobar=self.foobar).count()
            if exist != 0:
                from django.db import IntegrityError
                # We can use attributes from this model instance, because it needs to have a primary key
                # value before a many-to-many relationship can be used.
                site = Site.objects.get_current()
                raise IntegrityError(
                    "MyModel item with same foobar field exist on site %r" % site
                )
        
        return super(MyModel, self).save(*args, **kwargs)

    class Meta:
        #unique_together = ("foobar", "site") # unique_together doesn't work with ManyToMany!
        # See: http://code.djangoproject.com/ticket/702

if settings.TEMPLATE_STRING_IF_INVALID != "":
    from django.contrib.auth import admin as auth_admin
    from django.contrib.admin import options

    def patched_render_to_response(*args, **kwargs):
        old = settings.TEMPLATE_STRING_IF_INVALID
        settings.TEMPLATE_STRING_IF_INVALID = ""
        result = render_to_response(*args, **kwargs)
        settings.TEMPLATE_STRING_IF_INVALID = old
        return result

    options.render_to_response = patched_render_to_response
    auth_admin.render_to_response = patched_render_to_response

<h1>SiteMap</h1>
{% include "SiteMap_items.html" %}

<ul>
{% for node in nodes %}
    

        {{ node.name }}
        {% with "SiteMap_items.html" as filename %}
        {% with node.subnodes as nodes %}
            {% if nodes %}
            

                {% include filename %}
            
            {% endif %}
        {% endwith %}
        {% endwith %}
    
{% endfor %}
</ul>

#!/bin/bash

function verbose_eval {
    echo $*
    eval $*
}

function add_port_forward {
    echo Try to remove old values for $1 $2
    verbose_eval VBoxManage --nologo setextradata "$1" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/$2/Protocol"
    verbose_eval VBoxManage --nologo setextradata "$1" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/$2/GuestPort"
    verbose_eval VBoxManage --nologo setextradata "$1" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/$2/HostPort"
    echo ---------------------------------------------------------------------

    echo Add for $1 $2
    verbose_eval VBoxManage --nologo setextradata "$1" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/$2/Protocol" "$3"
    verbose_eval VBoxManage --nologo setextradata "$1" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/$2/GuestPort" $4
    verbose_eval VBoxManage --nologo setextradata "$1" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/$2/HostPort" $5
    echo ---------------------------------------------------------------------

    echo Please check:
    verbose_eval VBoxManage --nologo getextradata "$1" enumerate | grep $2
    echo ---------------------------------------------------------------------
}

add_port_forward VM_NAME apache TCP 80 8080
add_port_forward VM_NAME SSH TCP 22 8081

def check_unique_together(sender, **kwargs):
    """
    Check models unique_together manually. Django enforced unique together only the database level, but
    some databases (e.g. SQLite) doesn't support this.

    usage:
        from django.db.models import signals
        signals.pre_save.connect(check_unique_together, sender=MyModelClass)
        
    or use auto_add_check_unique_together(), see below
    """
    instance = kwargs["instance"]
    for field_names in sender._meta.unique_together:
        model_kwargs = {}
        for field_name in field_names:
            try:
                data = getattr(instance, field_name)
            except FieldDoesNotExist:
                # e.g.: a missing field, which is however necessary.
                # The real exception on model creation should be raised. 
                continue
            model_kwargs[field_name] = data

        query_set = sender.objects.filter(**model_kwargs)
        if instance.pk != None:
            # Exclude the instance if it was saved in the past
            query_set = query_set.exclude(pk=instance.pk)

        count = query_set.count()
        if count > 0:
            field_names = get_text_list(field_names, _('and'))
            msg = _(u"%(model_name)s with this %(field_names)s already exists.") % {
                'model_name': unicode(instance.__class__.__name__),
                'field_names': unicode(field_names)
            }
            raise IntegrityError(msg)

def auto_add_check_unique_together(model_class):
    """
    Add only the signal handler check_unique_together, if a database without UNIQUE support is used.
    """
    if settings.DATABASE_ENGINE in ('sqlite3',):    # 'postgresql', 'mysql', 'sqlite3' or 'ado_mssql'.
        signals.pre_save.connect(check_unique_together, sender=model_class)