root/trunk/djedna/catalog2/views.py

# (c) Copyright 2008 Thomas Bohmbach, Jr.
# 
# This file is part of DJ Edna.
# 
# DJ Edna is free software: you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
# 
# DJ Edna is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
# more details.
# 
# You should have received a copy of the GNU General Public License along with
# DJ Edna.  If not, see <http://www.gnu.org/licenses/>.

import logging as log
import mimetypes
import os

from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User, Group
from django.contrib.sites.models import Site, RequestSite
from django.core.urlresolvers import reverse
from django.http import HttpResponse, HttpResponseRedirect
from django.template import loader, Context, RequestContext
from django.template import TemplateDoesNotExist
from django.shortcuts import render_to_response, get_object_or_404
from django.utils.http import urlquote
from django.views.generic.list_detail import object_list, object_detail
from django.views import static

from djedna.catalog2.forms import LocalPathTrackFileForm, UploadTrackFileForm
from djedna.catalog2.forms import UploadImageFileForm
from djedna.catalog2.forms import get_track_form
from djedna.catalog2.models import TrackFile, Track, ImageFile


def trackfile_list(
        request, queryset=None, paginate_by=None, page=None,
        allow_empty=True, template_name='catalog2/trackfile_list.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_object_name='trackfile', mimetype=None
    ):
    """
    Generic list of TrackFiles.
    
    Templates: ``catalog2/trackfile_list.html``
    Context:
        trackfile_list
            list of trackfiles
        is_paginated
            are the results paginated?
        results_per_page
            number of trackfiles per page (if paginated)
        has_next
            is there a next page?
        has_previous
            is there a prev page?
        page
            the current page
        next
            the next page
        previous
            the previous page
        pages
            number of pages, total
        hits
            number of trackfiles, total
        last_on_page
            the result number of the last of trackfile in the
            trackfile_list (1-indexed)
        first_on_page
            the result number of the first trackfile in the
            trackfile_list (1-indexed)
        page_range:
            A list of the page numbers (1-indexed).
    """
    if queryset == None:
        queryset = TrackFile.on_site.all()
    return object_list(
        request, queryset, paginate_by=paginate_by, page=page,
        allow_empty=allow_empty, template_name=template_name,
        template_loader=template_loader, extra_context=extra_context,
        context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )

def trackfile_detail(
        request, trackfile_id=None, queryset=None,
        template_name='catalog2/trackfile_detail.html',
        template_loader=loader, extra_context=None,
        context_processors=None, template_object_name='trackfile',
        mimetype=None
    ):
    """
    Generic detail of a TrackFile.
    
    Templates: ``<app_label>/<model_name>_detail.html``
    Context:
        trackfile
            the trackfile
    """
    trackfile = get_object_or_404(TrackFile, pk=trackfile_id)
    if queryset == None:
        queryset = TrackFile.on_site.all()
    if trackfile.mimetype:
        mimetype_ext = mimetypes.guess_extension(trackfile.mimetype)
        if mimetype_ext:
            mimetype_ext = mimetype_ext[1:] # Drop the leading '.'
            template_base, template_ext = os.path.splitext(template_name)
            ext_template_name = '%s_%s%s' % (template_base,
                                             mimetype_ext,
                                             template_ext)
            try:
                loader.get_template(ext_template_name)
                template_name = ext_template_name
            except TemplateDoesNotExist, tdne:
                pass
    return object_detail(
        request, queryset, object_id=trackfile_id,
        template_name=template_name, template_loader=loader,
        extra_context=extra_context, context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )

def trackfile_import(
        request, next_page=None,
        template_name='catalog2/trackfile_import.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_form_name='form'
    ):
    next_page = next_page or request.POST.get('next_page', '')
    if request.method == 'POST':
        form = LocalPathTrackFileForm(data=request.POST)
        if form.is_valid():
            path = form.path
            if path:
                group_hash = TrackFile.objects.add_from_path(path) or 'none'
                if not next_page:
                    next_page = reverse(
                        'djedna_trackfile_import_result',
                        kwargs={'group_hash' : group_hash}
                    )
                return HttpResponseRedirect(next_page)
    else:
        form = LocalPathTrackFileForm()
    t = template_loader.get_template(template_name)
    c = RequestContext(request,
                       {template_form_name: form,
                        'next_page' : next_page},
                       context_processors)
    if extra_context is None: extra_context = {}
    for key, value in extra_context.items():
        if callable(value):
            c[key] = value()
        else:
            c[key] = value
    return HttpResponse(t.render(c))

def trackfile_import_result(
        request, group_hash=None, paginate_by=None, page=None,
        allow_empty=True,
        template_name='catalog2/trackfile_import_result.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_object_name='trackfile', mimetype=None
    ):
    if group_hash and group_hash != 'none':
        queryset = TrackFile.objects.filter(group_hash=group_hash)
    else:
        queryset = TrackFile.objects.none()
    return trackfile_list(
        request, queryset=queryset, paginate_by=paginate_by, page=page,
        allow_empty=allow_empty, template_name=template_name,
        template_loader=template_loader, extra_context=extra_context,
        context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )

