floof/controllers/art.py

   1 import logging
   2
   3 from pylons import config, request, response, session, tmpl_context as c
   4 from pylons.controllers.util import abort, redirect
   5 from pylons import url
   6 from floof.lib.base import BaseController, render
   7
   8 log = logging.getLogger(__name__)
   9
  10 from floof.lib import file_storage as storage, helpers as h
  11 from floof.model import Art, Rating, ArtUser
  12 from floof.model.art import ArtUserType
  13 from floof.model.comments import Discussion
  14 from floof.model.users import User, UserRelationship
  15
  16 import elixir
  17 #import magic
  18 import os.path
  19 import PIL
  20 import PIL.Image
  21 from sqlalchemy.exceptions import IntegrityError
  22 from sqlalchemy.orm.exc import NoResultFound
  23 from wtforms.validators import ValidationError
  24 from wtforms import *
  25
  26
  27 class ArtUploadForm(Form):
  28     by = TextField('Artists')
  29     file = FileField('Upload')
  30     url = TextField('Link')
  31
  32     # TODO: make this general purpose
  33     def validate_file(self, field):
  34         if field.data == u'':
  35             raise ValidationError('File is required')
  36
  37
  38 class ArtController(BaseController):
  39     def __before__(self, id=None):
  40         super(ArtController, self).__before__()
  41         # Awesome refactoring!
  42         if id:
  43             c.art = h.get_object_or_404(Art, id=id)
  44
  45     def new(self):
  46         """ New Art! """
  47         c.form = ArtUploadForm()
  48         return render("/art/new.mako")
  49
  50     # TODO: login required
  51     def create(self):
  52         c.form = ArtUploadForm(request.params)
  53         if not c.form.validate():
  54             ## TODO: JavaScript should be added to the upload form so that it is
  55             ## impossible to submit the form when it contains any invalid users,
  56             ## so this never happens.  Only autocompled usernames should be allowed.
  57             return render("/art/new.mako")
  58
  59         # Save the file
  60         upload = request.params['file']
  61         hash = storage.save_file('art/original', upload.file)
  62
  63         # Create a thumbnail and a medium view
  64         img = PIL.Image.open(
  65             config['app_conf']['static_root']
  66             + storage.get_path('art/original', hash)[1:]
  67         )
  68         for subdir, config_size in [('medium',    config['medium_size']),
  69                                     ('thumbnail', config['thumbnail_size'])]:
  70             path = config['app_conf']['static_root'] + storage.get_path("art/{0}".format(subdir), hash)
  71
  72             dir, _ = os.path.split(path)
  73             if not os.path.exists(dir):
  74                 os.makedirs(dir)
  75
  76             size = int(config_size)
  77             shrunken_img = img.copy()
  78             shrunken_img.thumbnail((size, size), PIL.Image.ANTIALIAS)
  79             shrunken_img.save(path, img.format)
  80
  81         #magicker = magic.Magic(mime=True)
  82         buffer = upload.file.read(64)
  83         upload.file.seek(0)
  84         mimetype = 'image/unknown' #magickery.from_buffer(buffer)
  85
  86         # XXX Ensure we can actually handle the mimetype
  87
  88         print mimetype
  89         c.art = Art(
  90             uploader=c.user,
  91             original_filename=upload.filename,
  92             hash=hash,
  93             mimetype=mimetype,
  94         )
  95         c.art.discussion = Discussion(count=0)
  96
  97         # For the moment, cheerfully assume that people are uploading their own
  98         # art
  99         ArtUser(art=c.art, user=c.user, type=ArtUserType.BY)
 100
 101
 102         try:
 103             elixir.session.commit()
 104             redirect(url('show_art', id=c.art.id))
 105         except IntegrityError:
 106             # XXX Check this as early as possible, and clean up the filesystem!
 107             # Right now this replaces the original file!
 108             hash = c.art.hash
 109             elixir.session.rollback()
 110             duplicate_art = Art.get_by(hash=hash)
 111             h.flash("We already have that one.")
 112             redirect(url('show_art', id=duplicate_art.id))
 113
 114
 115
 116     def show(self, id):
 117         # c.art = h.get_object_or_404(Art, id=id)
 118         if c.user:
 119             c.your_score = c.art.user_score(c.user)
 120         return render("/art/show.mako")
 121
 122
 123     # TODO: login required
 124     def rate(self, id):
 125         # c.art = h.get_object_or_404(Art, id=id)
 126         score = request.params.get("score")
 127         if score and score.isnumeric():
 128             score = int(score)
 129         else:
 130             score = Rating.reverse_options.get(score)
 131
 132         c.art.rate(score, c.user)
 133         elixir.session.commit()
 134
 135         redirect(url('show_art', id=c.art.id))
 136
 137
 138     def watchstream(self, name):
 139         """Watchstream for a certain user."""
 140         try:
 141             c.watching_user = User.get_by(name=name)
 142         except NoResultFound:
 143             abort(404)
 144
 145         # This user has watches which are users which have art
 146         # XXX use artist, not uploader
 147         c.artwork = Art.query.join(Art.uploader,
 148                                    User.target_of_relationships) \
 149                        .filter(UserRelationship.user_id == c.watching_user.id)
 150
 151         return render('/index.mako')