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 from mediagoblin.tools import pluginapi
  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 (
  30         may_edit_blogpost, set_blogpost_state, get_all_blogposts_of_blog,
  31         get_blog_by_slug)
  32
  33 from mediagoblin.messages import add_message, SUCCESS, ERROR
  34 from mediagoblin.decorators import (require_active_login, active_user_from_url,
  35                             get_media_entry_by_id, user_may_alter_collection,
  36                             get_user_collection, uses_pagination)
  37 from mediagoblin.tools.pagination import Pagination
  38 from mediagoblin.tools.response import (render_to_response,
  39                                         redirect, render_404)
  40 from mediagoblin.tools.translate import pass_to_ugettext as _
  41 from mediagoblin.tools.template import render_template
  42 from mediagoblin.tools.text import (
  43     convert_to_tag_list_of_dicts, media_tags_as_string, clean_html,
  44     cleaned_markdown_conversion)
  45
  46 from mediagoblin.db.util import check_media_slug_used, check_collection_slug_used
  47 from mediagoblin.db.models import User, Collection, MediaEntry
  48
  49 from mediagoblin.notifications import add_comment_subscription
  50
  51
  52 @require_active_login
  53 def blog_edit(request):
  54     """
  55     View for editing an existing blog or creating a new blog
  56     if user have not exceeded maximum allowed acount of blogs.
  57     """
  58     url_user = request.matchdict.get('user', None)
  59     blog_slug = request.matchdict.get('blog_slug', None)
  60
  61     config = pluginapi.get_config('mediagoblin.media_types.blog')
  62     max_blog_count = config['max_blog_count']
  63     form = blog_forms.BlogEditForm(request.form)
  64     # creating a blog
  65     if not blog_slug:
  66         if Blog.query.filter_by(author=request.user.id).count()<max_blog_count:
  67             if request.method=='GET':
  68                 return render_to_response(
  69                     request,
  70                     'mediagoblin/blog/blog_edit_create.html',
  71                     {'form': form,
  72                     'user' : request.user,
  73                     'app_config': mg_globals.app_config})
  74
  75             if request.method=='POST' and form.validate():
  76                 _log.info("Here")
  77                 blog = request.db.Blog()
  78                 blog.title = unicode(form.title.data)
  79                 blog.description = unicode(cleaned_markdown_conversion((form.description.data)))
  80                 blog.author = request.user.id
  81                 blog.generate_slug()
  82
  83                 blog.save()
  84                 return redirect(request, "mediagoblin.media_types.blog.blog_admin_dashboard",
  85                         user=request.user.username
  86                        )
  87         else:
  88             add_message(request, ERROR, "Welcome! You already have created \
  89                                                         maximum number of blogs.")
  90             return redirect(request, "mediagoblin.media_types.blog.blog_admin_dashboard",
  91                         user=request.user.username)
  92
  93
  94     #Blog already exists.
  95     else:
  96         blog = get_blog_by_slug(request, blog_slug)
  97         if not blog:
  98             return render_404(request)
  99         if request.method == 'GET':
 100             defaults = dict(
 101                 title = blog.title,
 102                 description = cleaned_markdown_conversion(blog.description),
 103                 author = request.user.id)
 104
 105             form = blog_forms.BlogEditForm(**defaults)
 106
 107             return render_to_response(
 108                     request,
 109                     'mediagoblin/blog/blog_edit_create.html',
 110                     {'form': form,
 111                      'user': request.user,
 112                      'app_config': mg_globals.app_config})
 113         else:
 114             if request.method == 'POST' and form.validate():
 115                 blog.title = unicode(form.title.data)
 116                 blog.description = unicode(cleaned_markdown_conversion((form.description.data)))
 117                 blog.author = request.user.id
 118                 blog.generate_slug()
 119
 120                 blog.save()
 121                 add_message(request, SUCCESS, "Your blog is updated.")
 122                 return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 123                         user=request.user.username,
 124                         blog_slug=blog.slug)
 125
 126
 127 @require_active_login
 128 def blogpost_create(request):
 129
 130     form = blog_forms.BlogPostEditForm(request.form, license=request.user.license_preference)
 131
 132     if request.method == 'POST' and form.validate():
 133         blog_slug = request.matchdict.get('blog_slug')
 134         blog = get_blog_by_slug(request, blog_slug, author=request.user.id)
 135         if not blog:
 136             return render_404(request)
 137
 138         blogpost = request.db.MediaEntry()
 139         blogpost.media_type = 'mediagoblin.media_types.blogpost'
 140         blogpost.title = unicode(form.title.data)
 141         blogpost.description = unicode(cleaned_markdown_conversion((form.description.data)))
 142         blogpost.tags =  convert_to_tag_list_of_dicts(form.tags.data)
 143         blogpost.license = unicode(form.license.data) or None
 144         blogpost.uploader = request.user.id
 145         blogpost.generate_slug()
 146
 147         set_blogpost_state(request, blogpost)
 148         blogpost.save()
 149
 150         # connect this blogpost to its blog
 151         blog_post_data = request.db.BlogPostData()
 152         blog_post_data.blog = blog.id
 153         blog_post_data.media_entry = blogpost.id
 154         blog_post_data.save()
 155
 156         add_message(request, SUCCESS, _('Woohoo! Submitted!'))
 157         add_comment_subscription(request.user, blogpost)
 158         return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 159                         user=request.user.username,
 160                         blog_slug=blog.slug)
 161
 162     return render_to_response(
 163         request,
 164         'mediagoblin/blog/blog_post_edit_create.html',
 165         {'form': form,
 166         'app_config': mg_globals.app_config,
 167         'user': request.user.username})
 168
 169
 170 @require_active_login
 171 def blogpost_edit(request):
 172
 173     blog_slug = request.matchdict.get('blog_slug', None)
 174     blog_post_slug = request.matchdict.get('blog_post_slug', None)
 175
 176     blogpost = request.db.MediaEntry.query.filter_by(slug=blog_post_slug, uploader=request.user.id).first()
 177     blog = get_blog_by_slug(request, blog_slug, author=request.user.id)
 178
 179     if not blogpost or not blog:
 180         return render_404(request)
 181
 182     defaults = dict(
 183                 title = blogpost.title,
 184                 description = cleaned_markdown_conversion(blogpost.description),
 185                 tags=media_tags_as_string(blogpost.tags),
 186                 license=blogpost.license)
 187
 188     form = blog_forms.BlogPostEditForm(request.form, **defaults)
 189     if request.method == 'POST' and form.validate():
 190         blogpost.title = unicode(form.title.data)
 191         blogpost.description = unicode(cleaned_markdown_conversion((form.description.data)))
 192         blogpost.tags =  convert_to_tag_list_of_dicts(form.tags.data)
 193         blogpost.license = unicode(form.license.data)
 194         set_blogpost_state(request, blogpost)
 195         blogpost.generate_slug()
 196         blogpost.save()
 197
 198         add_message(request, SUCCESS, _('Woohoo! edited blogpost is submitted'))
 199         return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
 200                         user=request.user.username,
 201                         blog_slug=blog.slug)
 202
 203     return render_to_response(
 204         request,
 205         'mediagoblin/blog/blog_post_edit_create.html',
 206         {'form': form,
 207         'app_config': mg_globals.app_config,
 208         'user': request.user.username,
 209         'blog_post_slug': blog_post_slug
 210         })
 211
 212
 213 @active_user_from_url
 214 @uses_pagination
 215 def blog_dashboard(request, page, url_user=None):
 216     """
 217     Dashboard for a blog, only accessible to
 218     the owner of the blog.
 219     """
 220     blog_slug = request.matchdict.get('blog_slug', None)
 221     blogs = request.db.Blog.query.filter_by(author=url_user.id)
 222     config = pluginapi.get_config('mediagoblin.media_types.blog')
 223     max_blog_count = config['max_blog_count']
 224     if request.user and (request.user.id == url_user.id or request.user.has_privilege(u'admin')):
 225         if blog_slug:
 226             blog = get_blog_by_slug(request, blog_slug)
 227             if not blog:
 228                 return render_404(request)
 229             else:
 230                 blog_posts_list = blog.get_all_blog_posts().order_by(MediaEntry.created.desc())
 231                 pagination = Pagination(page, blog_posts_list)
 232                 pagination.per_page = 15
 233                 blog_posts_on_a_page = pagination()
 234                 if may_edit_blogpost(request, blog):
 235                     return render_to_response(
 236                         request,
 237                         'mediagoblin/blog/blog_admin_dashboard.html',
 238                         {'blog_posts_list': blog_posts_on_a_page,
 239                         'blog_slug':blog_slug,
 240                         'blog':blog,
 241                         'user':url_user,
 242                         'pagination':pagination
 243                         })
 244     if not request.user or request.user.id != url_user.id or not blog_slug:
 245         blogs = blogs.all()
 246         return render_to_response(
 247         request,
 248         'mediagoblin/blog/list_of_blogs.html',
 249         {
 250         'blogs':blogs,
 251         'user':url_user,
 252         'max_blog_count':max_blog_count
 253         })
 254
 255
 256 @active_user_from_url
 257 @uses_pagination
 258 def blog_post_listing(request, page, url_user=None):
 259     """
 260     Page, listing all the blog posts of a particular blog.
 261     """
 262     blog_slug = request.matchdict.get('blog_slug', None)
 263     blog = get_blog_by_slug(request, blog_slug, author=url_user.id)
 264     if not blog:
 265         return render_404(request)
 266
 267     all_blog_posts = blog.get_all_blog_posts(u'processed').order_by(MediaEntry.created.desc())
 268     pagination = Pagination(page, all_blog_posts)
 269     pagination.per_page = 8
 270     blog_posts_on_a_page = pagination()
 271
 272     return render_to_response(
 273         request,
 274         'mediagoblin/blog/blog_post_listing.html',
 275         {'blog_posts': blog_posts_on_a_page,
 276          'pagination': pagination,
 277          'blog_owner': url_user,
 278          'blog':blog
 279         })
 280
 281
 282 @require_active_login
 283 def draft_view(request):
 284     blog_slug = request.matchdict.get('blog_slug', None)
 285     blog_post_slug = request.matchdict.get('blog_post_slug', None)
 286     user = request.matchdict.get('user')
 287     blog = get_blog_by_slug(request, blog_slug, author=request.user.id)
 288     blogpost = request.db.MediaEntry.query.filter_by(state = u'failed', uploader=request.user.id, slug=blog_post_slug).first()
 289
 290     if not blog or not blogpost:
 291         return render_404(request)
 292
 293     return render_to_response(
 294         request,
 295         'mediagoblin/blog/blogpost_draft_view.html',
 296         {'blogpost':blogpost,
 297          'blog': blog
 298          })
 299
 300
 301 @require_active_login
 302 def blog_delete(request, **kwargs):
 303     """
 304     Deletes a blog and media entries, tags associated with it.
 305     """
 306     url_user = request.matchdict.get('user')
 307     owner_user = request.db.User.query.filter_by(username=url_user).first()
 308
 309     blog_slug = request.matchdict.get('blog_slug', None)
 310     blog = get_blog_by_slug(request, blog_slug, author=owner_user.id)
 311     if not blog:
 312         return render_404(reequest)
 313
 314     form = blog_forms.ConfirmDeleteForm(request.form)
 315     if request.user.id == blog.author or request.user.has_privilege(u'admin'):
 316         if request.method == 'POST' and form.validate():
 317             if form.confirm.data is True:
 318                 blog.delete()
 319                 add_message(
 320                 request, SUCCESS, _('You deleted the Blog.'))
 321                 return redirect(request, "mediagoblin.media_types.blog.blog_admin_dashboard",
 322                         user=request.user.username)
 323             else:
 324                 add_message(
 325                 request, ERROR,
 326                 _("The media was not deleted because you didn't check that you were sure."))
 327                 return redirect(request, "mediagoblin.media_types.blog.blog_admin_dashboard",
 328                         user=request.user.username)
 329         else:
 330             if request.user.has_privilege(u'admin'):
 331                 add_message(
 332                     request, WARNING,
 333                     _("You are about to delete another user's Blog. "
 334                       "Proceed with caution."))
 335             return render_to_response(
 336             request,
 337             'mediagoblin/blog/blog_confirm_delete.html',
 338             {'blog':blog,
 339             'form':form
 340             })
 341     else:
 342         add_message(
 343         request, ERROR,
 344         _("The blog was not deleted because you have no rights."))
 345         return redirect(request, "mediagoblin.media_types.blog.blog_admin_dashboard",
 346         user=request.user.username)
 347
 348
 349 def blog_about_view(request):
 350     """
 351     Page containing blog description and statistics
 352     """
 353     blog_slug = request.matchdict.get('blog_slug', None)
 354     url_user = request.matchdict.get('user', None)
 355
 356     user = request.db.User.query.filter_by(username=url_user).first()
 357     blog = get_blog_by_slug(request, blog_slug, author=user.id)
 358
 359     if not user or not blog:
 360         return render_404(request)
 361
 362     else:
 363         blog_posts_processed = blog.get_all_blog_posts(u'processed').count()
 364         return render_to_response(
 365                 request,
 366                 'mediagoblin/blog/blog_about.html',
 367                 {'user': user,
 368                 'blog': blog,
 369                 'blogpost_count': blog_posts_processed
 370                 })
 371
 372
 373
 374
 375
 376
 377
 378