def trackfile_upload(
        request, track=None, next_page=None,
        template_name='catalog2/trackfile_upload.html',
        template_loader=loader, extra_context=None,
        context_processors=None, template_form_name='form'
    ):
    next_page = next_page or request.REQUEST.get('next_page', '')
    if request.method == 'POST':
        form = UploadTrackFileForm(request.POST, request.FILES)
        if form.is_valid():
            trackfile_upload = form.save()
            if request.user.is_authenticated():
                trackfile_upload.user = request.user
                trackfile_upload.save()
            if track and trackfile_upload.trackfile:
                trackfile_upload.trackfile.track = track
                trackfile_upload.trackfile.save()
            if not next_page:
                if trackfile_upload.trackfile:
                    group_hash = trackfile_upload.trackfile.group_hash or 'none'
                else:
                    trackfile_upload.delete()
                    group_hash = 'none'
                next_page = reverse(
                    'djedna_trackfile_upload_result',
                    kwargs={'group_hash' : group_hash}
                )
            return HttpResponseRedirect(next_page)
    else:
        form = UploadTrackFileForm()
    t = template_loader.get_template(template_name)
    c = RequestContext(request,
                       {template_form_name: form,
                        'next_page' : next_page},
                       context_processors)
    if extra_context is None: extra_context = {}
    for key, value in extra_context.items():
        if callable(value):
            c[key] = value()
        else:
            c[key] = value
    return HttpResponse(t.render(c))

def trackfile_upload_result(
        request, group_hash=None, paginate_by=None, page=None,
        allow_empty=True,
        template_name='catalog2/trackfile_upload_result.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_object_name='trackfile', mimetype=None
    ):
    if group_hash and group_hash != 'none':
        queryset = TrackFile.objects.filter(group_hash=group_hash)
    else:
        queryset = TrackFile.objects.none()
    return trackfile_list(
        request, queryset=queryset, paginate_by=paginate_by, page=page,
        allow_empty=allow_empty, template_name=template_name,
        template_loader=template_loader, extra_context=extra_context,
        context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )


def imagefile_list(
        request, queryset=None, paginate_by=None, page=None,
        allow_empty=True, template_name='catalog2/imagefile_list.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_object_name='imagefile', mimetype=None
    ):
    """
    Generic list of ImageFiles.
    
    Templates: ``catalog2/imageile_list.html``
    Context:
        imagefile_list
            list of imagefiles
        is_paginated
            are the results paginated?
        results_per_page
            number of trackfiles per page (if paginated)
        has_next
            is there a next page?
        has_previous
            is there a prev page?
        page
            the current page
        next
            the next page
        previous
            the previous page
        pages
            number of pages, total
        hits
            number of trackfiles, total
        last_on_page
            the result number of the last of imagefile in the
                imagefile_list (1-indexed)
        first_on_page
            the result number of the first imagefile in the
                imagefile_list (1-indexed)
        page_range:
            A list of the page numbers (1-indexed).
    """
    if queryset == None:
        queryset = ImageFile.on_site.all()
    return object_list(
        request, queryset, paginate_by=paginate_by, page=page,
        allow_empty=allow_empty, template_name=template_name,
        template_loader=template_loader, extra_context=extra_context,
        context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )

def imagefile_detail(
        request, imagefile_id=None, queryset=None,
        template_name='catalog2/imagefile_detail.html',
        template_loader=loader, extra_context=None,
        context_processors=None, template_object_name='imagefile',
        mimetype=None
    ):
    """
    Generic detail of an ImageFile.
    
    Templates: ``<app_label>/<model_name>_detail.html``
    Context:
        imagefile
            the imagefile
    """
    imagefile = get_object_or_404(ImageFile, pk=imagefile_id)
    if queryset == None:
        queryset = ImageFile.on_site.all()
    if imagefile.mimetype:
        mimetype_ext = mimetypes.guess_extension(imagefile.mimetype)
        if mimetype_ext:
            mimetype_ext = mimetype_ext[1:] # Drop the leading '.'
            template_base, template_ext = os.path.splitext(template_name)
            ext_template_name = '%s_%s%s' % (template_base,
                                             mimetype_ext,
                                             template_ext)
            try:
                loader.get_template(ext_template_name)
                template_name = ext_template_name
            except TemplateDoesNotExist, tdne:
                pass
    return object_detail(
        request, queryset, object_id=imagefile_id,
        template_name=template_name, template_loader=loader,
        extra_context=extra_context, context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )

