from django.core.exceptions import ImproperlyConfigured

from django.core.management.base import BaseCommand, CommandError

from django.core import serializers

from django.utils.datastructures import SortedDict

from optparse import make_option

class Command(BaseCommand):

    option_list = BaseCommand.option_list + (

        make_option('--format', default='json', dest='format',

            help='Specifies the output serialization format for fixtures.'),

        make_option('--indent', default=None, dest='indent', type='int',

            help='Specifies the indent level to use when pretty-printing output'),

        make_option('-e', '--exclude', dest='exclude',action='append', default=[],

            help='App to exclude (use multiple --exclude to exclude multiple apps).'),

    )

    help = 'Output the contents of the database as a fixture of the given format.'

    args = '[appname ...]'

    def handle(self, *app_labels, **options):

        from django.db.models import get_app, get_apps, get_models, get_model

        format = options.get('format','json')

        indent = options.get('indent',None)

        exclude = options.get('exclude',[])

        show_traceback = options.get('traceback', False)

        excluded_apps = [get_app(app_label) for app_label in exclude]

        if len(app_labels) == 0:

            app_list = SortedDict([(app, None) for app in get_apps() if app not in excluded_apps])

        else:

            app_list = SortedDict()

            for label in app_labels:

                try:

                    app_label, model_label = label.split('.')

                    try:

                        app = get_app(app_label)

                    except ImproperlyConfigured:

                        raise CommandError("Unknown application: %s" % app_label)

                    model = get_model(app_label, model_label)

                    if model is None:

                        raise CommandError("Unknown model: %s.%s" % (app_label, model_label))

                    if app in app_list.keys():

                        if app_list[app] and model not in app_list[app]:

                            app_list[app].append(model)

                    else:

                        app_list[app] = [model]

                except ValueError:

                    # This is just an app - no model qualifier

                    app_label = label

                    try:

                        app = get_app(app_label)

                    except ImproperlyConfigured:

                        raise CommandError("Unknown application: %s" % app_label)

                    app_list[app] = None

        # Check that the serialization format exists; this is a shortcut to

        # avoid collating all the objects and _then_ failing.

        if format not in serializers.get_public_serializer_formats():

            raise CommandError("Unknown serialization format: %s" % format)

        try:

            serializers.get_serializer(format)

        except KeyError:

            raise CommandError("Unknown serialization format: %s" % format)

        objects = []

        for app, model_list in app_list.items():

            if model_list is None:

                model_list = get_models(app)

            for model in model_list:

                if not model._meta.proxy:

                    objects.extend(model._default_manager.all())

        try:

            return serializers.serialize(format, objects, indent=indent)

        except Exception, e:

            if show_traceback:

                raise

            raise CommandError("Unable to serialize database: %s" % e)