addons/website_blog/controllers/main.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2013-Today OpenERP SA (<http://www.openerp.com>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 from openerp.addons.web import http
  23 from openerp.addons.web.http import request
  24 from openerp.addons.website.models import website
  25 from openerp.tools.translate import _
  26
  27 import werkzeug
  28
  29
  30 class WebsiteBlog(http.Controller):
  31     _category_post_per_page = 6
  32     _post_comment_per_page = 6
  33
  34     def nav_list(self):
  35         blog_post_obj = request.registry['blog.post']
  36         groups = blog_post_obj.read_group(request.cr, request.uid, [], ['name', 'create_date'],
  37             groupby="create_date", orderby="create_date asc", context=request.context)
  38         for group in groups:
  39             group['date'] = "%s_%s" % (group['__domain'][0][2], group['__domain'][1][2])
  40         return groups
  41
  42     @website.route([
  43         '/blog',
  44         '/blog/page/<int:page>/',
  45     ], type='http', auth="public", multilang=True)
  46     def blogs(self, page=1):
  47         BYPAGE = 60
  48         cr, uid, context = request.cr, request.uid, request.context
  49         blog_obj = request.registry['blog.post']
  50         total = blog_obj.search(cr, uid, [], count=True, context=context)
  51         pager = request.website.pager(
  52             url='/blog/',
  53             total=total,
  54             page=page,
  55             step=BYPAGE,
  56         )
  57         bids = blog_obj.search(cr, uid, [], offset=(page-1)*BYPAGE, limit=BYPAGE, context=context)
  58         blogs = blog_obj.browse(cr, uid, bids, context=context)
  59         return request.website.render("website_blog.latest_blogs", {
  60             'blogs': blogs,
  61             'pager': pager
  62         })
  63
  64     @website.route([
  65         '/blog',
  66         '/blog/page/<int:page>/',
  67         '/blog/cat/<model("blog.category"):category>/',
  68         '/blog/cat/<model("blog.category"):category>/page/<int:page>/',
  69         '/blog/tag/<model("blog.tag"):tag>/',
  70         '/blog/tag/<model("blog.tag"):tag>/page/<int:page>/',
  71         '/blog/cat/<model("blog.category"):category>/date/<string(length=21):date>/',
  72         '/blog/tag/<model("blog.tag"):tag>/date/<string(length=21):date>/',
  73         '/blog/tag/<model("blog.tag"):tag>/date/<string(length=21):date>/page/<int:page>/',
  74     ], type='http', auth="public", multilang=True)
  75     def blog(self, category=None, tag=None, page=1, date=None):
  76         """ Prepare all values to display the blog.
  77
  78         :param category: category currently browsed.
  79         :param tag: tag that is currently used to filter blog posts
  80         :param integer page: current page of the pager. Can be the category or
  81                             post pager.
  82         :param date: date currently used to filter blog posts (dateBegin_dateEnd)
  83
  84         :return dict values: values for the templates, containing
  85
  86          - 'blog_posts': list of browse records that are the posts to display
  87                          in a given category, if not blog_post_id
  88          - 'category': browse of the current category, if category_id
  89          - 'categories': list of browse records of categories
  90          - 'pager': the pager to display posts pager in a category
  91          - 'tag': current tag, if tag_id
  92          - 'nav_list': a dict [year][month] for archives navigation
  93         """
  94         BYPAGE = 10
  95
  96         cr, uid, context = request.cr, request.uid, request.context
  97         blog_post_obj = request.registry['blog.post']
  98
  99         blog_posts = None
 100
 101         category_obj = request.registry['blog.category']
 102         category_ids = category_obj.search(cr, uid, [], context=context)
 103         categories = category_obj.browse(cr, uid, category_ids, context=context)
 104
 105         path_filter = ""
 106         domain = []
 107
 108         if category:
 109             path_filter += "cat/%s/" % category.id
 110             domain += [("id", "=", [blog.id for blog in category.blog_post_ids])]
 111         if tag:
 112             path_filter += 'tag/%s/' % tag.id
 113             domain += [("id", "=", [blog.id for blog in tag.blog_post_ids])]
 114         if date:
 115             path_filter += "date/%s/" % date
 116             date = date.split("_")
 117             domain = [("create_date", ">=", date[0]), ("create_date", "<=", date[1])]
 118
 119         blog_post_ids = blog_post_obj.search(cr, uid, domain, context=context)
 120         blog_posts = blog_post_obj.browse(cr, uid, blog_post_ids, context=context)
 121
 122         pager = request.website.pager(
 123             url="/blog/%s" % path_filter,
 124             total=len(blog_posts),
 125             page=page,
 126             step=self._category_post_per_page,
 127             scope=BYPAGE
 128         )
 129         pager_begin = (page - 1) * self._category_post_per_page
 130         pager_end = page * self._category_post_per_page
 131         blog_posts = blog_posts[pager_begin:pager_end]
 132
 133         values = {
 134             'category': category,
 135             'categories': categories,
 136             'tag': tag,
 137             'blog_posts': blog_posts,
 138             'pager': pager,
 139             'nav_list': self.nav_list(),
 140             'path_filter': path_filter,
 141         }
 142
 143         if tag:
 144             values['main_object'] = tag
 145         elif category:
 146             values['main_object'] = category
 147
 148         return request.website.render("website_blog.blog_post_short", values)
 149
 150     @website.route([
 151         '/blog/<model("blog.post"):blog_post>/page/<int:page>/',
 152         '/blog/<model("blog.post"):blog_post>/cat/<model("blog.category"):category>/',
 153         '/blog/<model("blog.post"):blog_post>/cat/<model("blog.category"):category>/page/<int:page>/',
 154         '/blog/<model("blog.post"):blog_post>/tag/<model("blog.tag"):tag>/',
 155         '/blog/<model("blog.post"):blog_post>/tag/<model("blog.tag"):tag>/page/<int:page>/',
 156         '/blog/<model("blog.post"):blog_post>/cat/<model("blog.category"):category>/date/<string(length=21):date>/',
 157         '/blog/<model("blog.post"):blog_post>/tag/<model("blog.tag"):tag>/date/<string(length=21):date>/',
 158         '/blog/<model("blog.post"):blog_post>/tag/<model("blog.tag"):tag>/date/<string(length=21):date>/page/<int:page>/',
 159     ], type='http', auth="public", multilang=True)
 160     def blog_post(self, blog_post=None, category=None, tag=None, page=1, date=None, enable_editor=None, path_filter=''):
 161         """ Prepare all values to display the blog.
 162
 163         :param blog_post: blog post currently browsed. If not set, the user is
 164                           browsing the category and a post pager is calculated.
 165                           If set the user is reading the blog post and a
 166                           comments pager is calculated.
 167         :param category: category currently browsed.
 168         :param tag: tag that is currently used to filter blog posts
 169         :param integer page: current page of the pager. Can be the category or
 170                             post pager.
 171         :param date: date currently used to filter blog posts (dateBegin_dateEnd)
 172
 173          - 'enable_editor': editor control
 174
 175         :return dict values: values for the templates, containing
 176
 177          - 'blog_post': browse of the current post, if blog_post_id
 178          - 'category': browse of the current category, if category_id
 179          - 'categories': list of browse records of categories
 180          - 'pager': the pager to display comments pager in a blog post
 181          - 'tag': current tag, if tag_id
 182          - 'nav_list': a dict [year][month] for archives navigation
 183         """
 184
 185         pager_url = "/blog/%s" % blog_post.id
 186
 187         if path_filter:
 188             pager_url += path_filter
 189
 190         pager = request.website.pager(
 191             url=pager_url,
 192             total=len(blog_post.website_message_ids),
 193             page=page,
 194             step=self._post_comment_per_page,
 195             scope=7
 196         )
 197         pager_begin = (page - 1) * self._post_comment_per_page
 198         pager_end = page * self._post_comment_per_page
 199         blog_post.website_message_ids = blog_post.website_message_ids[pager_begin:pager_end]
 200
 201         cr, uid, context = request.cr, request.uid, request.context
 202         category_obj = request.registry['blog.category']
 203         category_ids = category_obj.search(cr, uid, [], context=context)
 204         categories = category_obj.browse(cr, uid, category_ids, context=context)
 205
 206         values = {
 207             'category': category,
 208             'categories': categories,
 209             'tag': tag,
 210             'blog_post': blog_post,
 211             'pager': pager,
 212             'nav_list': self.nav_list(),
 213             'enable_editor': enable_editor,
 214             'path_filter': path_filter,
 215         }
 216         return request.website.render("website_blog.blog_post_complete", values)
 217
 218     @website.route(['/blog/<int:blog_post_id>/comment'], type='http', auth="public")
 219     def blog_post_comment(self, blog_post_id=None, **post):
 220         cr, uid, context = request.cr, request.uid, request.context
 221         if post.get('comment'):
 222             request.registry['blog.post'].message_post(
 223                 cr, uid, blog_post_id,
 224                 body=post.get('comment'),
 225                 type='comment',
 226                 subtype='mt_comment',
 227                 context=dict(context, mail_create_nosubcribe=True))
 228         return werkzeug.utils.redirect(request.httprequest.referrer + "#comments")
 229
 230     @website.route(['/blog/<int:category_id><path:path_filter>/new'], type='http', auth="public", multilang=True)
 231     def blog_post_create(self, category_id=None, path_filter='', **post):
 232         cr, uid, context = request.cr, request.uid, request.context
 233         create_context = dict(context, mail_create_nosubscribe=True)
 234         new_blog_post_id = request.registry['blog.post'].create(
 235             request.cr, request.uid, {
 236                 'category_id': category_id,
 237                 'name': _("Blog title"),
 238                 'content': '',
 239                 'website_published': False,
 240             }, context=create_context)
 241         return werkzeug.utils.redirect("/blog/%s%s/?enable_editor=1" % (new_blog_post_id, path_filter))
 242
 243     @website.route(['/blog/<int:blog_post_id><path:path_filter>/duplicate'], type='http', auth="public")
 244     def blog_post_copy(self, blog_post_id=None, path_filter='', **post):
 245         cr, uid, context = request.cr, request.uid, request.context
 246         create_context = dict(context, mail_create_nosubscribe=True)
 247         new_blog_post_id = request.registry['blog.post'].copy(cr, uid, blog_post_id, {}, context=create_context)
 248         return werkzeug.utils.redirect("/blog/%s%s/?enable_editor=1" % (new_blog_post_id, path_filter))