def imagefile_upload(
        request, next_page=None,
        template_name='catalog2/imagefile_upload.html',
        template_loader=loader, extra_context=None,
        context_processors=None, template_form_name='form'
    ):
    next_page = next_page or request.REQUEST.get('next_page', '')
    if request.method == 'POST':
        form = UploadImageFileForm(request.POST, request.FILES)
        if form.is_valid():
            imagefile_upload = form.save()
            if request.user.is_authenticated():
                imagefile_upload.user = request.user
                imagefile_upload.save()
            if not next_page:
                if imagefile_upload.imagefile:
                    group_hash = imagefile_upload.imagefile.group_hash or 'none'
                else:
                    imagefile_upload.delete()
                    group_hash = 'none'
                next_page = reverse(
                    'djedna_imagefile_upload_result',
                    kwargs={'group_hash' : group_hash}
                )
            return HttpResponseRedirect(next_page)
    else:
        form = UploadImageFileForm()
    t = template_loader.get_template(template_name)
    c = RequestContext(request,
                       {template_form_name: form,
                        'next_page' : next_page},
                       context_processors)
    if extra_context is None: extra_context = {}
    for key, value in extra_context.items():
        if callable(value):
            c[key] = value()
        else:
            c[key] = value
    return HttpResponse(t.render(c))

def imagefile_upload_result(
        request, group_hash=None, paginate_by=None, page=None,
        allow_empty=True,
        template_name='catalog2/imagefile_upload_result.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_object_name='imagefile', mimetype=None
    ):
    if group_hash and group_hash != 'none':
        queryset = ImageFile.objects.filter(group_hash=group_hash)
    else:
        queryset = ImageFile.objects.none()
    return imagefile_list(
        request, queryset=queryset, paginate_by=paginate_by, page=page,
        allow_empty=allow_empty, template_name=template_name,
        template_loader=template_loader, extra_context=extra_context,
        context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )


def track_list(
        request, queryset=None, paginate_by=None, page=None,
        allow_empty=True, template_name='catalog2/track_list.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_object_name='track', mimetype=None
    ):
    """
    Generic list of Tracks.
    
    Templates: ``catalog2/track_list.html``
    Context:
        track_list
            list of tracks
        is_paginated
            are the results paginated?
        results_per_page
            number of tracks per page (if paginated)
        has_next
            is there a next page?
        has_previous
            is there a prev page?
        page
            the current page
        next
            the next page
        previous
            the previous page
        pages
            number of pages, total
        hits
            number of objects, total
        last_on_page
            the result number of the last of object in the
            track_list (1-indexed)
        first_on_page
            the result number of the first track in the
            track_list (1-indexed)
        page_range:
            A list of the page numbers (1-indexed).
    """
    if queryset == None:
        queryset = Track.on_site.all()
    return object_list(
        request, queryset, paginate_by=paginate_by, page=page,
        allow_empty=allow_empty, template_name=template_name,
        template_loader=template_loader, extra_context=extra_context,
        context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )

def track_detail(
        request, track_slug=None, queryset=None,
        template_name='catalog2/track_detail.html',
        template_loader=loader, extra_context=None,
        context_processors=None, template_object_name='track',
        mimetype=None
    ):
    """
    Generic detail of a Track.
    
    Templates: ``<app_label>/<model_name>_detail.html``
    Context:
        track
            the track
    """
    track = get_object_or_404(Track, slug=track_slug)
    if queryset == None:
        queryset = Track.on_site.all()
    return object_detail(
        request, queryset, object_id=track.id,
        template_name=template_name, template_loader=loader,
        extra_context=extra_context, context_processors=context_processors,
        template_object_name=template_object_name, mimetype=mimetype
    )

def track_create(
        request, initial=None, next_page=None,
        template_name='catalog2/track_create.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_form_name='form'
    ):
    pass

def track_create_from_trackfile(
        request, trackfile=None, next_page=None,
        template_name='catalog2/track_create.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_form_name='form'
    ):
    pass

def track_update(
        request, track_slug=None, next_page=None,
        template_name='catalog2/track_update.html',
        template_loader=loader, extra_context=None, context_processors=None,
        template_form_name='form'
    ):
    track = get_object_or_404(Track, slug=track_slug)
    next_page = next_page or request.POST.get('next_page', '')
    if request.method == 'POST':
        form = get_track_form(instance=track, data=request.POST)
        if form.is_valid():
            form.save()
            track.trackfiles = form.cleaned_data['trackfiles']
            if not next_page:
                next_page = reverse(
                    'djedna_track_detail',
                    kwargs={'track_slug' : track.slug}
                )
            return HttpResponseRedirect(next_page)
    else:
        data = {
            'trackfiles' :
                [trackfile.id for trackfile in track.trackfiles.all()],
        }
        form = get_track_form(initial=data, instance=track)
    t = template_loader.get_template(template_name)
    c = RequestContext(request,
                       {template_form_name: form,
                        'next_page' : next_page},
                       context_processors)
    if extra_context is None: extra_context = {}
    for key, value in extra_context.items():
        if callable(value):
            c[key] = value()
        else:
            c[key] = value
    return HttpResponse(t.render(c))

def track_upload(
        request, track_slug=None, next_page=None,
        template_name='catalog2/trackfile_upload.html',
        template_loader=loader, extra_context=None,
        context_processors=None, template_form_name='form'
    ):
    track = get_object_or_404(Track, slug=track_slug)
    return trackfile_upload(
        request, track=track, next_page=next_page,
        template_name=template_name,
        template_loader=loader, extra_context=extra_context,
        context_processors=context_processors,
        template_form_name=template_form_name
    )