# -*- coding: utf-8 -*-
import cStringIO
-import contextlib
-import hashlib
+import datetime
+from itertools import islice
import json
+import xml.etree.ElementTree as ET
+
import logging
-import os
-import datetime
import re
-from sys import maxint
-
-import werkzeug
-import werkzeug.exceptions
import werkzeug.utils
+import urllib2
import werkzeug.wrappers
from PIL import Image
import openerp
-from openerp.osv import fields
-from openerp.addons.website.models import website
from openerp.addons.web import http
-from openerp.http import request, Response
+from openerp.http import request, STATIC_CACHE
+from openerp.tools import image_save_for_web
logger = logging.getLogger(__name__)
# Completely arbitrary limits
MAX_IMAGE_WIDTH, MAX_IMAGE_HEIGHT = IMAGE_LIMITS = (1024, 768)
LOC_PER_SITEMAP = 45000
+SITEMAP_CACHE_TIME = datetime.timedelta(hours=12)
class Website(openerp.addons.web.controllers.main.Home):
#------------------------------------------------------
# View
#------------------------------------------------------
- @http.route('/', type='http', auth="public", website=True, multilang=True)
+ @http.route('/', type='http', auth="public", website=True)
def index(self, **kw):
page = 'homepage'
try:
main_menu = request.registry['ir.model.data'].get_object(request.cr, request.uid, 'website', 'main_menu')
+ except Exception:
+ pass
+ else:
first_menu = main_menu.child_id and main_menu.child_id[0]
if first_menu:
if not (first_menu.url.startswith(('/page/', '/?', '/#')) or (first_menu.url=='/')):
return request.redirect(first_menu.url)
if first_menu.url.startswith('/page/'):
- page = first_menu[6:]
- except:
- pass
+ return request.registry['ir.http'].reroute(first_menu.url)
return self.page(page)
- @http.route(website=True, auth="public", multilang=True)
+ @http.route(website=True, auth="public")
def web_login(self, *args, **kw):
# TODO: can't we just put auth=public, ... in web client ?
return super(Website, self).web_login(*args, **kw)
- @http.route('/page/<page:page>', type='http', auth="public", website=True, multilang=True)
+ @http.route('/page/<page:page>', type='http', auth="public", website=True)
def page(self, page, **opt):
values = {
'path': page,
}
- # allow shortcut for /page/<website_xml_id>
- if '.' not in page:
+ # /page/website.XXX --> /page/XXX
+ if page.startswith('website.'):
+ return request.redirect('/page/' + page[8:], code=301)
+ elif '.' not in page:
page = 'website.%s' % page
try:
@http.route('/sitemap.xml', type='http', auth="public", website=True)
def sitemap_xml_index(self):
- pages = list(request.website.enumerate_pages())
- if len(pages)<=LOC_PER_SITEMAP:
- return self.__sitemap_xml(pages, 0)
- # Sitemaps must be split in several smaller files with a sitemap index
- values = {
- 'pages': range(len(pages)/LOC_PER_SITEMAP+1),
- 'url_root': request.httprequest.url_root
- }
- headers = {
- 'Content-Type': 'application/xml;charset=utf-8',
- }
- return request.render('website.sitemap_index_xml', values, headers=headers)
+ cr, uid, context = request.cr, openerp.SUPERUSER_ID, request.context
+ ira = request.registry['ir.attachment']
+ iuv = request.registry['ir.ui.view']
+ mimetype ='application/xml;charset=utf-8'
+ content = None
+
+ def create_sitemap(url, content):
+ ira.create(cr, uid, dict(
+ datas=content.encode('base64'),
+ mimetype=mimetype,
+ type='binary',
+ name=url,
+ url=url,
+ ), context=context)
+
+ sitemap = ira.search_read(cr, uid, [('url', '=' , '/sitemap.xml'), ('type', '=', 'binary')], ('datas', 'create_date'), context=context)
+ if sitemap:
+ # Check if stored version is still valid
+ server_format = openerp.tools.misc.DEFAULT_SERVER_DATETIME_FORMAT
+ create_date = datetime.datetime.strptime(sitemap[0]['create_date'], server_format)
+ delta = datetime.datetime.now() - create_date
+ if delta < SITEMAP_CACHE_TIME:
+ content = sitemap[0]['datas'].decode('base64')
+
+ if not content:
+ # Remove all sitemaps in ir.attachments as we're going to regenerated them
+ sitemap_ids = ira.search(cr, uid, [('url', '=like' , '/sitemap%.xml'), ('type', '=', 'binary')], context=context)
+ if sitemap_ids:
+ ira.unlink(cr, uid, sitemap_ids, context=context)
+
+ pages = 0
+ first_page = None
+ locs = request.website.enumerate_pages()
+ while True:
+ start = pages * LOC_PER_SITEMAP
+ values = {
+ 'locs': islice(locs, start, start + LOC_PER_SITEMAP),
+ 'url_root': request.httprequest.url_root[:-1],
+ }
+ urls = iuv.render(cr, uid, 'website.sitemap_locs', values, context=context)
+ if urls.strip():
+ page = iuv.render(cr, uid, 'website.sitemap_xml', dict(content=urls), context=context)
+ if not first_page:
+ first_page = page
+ pages += 1
+ create_sitemap('/sitemap-%d.xml' % pages, page)
+ else:
+ break
+ if not pages:
+ return request.not_found()
+ elif pages == 1:
+ content = first_page
+ else:
+ # Sitemaps must be split in several smaller files with a sitemap index
+ content = iuv.render(cr, uid, 'website.sitemap_index_xml', dict(
+ pages=range(1, pages + 1),
+ url_root=request.httprequest.url_root,
+ ), context=context)
+ create_sitemap('/sitemap.xml', content)
- @http.route('/sitemap-<int:page>.xml', type='http', auth="public", website=True)
- def sitemap_xml(self, page):
- pages = list(request.website.enumerate_pages())
- return self.__sitemap_xml(pages, page)
+ return request.make_response(content, [('Content-Type', mimetype)])
- def __sitemap_xml(self, pages, index=0):
+ @http.route('/website/info', type='http', auth="public", website=True)
+ def website_info(self):
+ try:
+ request.website.get_template('website.info').name
+ except Exception, e:
+ return request.registry['ir.http']._handle_exception(e, 404)
+ irm = request.env()['ir.module.module'].sudo()
+ apps = irm.search([('state','=','installed'),('application','=',True)])
+ modules = irm.search([('state','=','installed'),('application','=',False)])
values = {
- 'pages': pages[index*LOC_PER_SITEMAP:(index+1)*LOC_PER_SITEMAP],
- 'url_root': request.httprequest.url_root.rstrip('/')
+ 'apps': apps,
+ 'modules': modules,
+ 'version': openerp.service.common.exp_version()
}
- headers = {
- 'Content-Type': 'application/xml;charset=utf-8',
- }
- return request.render('website.sitemap_xml', values, headers=headers)
+ return request.render('website.info', values)
#------------------------------------------------------
# Edit
@http.route('/website/theme_change', type='http', auth="user", website=True)
def theme_change(self, theme_id=False, **kwargs):
imd = request.registry['ir.model.data']
- view = request.registry['ir.ui.view']
+ Views = request.registry['ir.ui.view']
- view_model, view_option_id = imd.get_object_reference(
+ _, theme_template_id = imd.get_object_reference(
request.cr, request.uid, 'website', 'theme')
- views = view.search(
- request.cr, request.uid, [('inherit_id', '=', view_option_id)],
- context=request.context)
- view.write(request.cr, request.uid, views, {'inherit_id': False},
- context=request.context)
+ views = Views.search(request.cr, request.uid, [
+ ('inherit_id', '=', theme_template_id),
+ ], context=request.context)
+ Views.write(request.cr, request.uid, views, {
+ 'active': False,
+ }, context=dict(request.context or {}, active_test=True))
if theme_id:
module, xml_id = theme_id.split('.')
- view_model, view_id = imd.get_object_reference(
+ _, view_id = imd.get_object_reference(
request.cr, request.uid, module, xml_id)
- view.write(request.cr, request.uid, [view_id],
- {'inherit_id': view_option_id}, context=request.context)
+ Views.write(request.cr, request.uid, [view_id], {
+ 'active': True
+ }, context=dict(request.context or {}, active_test=True))
return request.render('website.themes', {'theme_changed': True})
modules_to_update = []
for temp_id in templates:
view = request.registry['ir.ui.view'].browse(request.cr, request.uid, int(temp_id), context=request.context)
+ if view.page:
+ continue
view.model_data_id.write({
'noupdate': False
})
if view.model_data_id.module not in modules_to_update:
modules_to_update.append(view.model_data_id.module)
- module_obj = request.registry['ir.module.module']
- module_ids = module_obj.search(request.cr, request.uid, [('name', 'in', modules_to_update)], context=request.context)
- module_obj.button_immediate_upgrade(request.cr, request.uid, module_ids, context=request.context)
- return request.redirect(redirect)
- @http.route('/website/customize_template_toggle', type='json', auth='user', website=True)
- def customize_template_set(self, view_id):
- view_obj = request.registry.get("ir.ui.view")
- view = view_obj.browse(request.cr, request.uid, int(view_id),
- context=request.context)
- if view.inherit_id:
- value = False
- else:
- value = view.inherit_option_id and view.inherit_option_id.id or False
- view_obj.write(request.cr, request.uid, [view_id], {
- 'inherit_id': value
- }, context=request.context)
- return True
+ if modules_to_update:
+ module_obj = request.registry['ir.module.module']
+ module_ids = module_obj.search(request.cr, request.uid, [('name', 'in', modules_to_update)], context=request.context)
+ if module_ids:
+ module_obj.button_immediate_upgrade(request.cr, request.uid, module_ids, context=request.context)
+ return request.redirect(redirect)
@http.route('/website/customize_template_get', type='json', auth='user', website=True)
- def customize_template_get(self, xml_id, optional=True):
+ def customize_template_get(self, xml_id, full=False):
+ """ Lists the templates customizing ``xml_id``. By default, only
+ returns optional templates (which can be toggled on and off), if
+ ``full=True`` returns all templates customizing ``xml_id``
+ """
imd = request.registry['ir.model.data']
view_model, view_theme_id = imd.get_object_reference(
request.cr, request.uid, 'website', 'theme')
- user = request.registry['res.users'].browse(request.cr, request.uid, request.uid, request.context)
- group_ids = [g.id for g in user.groups_id]
+ user = request.registry['res.users']\
+ .browse(request.cr, request.uid, request.uid, request.context)
+ user_groups = set(user.groups_id)
- view = request.registry.get("ir.ui.view")
- views = view._views_get(request.cr, request.uid, xml_id, context=request.context)
- done = {}
+ views = request.registry["ir.ui.view"]\
+ ._views_get(request.cr, request.uid, xml_id, context=dict(request.context or {}, active_test=False))
+ done = set()
result = []
for v in views:
- if v.groups_id and [g for g in v.groups_id if g.id not in group_ids]:
+ if not user_groups.issuperset(v.groups_id):
continue
- if v.inherit_option_id and v.inherit_option_id.id != view_theme_id or not optional:
- if v.inherit_option_id.id not in done:
+ if full or (v.customize_show and v.inherit_id.id != view_theme_id):
+ if v.inherit_id not in done:
result.append({
- 'name': v.inherit_option_id.name,
+ 'name': v.inherit_id.name,
'id': v.id,
'xml_id': v.xml_id,
'inherit_id': v.inherit_id.id,
'header': True,
'active': False
})
- done[v.inherit_option_id.id] = True
+ done.add(v.inherit_id)
result.append({
'name': v.name,
'id': v.id,
'xml_id': v.xml_id,
'inherit_id': v.inherit_id.id,
'header': False,
- 'active': (v.inherit_id.id == v.inherit_option_id.id) or (not optional and v.inherit_id.id)
+ 'active': v.active,
})
return result
@http.route('/website/get_view_translations', type='json', auth='public', website=True)
def get_view_translations(self, xml_id, lang=None):
lang = lang or request.context.get('lang')
- views = self.customize_template_get(xml_id, optional=False)
+ views = self.customize_template_get(xml_id, full=True)
views_ids = [view.get('id') for view in views if view.get('active')]
domain = [('type', '=', 'view'), ('res_id', 'in', views_ids), ('lang', '=', lang)]
irt = request.registry.get('ir.translation')
return True
@http.route('/website/attach', type='http', auth='user', methods=['POST'], website=True)
- def attach(self, func, upload=None, url=None):
+ def attach(self, func, upload=None, url=None, disable_optimization=None):
Attachments = request.registry['ir.attachment']
website_url = message = None
u"Image size excessive, uploaded images must be smaller "
u"than 42 million pixel")
+ if not disable_optimization and image.format in ('PNG', 'JPEG'):
+ image_data = image_save_for_web(image)
+
attachment_id = Attachments.create(request.cr, request.uid, {
'name': upload.filename,
'datas': image_data.encode('base64'),
obj = _object.browse(request.cr, request.uid, _id)
return bool(obj.website_published)
+ @http.route(['/website/seo_suggest/<keywords>'], type='http', auth="public", website=True)
+ def seo_suggest(self, keywords):
+ url = "http://google.com/complete/search"
+ try:
+ req = urllib2.Request("%s?%s" % (url, werkzeug.url_encode({
+ 'ie': 'utf8', 'oe': 'utf8', 'output': 'toolbar', 'q': keywords})))
+ request = urllib2.urlopen(req)
+ except (urllib2.HTTPError, urllib2.URLError):
+ return []
+ xmlroot = ET.fromstring(request.read())
+ return json.dumps([sugg[0].attrib['data'] for sugg in xmlroot if len(sugg) and sugg[0].attrib['data']])
+
#------------------------------------------------------
# Helpers
#------------------------------------------------------
return request.website.kanban_col(**post)
def placeholder(self, response):
- # file_open may return a StringIO. StringIO can be closed but are
- # not context managers in Python 2 though that is fixed in 3
- with contextlib.closing(openerp.tools.misc.file_open(
- os.path.join('web', 'static', 'src', 'img', 'placeholder.png'),
- mode='rb')) as f:
- response.data = f.read()
- return response.make_conditional(request.httprequest)
+ return request.registry['website']._image_placeholder(response)
@http.route([
'/website/image',
- '/website/image/<model>/<id>/<field>'
+ '/website/image/<model>-<id>-<field>',
+ '/website/image/<model>-<id>-<field>-<int:max_width>x<int:max_height>'
], auth="public", website=True)
def website_image(self, model, id, field, max_width=None, max_height=None):
""" Fetches the requested field and ensures it does not go above
Sets and checks conditional response parameters:
* :mailheader:`ETag` is always set (and checked)
* :mailheader:`Last-Modified is set iif the record has a concurrency
- field (``write_date``)
+ field (``__last_update``)
The requested field is assumed to be base64-encoded image data in
all cases.
"""
- id = int(id)
- response = werkzeug.wrappers.Response()
- concurrency = 'write_date'
try:
- [record] = request.registry[model].read(request.cr, openerp.SUPERUSER_ID, [id],
- [concurrency, field],
- context=request.context)
- except:
- return self.placeholder(response)
-
- if concurrency in record:
- server_format = openerp.tools.misc.DEFAULT_SERVER_DATETIME_FORMAT
- try:
- response.last_modified = datetime.datetime.strptime(
- record[concurrency], server_format + '.%f')
- except ValueError:
- # just in case we have a timestamp without microseconds
- response.last_modified = datetime.datetime.strptime(
- record[concurrency], server_format)
-
- # Field does not exist on model or field set to False
- if not record.get(field):
- # FIXME: maybe a field which does not exist should be a 404?
+ idsha = id.split('_')
+ id = idsha[0]
+ response = werkzeug.wrappers.Response()
+ return request.registry['website']._image(
+ request.cr, request.uid, model, id, field, response, max_width, max_height,
+ cache=STATIC_CACHE if len(idsha) > 1 else None)
+ except Exception:
+ logger.exception("Cannot render image field %r of record %s[%s] at size(%s,%s)",
+ field, model, id, max_width, max_height)
+ response = werkzeug.wrappers.Response()
return self.placeholder(response)
- response.set_etag(hashlib.sha1(record[field]).hexdigest())
- response.make_conditional(request.httprequest)
-
- # conditional request match
- if response.status_code == 304:
- return response
-
- data = record[field].decode('base64')
- if (not max_width) and (not max_height):
- response.data = data
- return response
-
- image = Image.open(cStringIO.StringIO(data))
- response.mimetype = Image.MIME[image.format]
-
- w, h = image.size
- max_w, max_h = int(max_width), int(max_height)
- if w < max_w and h < max_h:
- response.data = data
- else:
- image.thumbnail((max_w, max_h), Image.ANTIALIAS)
- image.save(response.stream, image.format)
- del response.headers['Content-Length']
- return response
-
#------------------------------------------------------
# Server actions
#------------------------------------------------------
action = ServerActions.browse(cr, uid, action_id, context=context)
if action.state == 'code' and action.website_published:
action_res = ServerActions.run(cr, uid, [action_id], context=context)
- if isinstance(action_res, Response):
+ if isinstance(action_res, werkzeug.wrappers.Response):
res = action_res
if res:
return res