addons/website/controllers/main.py

   1 # -*- coding: utf-8 -*-
   2 import cStringIO
   3 import datetime
   4 from itertools import islice
   5 import json
   6 import logging
   7 import re
   8
   9 from sys import maxint
  10
  11 import werkzeug.utils
  12 import werkzeug.wrappers
  13 from PIL import Image
  14
  15 import openerp
  16 from openerp.addons.web import http
  17 from openerp.http import request, Response
  18
  19 logger = logging.getLogger(__name__)
  20
  21 # Completely arbitrary limits
  22 MAX_IMAGE_WIDTH, MAX_IMAGE_HEIGHT = IMAGE_LIMITS = (1024, 768)
  23 LOC_PER_SITEMAP = 45000
  24 SITEMAP_CACHE_TIME = datetime.timedelta(hours=12)
  25
  26 class Website(openerp.addons.web.controllers.main.Home):
  27     #------------------------------------------------------
  28     # View
  29     #------------------------------------------------------
  30     @http.route('/', type='http', auth="public", website=True)
  31     def index(self, **kw):
  32         page = 'homepage'
  33         try:
  34             main_menu = request.registry['ir.model.data'].get_object(request.cr, request.uid, 'website', 'main_menu')
  35         except Exception:
  36             pass
  37         else:
  38             first_menu = main_menu.child_id and main_menu.child_id[0]
  39             if first_menu:
  40                 if not (first_menu.url.startswith(('/page/', '/?', '/#')) or (first_menu.url=='/')):
  41                     return request.redirect(first_menu.url)
  42                 if first_menu.url.startswith('/page/'):
  43                     return request.registry['ir.http'].reroute(first_menu.url)
  44         return self.page(page)
  45
  46     @http.route(website=True, auth="public")
  47     def web_login(self, *args, **kw):
  48         # TODO: can't we just put auth=public, ... in web client ?
  49         return super(Website, self).web_login(*args, **kw)
  50
  51     @http.route('/page/<path:page>', type='http', auth="public", website=True)
  52     def page(self, page, **opt):
  53         values = {
  54             'path': page,
  55         }
  56         # allow shortcut for /page/<website_xml_id>
  57         if '.' not in page:
  58             page = 'website.%s' % page
  59
  60         try:
  61             request.website.get_template(page)
  62         except ValueError, e:
  63             # page not found
  64             if request.website.is_publisher():
  65                 page = 'website.page_404'
  66             else:
  67                 return request.registry['ir.http']._handle_exception(e, 404)
  68
  69         return request.render(page, values)
  70
  71     @http.route(['/robots.txt'], type='http', auth="public")
  72     def robots(self):
  73         return request.render('website.robots', {'url_root': request.httprequest.url_root}, mimetype='text/plain')
  74
  75     @http.route('/sitemap.xml', type='http', auth="public", website=True)
  76     def sitemap_xml_index(self):
  77         cr, uid, context = request.cr, openerp.SUPERUSER_ID, request.context
  78         ira = request.registry['ir.attachment']
  79         iuv = request.registry['ir.ui.view']
  80         mimetype ='application/xml;charset=utf-8'
  81         content = None
  82
  83         def create_sitemap(url, content):
  84             ira.create(cr, uid, dict(
  85                 datas=content.encode('base64'),
  86                 mimetype=mimetype,
  87                 type='binary',
  88                 name=url,
  89                 url=url,
  90             ), context=context)
  91
  92         sitemap = ira.search_read(cr, uid, [('url', '=' , '/sitemap.xml'), ('type', '=', 'binary')], ('datas', 'create_date'), context=context)
  93         if sitemap:
  94             # Check if stored version is still valid
  95             server_format = openerp.tools.misc.DEFAULT_SERVER_DATETIME_FORMAT
  96             create_date = datetime.datetime.strptime(sitemap[0]['create_date'], server_format)
  97             delta = datetime.datetime.now() - create_date
  98             if delta < SITEMAP_CACHE_TIME:
  99                 content = sitemap[0]['datas'].decode('base64')
 100
 101         if not content:
 102             # Remove all sitemaps in ir.attachments as we're going to regenerated them
 103             sitemap_ids = ira.search(cr, uid, [('url', '=like' , '/sitemap%.xml'), ('type', '=', 'binary')], context=context)
 104             if sitemap_ids:
 105                 ira.unlink(cr, uid, sitemap_ids, context=context)
 106
 107             pages = 0
 108             first_page = None
 109             locs = request.website.enumerate_pages()
 110             while True:
 111                 start = pages * LOC_PER_SITEMAP
 112                 values = {
 113                     'locs': islice(locs, start, start + LOC_PER_SITEMAP),
 114                     'url_root': request.httprequest.url_root[:-1],
 115                 }
 116                 urls = iuv.render(cr, uid, 'website.sitemap_locs', values, context=context)
 117                 if urls.strip():
 118                     page = iuv.render(cr, uid, 'website.sitemap_xml', dict(content=urls), context=context)
 119                     if not first_page:
 120                         first_page = page
 121                     pages += 1
 122                     create_sitemap('/sitemap-%d.xml' % pages, page)
 123                 else:
 124                     break
 125             if not pages:
 126                 return request.not_found()
 127             elif pages == 1:
 128                 content = first_page
 129             else:
 130                 # Sitemaps must be split in several smaller files with a sitemap index
 131                 content = iuv.render(cr, uid, 'website.sitemap_index_xml', dict(
 132                     pages=range(1, pages + 1),
 133                     url_root=request.httprequest.url_root,
 134                 ), context=context)
 135             create_sitemap('/sitemap.xml', content)
 136
 137         return request.make_response(content, [('Content-Type', mimetype)])
 138
 139     #------------------------------------------------------
 140     # Edit
 141     #------------------------------------------------------
 142     @http.route('/website/add/<path:path>', type='http', auth="user", website=True)
 143     def pagenew(self, path, noredirect=False, add_menu=None):
 144         xml_id = request.registry['website'].new_page(request.cr, request.uid, path, context=request.context)
 145         if add_menu:
 146             model, id  = request.registry["ir.model.data"].get_object_reference(request.cr, request.uid, 'website', 'main_menu')
 147             request.registry['website.menu'].create(request.cr, request.uid, {
 148                     'name': path,
 149                     'url': "/page/" + xml_id,
 150                     'parent_id': id,
 151                 }, context=request.context)
 152         # Reverse action in order to allow shortcut for /page/<website_xml_id>
 153         url = "/page/" + re.sub(r"^website\.", '', xml_id)
 154
 155         if noredirect:
 156             return werkzeug.wrappers.Response(url, mimetype='text/plain')
 157         return werkzeug.utils.redirect(url)
 158
 159     @http.route('/website/theme_change', type='http', auth="user", website=True)
 160     def theme_change(self, theme_id=False, **kwargs):
 161         imd = request.registry['ir.model.data']
 162         Views = request.registry['ir.ui.view']
 163
 164         _, theme_template_id = imd.get_object_reference(
 165             request.cr, request.uid, 'website', 'theme')
 166         views = Views.search(request.cr, request.uid, [
 167             ('inherit_id', '=', theme_template_id),
 168             ('application', '=', 'enabled'),
 169         ], context=request.context)
 170         Views.write(request.cr, request.uid, views, {
 171             'application': 'disabled',
 172         }, context=request.context)
 173
 174         if theme_id:
 175             module, xml_id = theme_id.split('.')
 176             _, view_id = imd.get_object_reference(
 177                 request.cr, request.uid, module, xml_id)
 178             Views.write(request.cr, request.uid, [view_id], {
 179                 'application': 'enabled'
 180             }, context=request.context)
 181
 182         return request.render('website.themes', {'theme_changed': True})
 183
 184     @http.route(['/website/snippets'], type='json', auth="public", website=True)
 185     def snippets(self):
 186         return request.website._render('website.snippets')
 187
 188     @http.route('/website/reset_templates', type='http', auth='user', methods=['POST'], website=True)
 189     def reset_template(self, templates, redirect='/'):
 190         templates = request.httprequest.form.getlist('templates')
 191         modules_to_update = []
 192         for temp_id in templates:
 193             view = request.registry['ir.ui.view'].browse(request.cr, request.uid, int(temp_id), context=request.context)
 194             if view.page:
 195                 continue
 196             view.model_data_id.write({
 197                 'noupdate': False
 198             })
 199             if view.model_data_id.module not in modules_to_update:
 200                 modules_to_update.append(view.model_data_id.module)
 201
 202         if modules_to_update:
 203             module_obj = request.registry['ir.module.module']
 204             module_ids = module_obj.search(request.cr, request.uid, [('name', 'in', modules_to_update)], context=request.context)
 205             if module_ids:
 206                 module_obj.button_immediate_upgrade(request.cr, request.uid, module_ids, context=request.context)
 207         return request.redirect(redirect)
 208
 209     @http.route('/website/customize_template_get', type='json', auth='user', website=True)
 210     def customize_template_get(self, xml_id, full=False):
 211         """ Lists the templates customizing ``xml_id``. By default, only
 212         returns optional templates (which can be toggled on and off), if
 213         ``full=True`` returns all templates customizing ``xml_id``
 214         """
 215         imd = request.registry['ir.model.data']
 216         view_model, view_theme_id = imd.get_object_reference(
 217             request.cr, request.uid, 'website', 'theme')
 218
 219         user = request.registry['res.users']\
 220             .browse(request.cr, request.uid, request.uid, request.context)
 221         user_groups = set(user.groups_id)
 222
 223         views = request.registry["ir.ui.view"]\
 224             ._views_get(request.cr, request.uid, xml_id, context=request.context)
 225         done = set()
 226         result = []
 227         for v in views:
 228             if not user_groups.issuperset(v.groups_id):
 229                 continue
 230             if full or (v.application != 'always' and v.inherit_id.id != view_theme_id):
 231                 if v.inherit_id not in done:
 232                     result.append({
 233                         'name': v.inherit_id.name,
 234                         'id': v.id,
 235                         'xml_id': v.xml_id,
 236                         'inherit_id': v.inherit_id.id,
 237                         'header': True,
 238                         'active': False
 239                     })
 240                     done.add(v.inherit_id)
 241                 result.append({
 242                     'name': v.name,
 243                     'id': v.id,
 244                     'xml_id': v.xml_id,
 245                     'inherit_id': v.inherit_id.id,
 246                     'header': False,
 247                     'active': v.application in ('always', 'enabled'),
 248                 })
 249         return result
 250
 251     @http.route('/website/get_view_translations', type='json', auth='public', website=True)
 252     def get_view_translations(self, xml_id, lang=None):
 253         lang = lang or request.context.get('lang')
 254         views = self.customize_template_get(xml_id, full=True)
 255         views_ids = [view.get('id') for view in views if view.get('active')]
 256         domain = [('type', '=', 'view'), ('res_id', 'in', views_ids), ('lang', '=', lang)]
 257         irt = request.registry.get('ir.translation')
 258         return irt.search_read(request.cr, request.uid, domain, ['id', 'res_id', 'value','state','gengo_translation'], context=request.context)
 259
 260     @http.route('/website/set_translations', type='json', auth='public', website=True)
 261     def set_translations(self, data, lang):
 262         irt = request.registry.get('ir.translation')
 263         for view_id, trans in data.items():
 264             view_id = int(view_id)
 265             for t in trans:
 266                 initial_content = t['initial_content'].strip()
 267                 new_content = t['new_content'].strip()
 268                 tid = t['translation_id']
 269                 if not tid:
 270                     old_trans = irt.search_read(
 271                         request.cr, request.uid,
 272                         [
 273                             ('type', '=', 'view'),
 274                             ('res_id', '=', view_id),
 275                             ('lang', '=', lang),
 276                             ('src', '=', initial_content),
 277                         ])
 278                     if old_trans:
 279                         tid = old_trans[0]['id']
 280                 if tid:
 281                     vals = {'value': new_content}
 282                     irt.write(request.cr, request.uid, [tid], vals)
 283                 else:
 284                     new_trans = {
 285                         'name': 'website',
 286                         'res_id': view_id,
 287                         'lang': lang,
 288                         'type': 'view',
 289                         'source': initial_content,
 290                         'value': new_content,
 291                     }
 292                     if t.get('gengo_translation'):
 293                         new_trans['gengo_translation'] = t.get('gengo_translation')
 294                         new_trans['gengo_comment'] = t.get('gengo_comment')
 295                     irt.create(request.cr, request.uid, new_trans)
 296         return True
 297
 298     @http.route('/website/attach', type='http', auth='user', methods=['POST'], website=True)
 299     def attach(self, func, upload=None, url=None):
 300         Attachments = request.registry['ir.attachment']
 301
 302         website_url = message = None
 303         if not upload:
 304             website_url = url
 305             name = url.split("/").pop()
 306             attachment_id = Attachments.create(request.cr, request.uid, {
 307                 'name':name,
 308                 'type': 'url',
 309                 'url': url,
 310                 'res_model': 'ir.ui.view',
 311             }, request.context)
 312         else:
 313             try:
 314                 image_data = upload.read()
 315                 image = Image.open(cStringIO.StringIO(image_data))
 316                 w, h = image.size
 317                 if w*h > 42e6: # Nokia Lumia 1020 photo resolution
 318                     raise ValueError(
 319                         u"Image size excessive, uploaded images must be smaller "
 320                         u"than 42 million pixel")
 321
 322                 attachment_id = Attachments.create(request.cr, request.uid, {
 323                     'name': upload.filename,
 324                     'datas': image_data.encode('base64'),
 325                     'datas_fname': upload.filename,
 326                     'res_model': 'ir.ui.view',
 327                 }, request.context)
 328
 329                 [attachment] = Attachments.read(
 330                     request.cr, request.uid, [attachment_id], ['website_url'],
 331                     context=request.context)
 332                 website_url = attachment['website_url']
 333             except Exception, e:
 334                 logger.exception("Failed to upload image to attachment")
 335                 message = unicode(e)
 336
 337         return """<script type='text/javascript'>
 338             window.parent['%s'](%s, %s);
 339         </script>""" % (func, json.dumps(website_url), json.dumps(message))
 340
 341     @http.route(['/website/publish'], type='json', auth="public", website=True)
 342     def publish(self, id, object):
 343         _id = int(id)
 344         _object = request.registry[object]
 345         obj = _object.browse(request.cr, request.uid, _id)
 346
 347         values = {}
 348         if 'website_published' in _object._all_columns:
 349             values['website_published'] = not obj.website_published
 350         _object.write(request.cr, request.uid, [_id],
 351                       values, context=request.context)
 352
 353         obj = _object.browse(request.cr, request.uid, _id)
 354         return bool(obj.website_published)
 355
 356     #------------------------------------------------------
 357     # Helpers
 358     #------------------------------------------------------
 359     @http.route(['/website/kanban'], type='http', auth="public", methods=['POST'], website=True)
 360     def kanban(self, **post):
 361         return request.website.kanban_col(**post)
 362
 363     def placeholder(self, response):
 364         return request.registry['website']._image_placeholder(response)
 365
 366     @http.route([
 367         '/website/image',
 368         '/website/image/<model>/<id>/<field>'
 369         ], auth="public", website=True)
 370     def website_image(self, model, id, field, max_width=None, max_height=None):
 371         """ Fetches the requested field and ensures it does not go above
 372         (max_width, max_height), resizing it if necessary.
 373
 374         If the record is not found or does not have the requested field,
 375         returns a placeholder image via :meth:`~.placeholder`.
 376
 377         Sets and checks conditional response parameters:
 378         * :mailheader:`ETag` is always set (and checked)
 379         * :mailheader:`Last-Modified is set iif the record has a concurrency
 380           field (``__last_update``)
 381
 382         The requested field is assumed to be base64-encoded image data in
 383         all cases.
 384         """
 385         response = werkzeug.wrappers.Response()
 386         return request.registry['website']._image(
 387                     request.cr, request.uid, model, id, field, response, max_width, max_height)
 388
 389
 390     #------------------------------------------------------
 391     # Server actions
 392     #------------------------------------------------------
 393     @http.route('/website/action/<path_or_xml_id_or_id>', type='http', auth="public", website=True)
 394     def actions_server(self, path_or_xml_id_or_id, **post):
 395         cr, uid, context = request.cr, request.uid, request.context
 396         res, action_id, action = None, None, None
 397         ServerActions = request.registry['ir.actions.server']
 398
 399         # find the action_id: either an xml_id, the path, or an ID
 400         if isinstance(path_or_xml_id_or_id, basestring) and '.' in path_or_xml_id_or_id:
 401             action_id = request.registry['ir.model.data'].xmlid_to_res_id(request.cr, request.uid, path_or_xml_id_or_id, raise_if_not_found=False)
 402         if not action_id:
 403             action_ids = ServerActions.search(cr, uid, [('website_path', '=', path_or_xml_id_or_id), ('website_published', '=', True)], context=context)
 404             action_id = action_ids and action_ids[0] or None
 405         if not action_id:
 406             try:
 407                 action_id = int(path_or_xml_id_or_id)
 408             except ValueError:
 409                 pass
 410
 411         # check it effectively exists
 412         if action_id:
 413             action_ids = ServerActions.exists(cr, uid, [action_id], context=context)
 414             action_id = action_ids and action_ids[0] or None
 415         # run it, return only if we got a Response object
 416         if action_id:
 417             action = ServerActions.browse(cr, uid, action_id, context=context)
 418             if action.state == 'code' and action.website_published:
 419                 action_res = ServerActions.run(cr, uid, [action_id], context=context)
 420                 if isinstance(action_res, werkzeug.wrappers.Response):
 421                     res = action_res
 422         if res:
 423             return res
 424         return request.redirect('/')
 425