summaryrefslogtreecommitdiffstats
path: root/bn_django/photos/views.py
blob: 7cc53320b6e358dfd50d7dd862c7cc9aabf55b50 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
# Create your views here.

# django imports
from django.conf import settings
from django import forms, http, template
from django.contrib.auth.decorators import login_required
from django.shortcuts import get_object_or_404, render_to_response
from django.http import HttpResponse

# other imports
import zipfile
import os
import stat
import shutil
from datetime import datetime
from tempfile import NamedTemporaryFile, mkdtemp
import Image
try:
	from cStringIO import StringIO
except ImportError:
	from StringIO import StringIO

# Handling settings here
try:
    STOCKPHOTO_BASE = settings.STOCKPHOTO_BASE.strip('/')
except AttributeError:
    STOCKPHOTO_BASE = 'photos'
    
# models
from bn_django.photos.models import Gallery, Photo

# views

class ImportManipulator(forms.Manipulator):
    def __init__(self):
        self.fields = (
            forms.FileUploadField(field_name="zipfile",
                            is_required=True,
                            validator_list=[self.valid_zipfile,]),
            forms.TextField(field_name="photographer"),
            forms.DateField(field_name="date"),
        )
    def valid_zipfile(self, field_data, all_data):
    	zip_file = StringIO(field_data['content'])
	zip = zipfile.ZipFile(zip_file)
	return not zip.testzip()



@login_required
def import_photos(request, thegallery):
    """Import a batch of photographs uploaded by the user.

    Import a batch of photographs uploaded by the user, all with
    the same information for gallery, photographer and date.  The
    title will be set from the filename, and the description will be
    blank.  Self-respecting photographers will edit the fields for
    each photograph; this is just a way to get a bunch of photographs
    uploaded quickly.

    The photographs should be wrapped up in a zip archive.  The
    archive will be unpacked (and flattened) in a temporary directory,
    and all image files will be identified and imported into the
    gallery.  Other files in the archive will be silently ignored.

    After importing the images, the view will display a page which may
    contain the number of images imported, and a link to the gallery
    into which the images were imported.
    """
    # Check if the gallery is valid
    gallery = get_object_or_404(Gallery, pk=thegallery)
    # And that the user has permission to add photos
    if not request.user.has_perm('gallery.add_photo'):
        return http.HttpResponseForbidden("No permission to add photos")

    manipulator = ImportManipulator()
    if request.POST:
        new_data = request.POST.copy()
        new_data.update(request.FILES)
        errors = manipulator.get_validation_errors(new_data)
        if not errors:
            # So now everything is okay
	    f = StringIO(new_data['zipfile']['content']) # the zip"file"
	    zip = zipfile.ZipFile(f)
            manipulator.do_html2python(new_data)
            date = new_data['date']
            if not date:
                date = datetime.date(datetime.now())

	    destdir= os.path.join(settings.MEDIA_ROOT, STOCKPHOTO_BASE,
                                  datetime.strftime(datetime.now(), 
				  "%Y/%m/%d/"))
	    if not os.path.isdir(destdir):
	        os.makedirs(destdir, 0775)
        for filename in zip.namelist():
            photopath = os.path.join(destdir, os.path.basename(filename))
            data = zip.read(filename)
            file_data = StringIO(data)
            try:
                Image.open(file_data)
            except:
                # don't save and process non Image files
                continue
            photo = file(photopath, "wb")
            photo.write(data)
            
            # Create the object
            if photopath.startswith(os.path.sep):
                photopath = photopath[len(settings.MEDIA_ROOT):]
            photo = Photo(image=photopath, date=date,
                          photographer=new_data['photographer'],
                          title = os.path.basename(filename),
                          gallery_id = thegallery)
            # Save it -- the thumbnails etc. get created.
            photo.save()
		
        # And jump to the directory for this gallery
        response = http.HttpResponseRedirect(gallery.get_absolute_url())
        response['Pragma'] = 'no cache'
        response['Cache-Control'] = 'no-cache'
        return response
    else:
        errors = new_data = {}
    form = forms.FormWrapper(manipulator, new_data, errors)
    return render_to_response('photos/import_form.html',
			      dict(form=form, gallery=gallery))
	# request, 

@login_required
def export(request, thegallery):
    """Export a gallery to a zip file and send it to the user.
    """
    # Check if the gallery is valid
    gallery = get_object_or_404(Gallery, pk=thegallery)
    
    # gather up the photos into a new directory
    tmpdir = mkdtemp()
    for photo in gallery.photo_set.all():
        shutil.copy(photo.get_image_filename(),
                        tmpdir)
    files = [ os.path.join(tmpdir, ff) for ff in os.listdir(tmpdir) ]
    outfile = NamedTemporaryFile()
    zf = zipfile.ZipFile(outfile, "w",
                         compression=zipfile.ZIP_DEFLATED)
    for filename in files:
        zf.write(filename, arcname=os.path.basename(filename))
    zf.close()
    outfile.flush()
    outfile.seek(0)
    shutil.rmtree(tmpdir)
    response = HttpResponse(outfile)
    response['Content-Type'] = "application/zip"
    response['Content-Length'] = str(os.stat(outfile.name)[stat.ST_SIZE])
    response['Content-Disposition'] = "attachment; filename=photos.zip"
    return response