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 _log = logging.getLogger(__name__)
  19
  20 from datetime import datetime
  21
  22 from werkzeug.exceptions import Forbidden
  23
  24 from mediagoblin import mg_globals
  25
  26 from mediagoblin.media_types.blog import forms as blog_forms
  27 from mediagoblin.media_types.blog.models import Blog, BlogPostData
  28 from mediagoblin.media_types.blog.lib import may_edit_blogpost, set_blogpost_state, get_all_blogposts_of_blog
  29
  30 from mediagoblin.messages import add_message, SUCCESS, ERROR
  31 from mediagoblin.decorators import (require_active_login, active_user_from_url,
  32                             get_media_entry_by_id, user_may_alter_collection,
  33                             get_user_collection, uses_pagination)
  34 from mediagoblin.tools.pagination import Pagination
  35 from mediagoblin.tools.response import (render_to_response,
  36                                         redirect, 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
  43 from mediagoblin.db.util import check_media_slug_used, check_collection_slug_used
  44 from mediagoblin.db.models import User, Collection, MediaEntry
  45
  46 from mediagoblin.notifications import add_comment_subscription
  47
  48
  49 @require_active_login
  50 def blog_edit(request):
  51     """
  52     View for editing the existing blog or automatically
  53     creating a new blog if user does not have any yet.
  54     """
  55     url_user = request.matchdict.get('user', None)
  56     blog_slug = request.matchdict.get('blog_slug', None)
  57
  58
  59     max_blog_count = 4
  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 = request.db.Blog()
  75                 blog.title = unicode(form.title.data)
  76                 blog.description = unicode(cleaned_markdown_conversion((form.description.data)))
  77                 blog.author = request.user.id
  78                 blog.generate_slug()
  79
  80                 blog.save()
  81                 return redirect(request, "mediagoblin.media_types.blog.blog_admin_dashboard",
  82                         user=request.user.username
  83                        )
  84         else:
  85             #the case when max blog count is one.
  86             add_message(request, ERROR, "Welcome! You already have created a blog.")
  87             return redirect(request, "mediagoblin.media_types.blog.blog_admin_dashboard",
  88                         user=request.user.username)
  89
  90
  91     #Blog already exists.
  92     else:
  93         blog = request.db.Blog.query.filter_by(slug=blog_slug).first()
  94         if request.method == 'GET':
  95             defaults = dict(
  96                 title = blog.title,
  97                 description = cleaned_markdown_conversion(blog.description),
  98                 author = request.user.id)
  99
 100             form = blog_forms.BlogEditForm(**defaults)
 101
 102             return render_to_response(
 103                     request,
 104                     'mediagoblin/blog/blog_edit_create.html',
 105                     {'form': form,
 106                      'user': request.user,
 107                      'app_config': mg_globals.app_config})
 108         else:
 109             if request.method == 'POST' and form.validate():
 110                 blog.title = unicode(form.title.data)
 111                 blog.description = unicode(cleaned_markdown_conversion((form.description.data)))
 112                 blog.author = request.user.id
 113                 blog.generate_slug()
 114
 115                 blog.save()
 116                 add_message(request, SUCCESS, "Your blog is updated.")
 117                 return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 118                         user=request.user.username,
 119                         blog_slug=blog.slug)
 120
 121
 122 @require_active_login
 123 def blogpost_create(request):
 124
 125     form = blog_forms.BlogPostEditForm(request.form, license=request.user.license_preference)
 126
 127     if request.method == 'POST' and form.validate():
 128         blog_slug = request.matchdict.get('blog_slug')
 129         blog = request.db.Blog.query.filter_by(slug=blog_slug,
 130             author=request.user.id).first()
 131         if not blog:
 132             return render_404(request)
 133
 134         blogpost = request.db.MediaEntry()
 135         blogpost.media_type = 'mediagoblin.media_types.blogpost'
 136         blogpost.title = unicode(form.title.data)
 137         blogpost.description = unicode(cleaned_markdown_conversion((form.description.data)))
 138         blogpost.tags =  convert_to_tag_list_of_dicts(form.tags.data)
 139         blogpost.license = unicode(form.license.data) or None
 140         blogpost.uploader = request.user.id
 141         blogpost.generate_slug()
 142
 143         set_blogpost_state(request, blogpost)
 144         blogpost.save()
 145
 146         # connect this blogpost to its blog
 147         blog_post_data = request.db.BlogPostData()
 148         blog_post_data.blog = blog.id
 149         blog_post_data.media_entry = blogpost.id
 150         blog_post_data.save()
 151
 152         add_message(request, SUCCESS, _('Woohoo! Submitted!'))
 153         add_comment_subscription(request.user, blogpost)
 154         return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 155                         user=request.user.username,
 156                         blog_slug=blog.slug)
 157
 158     return render_to_response(
 159         request,
 160         'mediagoblin/blog/blog_post_edit_create.html',
 161         {'form': form,
 162         'app_config': mg_globals.app_config,
 163         'user': request.user.username})
 164
 165
 166 @require_active_login
 167 def blogpost_edit(request):
 168     blog_slug = request.matchdict.get('blog_slug', None)
 169     blog_post_slug = request.matchdict.get('blog_post_slug', None)
 170
 171     blogpost = request.db.MediaEntry.query.filter_by(slug=blog_post_slug, uploader=request.user.id).first()
 172     blog = request.db.Blog.query.filter_by(slug=blog_slug, author=request.user.id).first()
 173
 174     if not blogpost or not blog:
 175         return render_404(request)
 176
 177     defaults = dict(
 178                 title = blogpost.title,
 179                 description = cleaned_markdown_conversion(blogpost.description),
 180                 tags=media_tags_as_string(blogpost.tags),
 181                 license=blogpost.license)
 182
 183     form = blog_forms.BlogPostEditForm(request.form, **defaults)
 184     if request.method == 'POST' and form.validate():
 185         blogpost.title = unicode(form.title.data)
 186         blogpost.description = unicode(cleaned_markdown_conversion((form.description.data)))
 187         blogpost.tags =  convert_to_tag_list_of_dicts(form.tags.data)
 188         blogpost.license = unicode(form.license.data)
 189         set_blogpost_state(request, blogpost)
 190         blogpost.generate_slug()
 191         blogpost.save()
 192
 193         add_message(request, SUCCESS, _('Woohoo! edited blogpost is submitted'))
 194         return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 195                         user=request.user.username,
 196                         blog_slug=blog.slug)
 197
 198     return render_to_response(
 199         request,
 200         'mediagoblin/blog/blog_post_edit_create.html',
 201         {'form': form,
 202         'app_config': mg_globals.app_config,
 203         'user': request.user.username,
 204         'blog_post_slug': blog_post_slug
 205         })
 206
 207
 208 @uses_pagination
 209 def blog_dashboard(request, page):
 210
 211         url_user = request.matchdict.get('user')
 212         user = request.db.User.query.filter_by(username=url_user).one()
 213         blog_slug = request.matchdict.get('blog_slug', None)
 214         max_blog_count = 4
 215         #_log.info(dir(mg_globals.app_config['max_blog_count']))
 216         blogs = request.db.Blog.query.filter_by(author=user.id)
 217         if (request.user and request.user.id == user.id) or (request.user and request.user.is_admin):
 218                 if blog_slug:
 219                         blog = blogs.filter(Blog.slug==blog_slug).first()
 220                         if not blog:
 221                                 return render_404(request)
 222                         else:
 223                                 blog_posts_list = blog.get_all_blog_posts().order_by(MediaEntry.created.desc())
 224                                 pagination = Pagination(page, blog_posts_list)
 225                                 pagination.per_page = 15
 226                                 blog_posts_on_a_page = pagination()
 227                                 if may_edit_blogpost(request, blog):
 228                                         return render_to_response(
 229                                                 request,
 230                                                 'mediagoblin/blog/blog_admin_dashboard.html',
 231                                                 {'blog_posts_list': blog_posts_on_a_page,
 232                                                 'blog_slug':blog_slug,
 233                                                 'blog':blog,
 234                                                 'user':user,
 235                                                 'pagination':pagination
 236                                                 })
 237         if not request.user or request.user.id != user.id or not blog_slug:
 238                 return render_to_response(
 239                 request,
 240                 'mediagoblin/blog/list_of_blogs.html',
 241                 {
 242                 'blogs':blogs,
 243                 'user':user
 244                 })
 245
 246
 247
 248 #supposed to list all the blog posts belonging to a particular blog of particular user.
 249 @uses_pagination
 250 def blog_post_listing(request, page):
 251
 252     blog_owner = request.matchdict.get('user')
 253     blog_slug = request.matchdict.get('blog_slug', None)
 254     owner_user = User.query.filter_by(username=blog_owner).one()
 255     blog = request.db.Blog.query.filter_by(slug=blog_slug).first()
 256
 257     if not owner_user or not blog:
 258         return render_404(request)
 259
 260     all_blog_posts = blog.get_all_blog_posts(u'processed').order_by(MediaEntry.created.desc())
 261     pagination = Pagination(page, all_blog_posts)
 262     pagination.per_page = 8
 263     blog_posts_on_a_page = pagination()
 264
 265     return render_to_response(
 266         request,
 267         'mediagoblin/blog/blog_post_listing.html',
 268         {'blog_posts': blog_posts_on_a_page,
 269          'pagination': pagination,
 270          'blog_owner': blog_owner
 271         })
 272
 273 @require_active_login
 274 def draft_view(request):
 275     blog_slug = request.matchdict.get('blog_slug', None)
 276     blog_post_slug = request.matchdict.get('blog_post_slug', None)
 277     user = request.matchdict.get('user')
 278
 279     blog = request.db.Blog.query.filter_by(author=request.user.id, slug=blog_slug).first()
 280     blogpost = request.db.MediaEntry.query.filter_by(state = u'failed', uploader=request.user.id, slug=blog_post_slug).first()
 281
 282     if not blog or not blogpost:
 283         return render_404(request)
 284
 285     return render_to_response(
 286         request,
 287         'mediagoblin/blog/blogpost_draft_view.html',
 288         {'blogpost':blogpost,
 289          'blog': blog
 290          })
 291