mediagoblin/media_types/blog/views.py

   1 # GNU MediaGoblin -- federated, autonomous media hosting
   2 # Copyright (C) 2011, 2012 MediaGoblin contributors.  See AUTHORS.
   3 #
   4 # This program is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU Affero General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU Affero General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Affero General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 import logging
  18
  19 _log = logging.getLogger(__name__)
  20
  21 from datetime import datetime
  22
  23 from werkzeug.exceptions import Forbidden
  24
  25 from mediagoblin import mg_globals
  26
  27 from mediagoblin.media_types.blog import forms as blog_forms
  28 from mediagoblin.media_types.blog.models import Blog, BlogPostData
  29 from mediagoblin.media_types.blog.lib import may_edit_blogpost, set_blogpost_state
  30
  31 from mediagoblin.messages import add_message, SUCCESS, ERROR
  32 from mediagoblin.decorators import (require_active_login, active_user_from_url,
  33                             get_media_entry_by_id, user_may_alter_collection,
  34                             get_user_collection)
  35 from mediagoblin.tools.response import (render_to_response,
  36                                         redirect, redirect_obj, render_404)
  37 from mediagoblin.tools.translate import pass_to_ugettext as _
  38 from mediagoblin.tools.template import render_template
  39 from mediagoblin.tools.text import (
  40     convert_to_tag_list_of_dicts, media_tags_as_string, clean_html,
  41     cleaned_markdown_conversion)
  42 from mediagoblin.tools.url import slugify
  43
  44 from mediagoblin.db.util import check_media_slug_used, check_collection_slug_used
  45 from mediagoblin.db.models import User, Collection, MediaEntry
  46
  47 from mediagoblin.notifications import add_comment_subscription
  48
  49
  50 @require_active_login
  51 def blog_edit(request):
  52     """
  53     View for editing the existing blog or automatically
  54     creating a new blog if user does not have any yet.
  55     """
  56     url_user = request.matchdict.get('user', None)
  57     blog_slug = request.matchdict.get('blog_slug', None)
  58
  59     max_blog_count = 1
  60     form = blog_forms.BlogEditForm(request.form)
  61     # the blog doesn't exists yet
  62     if not blog_slug:
  63         if Blog.query.filter_by(author=request.user.id).count()<max_blog_count:
  64             if request.method=='GET':
  65                 return render_to_response(
  66                     request,
  67                     'mediagoblin/blog/blog_edit_create.html',
  68                     {'form': form,
  69                     'user' : request.user,
  70                     'app_config': mg_globals.app_config})
  71
  72             if request.method=='POST' and form.validate():
  73                 _log.info("Here")
  74                 blog = Blog()
  75                 blog.title = unicode(form.title.data)
  76                 blog.description = unicode(cleaned_markdown_conversion((form.description.data)))  #remember clean html data.
  77                 blog.author = request.user.id
  78                 blog.generate_slug()
  79
  80                 blog.save()
  81                 return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
  82                         user=request.user.username,
  83                         blog_slug=blog.slug)
  84         else:
  85             #the case when max blog count is one.
  86             blog = request.db.Blog.query.filter_by(author=request.user.id).first()
  87             add_message(request, ERROR, "Welcome! You already have created a blog.")
  88             return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
  89                         user=request.user.username,
  90                         blog_slug=blog.slug)
  91
  92
  93     #Blog already exists.
  94     else:
  95         blog = Blog.query.filter_by(slug=blog_slug).first()
  96         if request.method == 'GET':
  97             defaults = dict(
  98                 title = blog.title,
  99                 description = cleaned_markdown_conversion(blog.description),
 100                 author = request.user.id)
 101
 102             form = blog_forms.BlogEditForm(**defaults)
 103
 104             return render_to_response(
 105                     request,
 106                     'mediagoblin/blog/blog_edit_create.html',
 107                     {'form': form,
 108                      'user': request.user,
 109                      'app_config': mg_globals.app_config})
 110         else:
 111             if request.method == 'POST' and form.validate():
 112                 blog.title = unicode(form.title.data)
 113                 blog.description = unicode(cleaned_markdown_conversion((form.description.data)))
 114                 blog.author = request.user.id
 115                 blog.generate_slug()
 116
 117                 blog.save()
 118                 add_message(request, SUCCESS, "Your blog is updated.")
 119                 return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 120                         user=request.user.username,
 121                         blog_slug=blog.slug)
 122
 123 @require_active_login
 124 def blogpost_create(request):
 125
 126     form = blog_forms.BlogPostEditForm(request.form, license=request.user.license_preference)
 127
 128     if request.method == 'POST' and form.validate():
 129         blog_slug = request.matchdict.get('blog_slug')
 130         blog = request.db.Blog.query.filter_by(slug=blog_slug,
 131             author=request.user.id).first()
 132         if not blog:
 133             return render_404(request)
 134
 135         blogpost = request.db.MediaEntry()
 136         blogpost.media_type = 'mediagoblin.media_types.blogpost'
 137         blogpost.title = unicode(form.title.data)
 138         blogpost.description = unicode(cleaned_markdown_conversion((form.description.data)))
 139         blogpost.tags =  convert_to_tag_list_of_dicts(form.tags.data)
 140         blogpost.license = unicode(form.license.data) or None
 141         blogpost.uploader = request.user.id
 142         blogpost.generate_slug()
 143
 144         set_blogpost_state(request, blogpost)
 145         blogpost.save()
 146
 147         # connect this blogpost to its blog
 148         blog_post_data = request.db.BlogPostData()
 149         blog_post_data.blog = blog.id
 150         blog_post_data.media_entry = blogpost.id
 151         blog_post_data.save()
 152
 153         add_message(request, SUCCESS, _('Woohoo! Submitted!'))
 154         add_comment_subscription(request.user, blogpost)
 155         return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 156                         user=request.user.username,
 157                         blog_slug=blog.slug)
 158
 159     return render_to_response(
 160         request,
 161         'mediagoblin/blog/blog_post_edit_create.html',
 162         {'form': form,
 163         'app_config': mg_globals.app_config,
 164         'user': request.user.username})
 165
 166
 167 @require_active_login
 168 def blogpost_edit(request):
 169     blog_slug = request.matchdict.get('blog_slug', None)
 170     blog_post_slug = request.matchdict.get('blog_post_slug', None)
 171
 172     blogpost = request.db.MediaEntry.query.filter_by(slug=blog_post_slug, uploader=request.user.id).first()
 173     blog = request.db.Blog.query.filter_by(slug=blog_slug, author=request.user.id).first()
 174
 175     if not blogpost or not blog:
 176         return render_404(request)
 177
 178     defaults = dict(
 179                 title = blogpost.title,
 180                 description = cleaned_markdown_conversion(blogpost.description),
 181                 tags=media_tags_as_string(blogpost.tags),
 182                 license=blogpost.license)
 183
 184     form = blog_forms.BlogPostEditForm(request.form, **defaults)
 185     if request.method == 'POST' and form.validate():
 186         blogpost.title = unicode(form.title.data)
 187         blogpost.description = unicode(cleaned_markdown_conversion((form.description.data)))
 188         blogpost.tags =  convert_to_tag_list_of_dicts(form.tags.data)
 189         blogpost.license = unicode(form.license.data)
 190         set_blogpost_state(request, blogpost)
 191         blogpost.generate_slug()
 192         blogpost.save()
 193
 194         add_message(request, SUCCESS, _('Woohoo! edited blogpost is submitted'))
 195         return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 196                         user=request.user.username,
 197                         blog_slug=blog.slug)
 198
 199     return render_to_response(
 200         request,
 201         'mediagoblin/blog/blog_post_edit_create.html',
 202         {'form': form,
 203         'app_config': mg_globals.app_config,
 204         'user': request.user.username,
 205         'blog_post_slug': blog_post_slug
 206         })
 207
 208 @require_active_login
 209 def blog_dashboard(request):
 210
 211     url_user = request.matchdict.get('user')
 212     blog_posts_list = []
 213     blog_slug = request.matchdict.get('blog_slug')
 214     _log.info(blog_slug)
 215
 216     blog = request.db.Blog.query.filter_by(slug=blog_slug).first()
 217
 218     if not blog:
 219         return render_404(request)
 220
 221     blog_post_data = request.db.BlogPostData.query.filter_by(blog=blog.id).all()
 222
 223     for each_blog_post_data in blog_post_data:
 224         blog_post = each_blog_post_data.get_media_entry
 225         if blog_post:
 226             blog_posts_list.append(blog_post)
 227     blog_posts_list.reverse()
 228     blog_post_count = len(blog_posts_list)
 229
 230     if may_edit_blogpost(request, blog):
 231         return render_to_response(
 232         request,
 233         'mediagoblin/blog/blog_admin_dashboard.html',
 234         {'blog_posts_list': blog_posts_list,
 235         'blog_slug':blog_slug,
 236         'blog':blog,
 237         'blog_post_count':blog_post_count
 238         })
 239
 240 #supposed to list all the blog posts not just belonging to a particular post.
 241 def blog_post_listing(request):
 242
 243     blog_owner = request.matchdict.get('user')
 244     owner_user = User.query.filter_by(username=blog_owner).one()
 245
 246     if not owner_user:
 247         return render_404(request)
 248
 249     all_blog_posts = MediaEntry.query.filter_by(
 250         uploader=owner_user.id, media_type='mediagoblin.media_types.blogpost',
 251         state=u'processed').all()
 252     all_blog_posts.reverse()
 253     _log.info(len(all_blog_posts))
 254
 255     return render_to_response(
 256         request,
 257         'mediagoblin/blog/blog_post_listing.html',
 258         {'blog_posts': all_blog_posts,
 259          'blog_owner': blog_owner
 260         })
 261
 262
 263 def draft_view(request):
 264     blog_slug = request.matchdict.get('blog_slug')
 265     blog_post_slug = request.matchdict.get('blog_post_slug')
 266     user = request.matchdict.get('user')
 267
 268     blog = request.db.Blog.query.filter_by(author=request.user.id, slug=blog_slug).first()
 269     blogpost = request.db.MediaEntry.query.filter_by(state = u'failed', uploader=request.user.id, slug=blog_post_slug).first()
 270
 271     if not blog or not blogpost:
 272         return render_404(request)
 273
 274     return render_to_response(
 275         request,
 276         'mediagoblin/blog/blogpost_draft_view.html',
 277         {'blogpost':blogpost,
 278          'blog': blog
 279          })
 280
 281
 282
 283
 284