from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
try:
import simplejson as json
class AdyenController(http.Controller):
_return_url = '/payment/adyen/return/'
- @website.route([
+ @http.route([
'/payment/adyen/return/',
- ], type='http', auth='public')
+ ], type='http', auth='public', website=True)
def adyen_return(self, pspReference, **post):
""" Paypal IPN."""
post["pspReference"] = pspReference
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
_logger = logging.getLogger(__name__)
_exception_url = '/payment/ogone/test/exception'
_cancel_url = '/payment/ogone/test/cancel'
- @website.route([
+ @http.route([
'/payment/ogone/accept', '/payment/ogone/test/accept',
'/payment/ogone/decline', '/payment/ogone/test/decline',
'/payment/ogone/exception', '/payment/ogone/test/exception',
'/payment/ogone/cancel', '/payment/ogone/test/cancel',
- ], type='http', auth='admin')
+ ], type='http', auth='admin', website=True)
def ogone_form_feedback(self, **post):
""" Ogone contacts using GET, at least for accept """
_logger.info('Ogone: entering form_feedback with post data %s', pprint.pformat(post)) # debug
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
_logger = logging.getLogger(__name__)
_logger.warning('Paypal: unrecognized paypal answer, received %s instead of VERIFIED or INVALID' % resp.text)
return res
- @website.route([
+ @http.route([
'/payment/paypal/ipn/',
- ], type='http', auth='public', methods=['POST'])
+ ], type='http', auth='public', methods=['POST'], website=True)
def paypal_ipn(self, **post):
""" Paypal IPN. """
_logger.info('Beginning Paypal IPN form_feedback with post data %s', pprint.pformat(post)) # debug
self.paypal_validate_data(**post)
return ''
- @website.route([
+ @http.route([
'/payment/paypal/dpn',
- ], type='http', auth="public", methods=['POST'])
+ ], type='http', auth="public", methods=['POST'], website=True)
def paypal_dpn(self, **post):
""" Paypal DPN """
_logger.info('Beginning Paypal DPN form_feedback with post data %s', pprint.pformat(post)) # debug
self.paypal_validate_data(**post)
return request.redirect(return_url)
- @website.route([
+ @http.route([
'/payment/paypal/cancel',
- ], type='http', auth="public")
+ ], type='http', auth="public", website=True)
def paypal_cancel(self, **post):
""" When the user cancels its Paypal payment: GET on this route """
cr, uid, context = request.cr, request.uid, request.context
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
_logger = logging.getLogger(__name__)
class OgoneController(http.Controller):
_accept_url = '/payment/transfer/feedback'
- @website.route([
+ @http.route([
'/payment/transfer/feedback',
- ], type='http', auth='admin')
+ ], type='http', auth='admin', website=True)
def transfer_form_feedback(self, **post):
cr, uid, context = request.cr, request.uid, request.context
_logger.info('Beginning form_feedback with post data %s', pprint.pformat(post)) # debug
MAX_IMAGE_WIDTH, MAX_IMAGE_HEIGHT = IMAGE_LIMITS = (1024, 768)
class Website(openerp.addons.web.controllers.main.Home):
- @website.route('/', type='http', auth="public", multilang=True)
+ @http.route(['/', '/2'], type='http', auth="public", website=True, multilang=True)
def index(self, **kw):
try:
main_menu = request.registry['ir.model.data'].get_object(request.cr, request.uid, 'website', 'main_menu')
pass
return self.page("website.homepage")
- @website.route('/pagenew/<path:path>', type='http', auth="user")
+ @http.route('/pagenew/<path:path>', type='http', auth="user")
def pagenew(self, path, noredirect=NOPE):
web = request.registry['website']
try:
return werkzeug.wrappers.Response(url, mimetype='text/plain')
return werkzeug.utils.redirect(url)
- @website.route('/website/theme_change', type='http', auth="admin")
+ @http.route('/website/theme_change', type='http', auth="admin", website=True)
def theme_change(self, theme_id=False, **kwargs):
imd = request.registry['ir.model.data']
view = request.registry['ir.ui.view']
return request.website.render('website.themes', {'theme_changed': True})
- @website.route(['/website/snippets'], type='json', auth="public")
+ @http.route(['/website/snippets'], type='json', auth="public", website=True)
def snippets(self):
return request.website._render('website.snippets')
- @website.route('/page/<page:page>', type='http', auth="public", multilang=True)
+ @http.route('/page/<page:page>', type='http', auth="public", website=True, multilang=True)
def page(self, page, **opt):
values = {
'path': page,
return request.website.render(page, values)
- @website.route('/website/reset_templates', type='http', auth='user', methods=['POST'])
+ @http.route('/website/reset_templates', type='http', auth='user', methods=['POST'], website=True)
def reset_template(self, templates, redirect='/'):
templates = request.httprequest.form.getlist('templates')
modules_to_update = []
module_obj.button_immediate_upgrade(request.cr, request.uid, module_ids, context=request.context)
return request.redirect(redirect)
- @website.route('/website/customize_template_toggle', type='json', auth='user')
+ @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)
return True
- @website.route('/website/customize_template_get', type='json', auth='user')
+ @http.route('/website/customize_template_get', type='json', auth='user', website=True)
def customize_template_get(self, xml_id, optional=True):
imd = request.registry['ir.model.data']
view_model, view_theme_id = imd.get_object_reference(
})
return result
- @website.route('/website/get_view_translations', type='json', auth='admin')
+ @http.route('/website/get_view_translations', type='json', auth='admin', 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)
irt = request.registry.get('ir.translation')
return irt.search_read(request.cr, request.uid, domain, ['id', 'res_id', 'value'], context=request.context)
- @website.route('/website/set_translations', type='json', auth='admin')
+ @http.route('/website/set_translations', type='json', auth='admin', website=True)
def set_translations(self, data, lang):
irt = request.registry.get('ir.translation')
for view_id, trans in data.items():
irt.create(request.cr, request.uid, new_trans)
return True
- @website.route('/website/attach', type='http', auth='user')
+ @http.route('/website/attach', type='http', auth='user', website=True)
def attach(self, func, upload):
req = request.httprequest
if req.method != 'POST':
window.parent['%s'](%s, %s);
</script>""" % (func, json.dumps(url), json.dumps(message))
- @website.route(['/website/publish'], type='json', auth="public")
+ @http.route(['/website/publish'], type='json', auth="public", website=True)
def publish(self, id, object):
_id = int(id)
_object = request.registry[object]
obj = _object.browse(request.cr, request.uid, _id)
return bool(obj.website_published)
- @website.route(['/website/kanban/'], type='http', auth="public", methods=['POST'])
+ @http.route(['/website/kanban/'], type='http', auth="public", methods=['POST'], website=True)
def kanban(self, **post):
return request.website.kanban_col(**post)
- @website.route(['/robots.txt'], type='http', auth="public")
+ @http.route(['/robots.txt'], type='http', auth="public", website=True)
def robots(self):
response = request.website.render('website.robots', {'url_root': request.httprequest.url_root})
response.mimetype = 'text/plain'
return response
- @website.route('/sitemap', type='http', auth='public', multilang=True)
+ @http.route('/sitemap', type='http', auth='public', website=True, multilang=True)
def sitemap(self):
return request.website.render('website.sitemap', {
'pages': request.website.enumerate_pages()
})
- @website.route('/sitemap.xml', type='http', auth="public")
+ @http.route('/sitemap.xml', type='http', auth="public", website=True)
def sitemap_xml(self):
response = request.website.render('website.sitemap_xml', {
'pages': request.website.enumerate_pages()
response.set_data(f.read())
return response.make_conditional(request.httprequest)
- @website.route('/website/image', auth="public")
+ @http.route('/website/image', auth="public", website=True)
def image(self, model, id, field, max_width=maxint, max_height=maxint):
Model = request.registry[model]
return response
-
# vim:expandtab:tabstop=4:softtabstop=4:shiftwidth=4:
func = None
try:
func, arguments = self._find_handler()
- request.cms = getattr(func, 'cms', False)
+ request.website_enabled = func.routing.get('website', False)
except werkzeug.exceptions.NotFound:
# either we have a language prefixed route, either a real 404
# in all cases, website processes them
- request.cms = True
+ request.website_enabled = True
- if request.cms:
+ if request.website_enabled:
if func:
- self._authenticate(getattr(func, 'auth', None))
+ self._authenticate(func.routing['auth'])
else:
self._auth_method_public()
request.website = request.registry['website'].get_current_website(request.cr, request.uid, context=request.context)
def _handle_exception(self, exception=None, code=500):
if isinstance(exception, werkzeug.exceptions.HTTPException) and exception.response:
return exception.response
- if getattr(request, 'cms', False) and request.website:
+ if getattr(request, 'website_enabled', False) and request.website:
values = dict(
exception=exception,
traceback=traceback.format_exc(exception),
# -*- coding: utf-8 -*-
import fnmatch
-import functools
import inspect
import logging
import math
from openerp.osv import orm, osv, fields
from openerp.tools.safe_eval import safe_eval
-from openerp.addons.web import http
from openerp.addons.web.http import request, LazyResponse
from ..utils import slugify
logger = logging.getLogger(__name__)
-def route(routes, *route_args, **route_kwargs):
- def decorator(f):
- f.cms = True
- f.multilang = route_kwargs.pop('multilang', False)
- return http.route(routes, *route_args, **route_kwargs)(f)
- return decorator
-
def url_for(path_or_uri, lang=None, keep_query=None):
location = path_or_uri.strip()
url = urlparse.urlparse(location)
converters = rule._converters.values()
return (
- 'GET' in methods
- and endpoint.exposed == 'http'
- and endpoint.auth in ('none', 'public')
- and getattr(endpoint, 'cms', False)
+ 'GET' in methods
+ and endpoint.routing['type'] == 'http'
+ and endpoint.routing['auth'] in ('none', 'public')
+ and endpoint.routing.get('website', False)
# preclude combinatorial explosion by only allowing a single converter
and len(converters) <= 1
# ensure all converters on the rule are able to generate values for
group['date'] = "%s_%s" % (group['__domain'][0][2], group['__domain'][1][2])
return groups
- @website.route([
+ @http.route([
'/blog',
'/blog/page/<int:page>/',
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def blogs(self, page=1):
BYPAGE = 60
cr, uid, context = request.cr, request.uid, request.context
'pager': pager
})
- @website.route([
+ @http.route([
'/blog/<model("blog.category"):category>/',
'/blog/<model("blog.category"):category>/page/<int:page>/',
'/blog/<model("blog.category"):category>/tag/<model("blog.tag"):tag>/',
'/blog/<model("blog.category"):category>/date/<string(length=21):date>/page/<int:page>/',
'/blog/<model("blog.category"):category>/tag/<model("blog.tag"):tag>/date/<string(length=21):date>/',
'/blog/<model("blog.category"):category>/tag/<model("blog.tag"):tag>/date/<string(length=21):date>/page/<int:page>/',
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def blog(self, category=None, tag=None, date=None, page=1, **opt):
""" Prepare all values to display the blog.
}
return request.website.render("website_blog.blog_post_short", values)
- @website.route([
+ @http.route([
'/blogpost/<model("blog.post"):blog_post>/',
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def blog_post(self, blog_post, tag=None, date=None, page=1, enable_editor=None, **post):
""" Prepare all values to display the blog.
}
return request.website.render("website_blog.blog_post_complete", values)
- @website.route(['/blogpost/comment'], type='http', auth="public", methods=['POST'])
+ @http.route(['/blogpost/comment'], type='http', auth="public", methods=['POST'], website=True)
def blog_post_comment(self, blog_post_id=0, **post):
cr, uid, context = request.cr, request.uid, request.context
if post.get('comment'):
context=dict(context, mail_create_nosubcribe=True))
return werkzeug.utils.redirect(request.httprequest.referrer + "#comments")
- @website.route('/blogpost/new', type='http', auth="public", multilang=True)
+ @http.route('/blogpost/new', type='http', auth="public", website=True, multilang=True)
def blog_post_create(self, category_id, **post):
cr, uid, context = request.cr, request.uid, request.context
create_context = dict(context, mail_create_nosubscribe=True)
}, context=create_context)
return werkzeug.utils.redirect("/blogpost/%s/?enable_editor=1" % new_blog_post_id)
- @website.route('/blogpost/duplicate', type='http', auth="public")
+ @http.route('/blogpost/duplicate', type='http', auth="public", website=True)
def blog_post_copy(self, blog_post_id, **post):
""" Duplicate a blog.
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
from openerp import SUPERUSER_ID
from urllib import quote_plus
)
return url
- @website.route(['/crm/contactus'], type='http', auth="public", multilang=True)
+ @http.route(['/crm/contactus'], type='http', auth="public", website=True, multilang=True)
def contactus(self, *arg, **post):
required_fields = ['contact_name', 'email_from', 'description']
post['user_id'] = False
from openerp.addons.web.http import request
from openerp.addons.website.models import website
from openerp.addons.website_partner.controllers import main as website_partner
-import werkzeug
class WebsiteCrmPartnerAssign(http.Controller):
_references_per_page = 20
- @website.route([
+ @http.route([
'/partners/',
'/partners/page/<int:page>/',
'/partners/country/<int:country_id>',
'/partners/country/<country_name>-<int:country_id>',
'/partners/country/<int:country_id>/page/<int:page>/',
'/partners/country/<country_name>-<int:country_id>/page/<int:page>/',
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def partners(self, country_id=0, page=0, **post):
country_obj = request.registry['res.country']
partner_obj = request.registry['res.partner']
}
return request.website.render("website_crm_partner_assign.index", values)
- @website.route(['/partners/<int:partner_id>/', '/partners/<partner_name>-<int:partner_id>/'], type='http', auth="public", multilang=True)
+ @http.route(['/partners/<int:partner_id>/', '/partners/<partner_name>-<int:partner_id>/'], type='http', auth="public", website=True, multilang=True)
def partners_ref(self, partner_id, **post):
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
website.preload_records(partner)
class WebsiteCustomer(http.Controller):
_references_per_page = 20
- @website.route([
+ @http.route([
'/customers/',
'/customers/page/<int:page>/',
'/customers/country/<int:country_id>',
'/customers/country/<country_name>-<int:country_id>',
'/customers/country/<int:country_id>/page/<int:page>/',
'/customers/country/<country_name>-<int:country_id>/page/<int:page>/',
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def customers(self, country_id=0, page=0, **post):
cr, uid, context = request.cr, request.uid, request.context
partner_obj = request.registry['res.partner']
}
return request.website.render("website_customer.index", values)
- @website.route(['/customers/<int:partner_id>/', '/customers/<partner_name>-<int:partner_id>/'], type='http', auth="public", multilang=True)
+ @http.route(['/customers/<int:partner_id>/', '/customers/<partner_name>-<int:partner_id>/'], type='http', auth="public", website=True, multilang=True)
def customer(self, partner_id, **post):
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
website.preload_records(partner)
import urllib
class website_event(http.Controller):
- @website.route(['/event/', '/event/page/<int:page>'], type='http', auth="public", multilang=True)
+ @http.route(['/event/', '/event/page/<int:page>'], type='http', auth="public", website=True, multilang=True)
def events(self, page=1, **searches):
cr, uid, context = request.cr, request.uid, request.context
event_obj = request.registry['event.event']
return request.website.render("website_event.index", values)
- @website.route(['/event/<model("event.event"):event>/page/<page:page>'], type='http', auth="public", multilang=True)
+ @http.route(['/event/<model("event.event"):event>/page/<page:page>'], type='http', auth="public", website=True, multilang=True)
def event_page(self, event, page, **post):
website.preload_records(event, on_error="website_event.404")
values = {
}
return request.website.render(page, values)
- @website.route(['/event/<model("event.event"):event>'], type='http', auth="public", multilang=True)
+ @http.route(['/event/<model("event.event"):event>'], type='http', auth="public", website=True, multilang=True)
def event(self, event, **post):
website.preload_records(event, on_error="website_event.404")
if event.menu_id and event.menu_id.child_id:
target_url += '?enable_editor=1'
return request.redirect(target_url);
- @website.route(['/event/<model("event.event"):event>/register'], type='http', auth="public", multilang=True)
+ @http.route(['/event/<model("event.event"):event>/register'], type='http', auth="public", website=True, multilang=True)
def event_register(self, event, **post):
website.preload_records(event, on_error="website_event.404")
values = {
}
return request.website.render("website_event.event_description_full", values)
- @website.route(['/event/add_cart'], type='http', auth="public", multilang=True)
+ @http.route(['/event/add_cart'], type='http', auth="public", website=True, multilang=True)
def add_cart(self, event_id, **post):
user_obj = request.registry['res.users']
order_line_obj = request.registry.get('sale.order.line')
return request.redirect("/event/%s/" % event_id)
return request.redirect("/shop/checkout")
- @website.route(['/event/publish'], type='json', auth="public")
+ @http.route(['/event/publish'], type='json', auth="public", website=True)
def publish(self, id, object):
# if a user publish an event, he publish all linked res.partner
event = request.registry[object].browse(request.cr, request.uid, int(id))
return controllers.publish(id, object)
- @website.route('/event/add_event/', type='http', auth="user", multilang=True, methods=['POST'])
+ @http.route('/event/add_event/', type='http', auth="user", multilang=True, methods=['POST'], website=True)
def add_event(self, event_name="New Event", **kwargs):
Event = request.registry.get('event.event')
date_begin = datetime.today() + timedelta(days=(15)) # FIXME: better defaults
controllers = controllers()
class website_event(http.Controller):
- @website.route(['/event/<model("event.event"):event>/track/<model("event.track"):track>'], type='http', auth="public", multilang=True)
+ @http.route(['/event/<model("event.event"):event>/track/<model("event.track"):track>'], type='http', auth="public", website=True, multilang=True)
def event_track_view(self, event, track, **post):
# TODO: not implemented
website.preload_records(event, on_error="website_event.404")
values = { 'track': track, 'event': track.event_id, 'main_object': track }
return request.website.render("website_event_track.track_view", values)
- @website.route(['/event/<model("event.event"):event>/agenda/'], type='http', auth="public", multilang=True)
+ @http.route(['/event/<model("event.event"):event>/agenda/'], type='http', auth="public", website=True, multilang=True)
def event_agenda(self, event, tag=None, **post):
website.preload_records(event, on_error="website_event.404")
values = {
}
return request.website.render("website_event_track.agenda", values)
- @website.route([
+ @http.route([
'/event/<model("event.event"):event>/track/',
'/event/<model("event.event"):event>/track/tag/<model("event.track.tag"):tag>'
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def event_tracks(self, event, tag=None, **post):
website.preload_records(event, on_error="website_event.404")
website.preload_records(tag)
- @website.route(['/event/<model("event.event"):event>/track_proposal/'], type='http', auth="public", multilang=True)
+ @http.route(['/event/<model("event.event"):event>/track_proposal/'], type='http', auth="public", website=True, multilang=True)
def event_track_proposal(self, event, **post):
website.preload_records(event, on_error="website_event.404")
values = { 'event': event }
return request.website.render("website_event_track.event_track_proposal", values)
- @website.route(['/event/<model("event.event"):event>/track_proposal/post'], type='http', auth="public", methods=['POST'], multilang=True)
+ @http.route(['/event/<model("event.event"):event>/track_proposal/post'], type='http', auth="public", methods=['POST'], website=True, multilang=True)
def event_track_proposal_post(self, event, **post):
cr, uid, context = request.cr, request.uid, request.context
import openerp
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
from datetime import datetime
class google_map(http.Controller):
- @website.route(['/google_map/'], type='http', auth="admin")
+ @http.route(['/google_map/'], type='http', auth="admin", website=True)
def google_map(self, *arg, **post):
values = {
'partner_ids': post.get('partner_ids', ""),
}
return request.website.render("website_google_map.google_map", values)
- @website.route(['/google_map/partners.json'], type='http', auth="admin")
+ @http.route(['/google_map/partners.json'], type='http', auth="admin", website=True)
def google_map_data(self, *arg, **post):
partner_obj = request.registry['res.partner']
return partner_obj.google_map_json(request.cr, openerp.SUPERUSER_ID,
partner_ids, request.context)
- @website.route(['/google_map/set_partner_position/'], type='http', auth="admin")
+ @http.route(['/google_map/set_partner_position/'], type='http', auth="admin", website=True)
def google_map_set_partner_position(self, *arg, **post):
partner_obj = request.registry['res.partner']
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
class website_hr(http.Controller):
- @website.route(['/page/website.aboutus'], type='http', auth="public", multilang=True)
+ @http.route(['/page/website.aboutus'], type='http', auth="public", website=True, multilang=True)
def blog(self, **post):
hr_obj = request.registry['hr.employee']
employee_ids = hr_obj.search(request.cr, request.uid, [('website_published', '=', True)],
from openerp.addons.web import http
from openerp.tools.translate import _
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
from openerp.addons.website.controllers.main import Website as controllers
controllers = controllers()
class website_hr_recruitment(http.Controller):
- @website.route([
+ @http.route([
'/jobs',
'/jobs/department/<model("hr.department"):department>/office/<model("res.partner"):office>',
'/jobs/department/<model("hr.department"):department>',
'/jobs/office/<model("res.partner"):office>'
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def jobs(self, department=None, office=None):
JobsObj = request.registry['hr.job']
jobpost_ids = JobsObj.search(request.cr, request.uid, [],
'office': office and office.id or None
})
- @website.route(['/job/detail/<model("hr.job"):job>'], type='http', auth="public", multilang=True)
+ @http.route(['/job/detail/<model("hr.job"):job>'], type='http', auth="public", website=True, multilang=True)
def detail(self, job, **kwargs):
return request.website.render("website_hr_recruitment.detail", { 'job': job, 'main_object': job })
- @website.route(['/job/success'], methods=['POST'], type='http', auth="admin", multilang=True)
+ @http.route(['/job/success'], methods=['POST'], type='http', auth="admin", website=True, multilang=True)
def success(self, **post):
data = {
'name': _('Online Form'),
request.registry['ir.attachment'].create(request.cr, request.uid, attachment_values, context=request.context)
return request.website.render("website_hr_recruitment.thankyou", {})
- @website.route(['/job/apply'], type='http', auth="public", multilang=True)
+ @http.route(['/job/apply'], type='http', auth="public", website=True, multilang=True)
def applyjobpost(self, job):
[job_object] = request.registry['hr.job'].browse(
request.cr, request.uid, [int(job)], context=request.context)
'job': job_object
})
- @website.route('/job/add_job_offer/', type='http', auth="user", multilang=True, methods=['POST'])
+ @http.route('/job/add_job_offer/', type='http', auth="user", methods=['POST'], website=True, multilang=True)
def add_job_offer(self, **kwargs):
Job = request.registry.get('hr.job')
job_id = Job.create(request.cr, request.uid, {
# from openerp import SUPERUSER_ID
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
class WebsiteEmailDesigner(http.Controller):
- @website.route('/website_mail/email_designer/<model("email.template"):template>/', type='http', auth="public", multilang=True)
+ @http.route('/website_mail/email_designer/<model("email.template"):template>/', type='http', auth="public", website=True, multilang=True)
def index(self, template, **kw):
values = {
'template': template,
print template
return request.website.render("website_mail.designer_index", values)
- @website.route(['/website_mail/snippets'], type='json', auth="public")
+ @http.route(['/website_mail/snippets'], type='json', auth="public", website=True)
def snippets(self):
return request.website._render('website_mail.email_designer_snippets')
from openerp import SUPERUSER_ID
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
class WebsiteMail(http.Controller):
partner_ids = [user_obj.browse(request.cr, request.uid, request.uid, request.context).partner_id.id]
return partner_ids
- @website.route(['/website_mail/follow/'], type='json', auth="public")
+ @http.route(['/website_mail/follow/'], type='json', auth="public", website=True)
def website_message_subscribe(self, id=0, object=None, message_is_follower="on", email=False, **post):
_id = int(id)
_message_is_follower = message_is_follower == 'on'
class WebsiteMembership(http.Controller):
_references_per_page = 20
- @website.route([
+ @http.route([
'/members/',
'/members/page/<int:page>/',
'/members/association/<int:membership_id>/',
'/members/association/<int:membership_id>/country/<int:country_id>',
'/members/association/<int:membership_id>/country/<country_name>-<int:country_id>/page/<int:page>/',
'/members/association/<int:membership_id>/country/<int:country_id>/page/<int:page>/',
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def members(self, membership_id=None, country_name=None, country_id=0, page=0, **post):
cr, uid, context = request.cr, request.uid, request.context
product_obj = request.registry['product.product']
}
return request.website.render("website_membership.index", values)
- @website.route(['/members/<int:partner_id>/', '/members/<partner_name>-<int:partner_id>/'], type='http', auth="public", multilang=True)
+ @http.route(['/members/<int:partner_id>/', '/members/<partner_name>-<int:partner_id>/'], type='http', auth="public", website=True, multilang=True)
def partners_ref(self, partner_id, **post):
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
website.preload_records(partner)
return values
class WebsitePartner(http.Controller):
- @website.route(['/partners/<int:partner_id>/', '/partners/<partner_name>-<int:partner_id>/'], type='http', auth="public", multilang=True)
+ @http.route(['/partners/<int:partner_id>/', '/partners/<partner_name>-<int:partner_id>/'], type='http', auth="public", website=True, multilang=True)
def partner(self, partner_id, **post):
""" Route for displaying a single partner / customer. """
partner = request.registry['res.partner'].browse(request.cr, SUPERUSER_ID, partner_id, context=request.context)
from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
from openerp.osv import osv
class website_project(http.Controller):
- @website.route(['/project/<int:project_id>/'], type='http', auth="public", multilang=True)
+ @http.route(['/project/<int:project_id>/'], type='http', auth="public", website=True, multilang=True)
def project(self, project_id=None, **post):
cr, uid, context = request.cr, request.uid, request.context
project_obj = request.registry['project.project']
}
return request.website.render("website_project.index", render_values)
- @website.route(['/project/task/<int:task_id>'], type='http', auth="public", multilang=True)
+ @http.route(['/project/task/<int:task_id>'], type='http', auth="public", website=True, multilang=True)
def task(self, task_id=None, **post):
cr, uid, context = request.cr, request.uid, request.context
task_obj = request.registry['project.task']
return key_val
return False
- @website.route(['/shop/filters/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/filters/'], type='http', auth="public", website=True, multilang=True)
def filters(self, **post):
index = []
filters = []
att = obj.read(request.cr, request.uid, att_ids, ["product_tmpl_id"], context=request.context)
return [r["product_tmpl_id"][0] for r in att]
- @website.route(['/shop/pricelist'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/pricelist'], type='http', auth="public", website=True, multilang=True)
def shop_promo(self, code, **post):
assert code, 'No pricelist code provided'
request.registry['website']._ecommerce_change_pricelist(request.cr, request.uid, code=code, context=request.context)
return request.redirect("/shop")
- @website.route([
+ @http.route([
'/shop/',
'/shop/page/<int:page>/',
'/shop/category/<model("product.public.category"):category>/',
'/shop/category/<model("product.public.category"):category>/page/<int:page>/'
- ], type='http', auth="public", multilang=True)
+ ], type='http', auth="public", website=True, multilang=True)
def shop(self, category=None, page=0, filters='', search='', **post):
cr, uid, context = request.cr, request.uid, request.context
product_obj = request.registry.get('product.template')
}
return request.website.render("website_sale.products", values)
- @website.route(['/shop/product/<model("product.template"):product>/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/product/<model("product.template"):product>/'], type='http', auth="public", website=True, multilang=True)
def product(self, product, search='', category='', filters='', **kwargs):
website.preload_records(product, on_error="website_sale.404")
}
return request.website.render("website_sale.product", values)
- @website.route(['/shop/product/comment'], type='http', auth="public", methods=['POST'])
+ @http.route(['/shop/product/comment'], type='http', auth="public", methods=['POST'], website=True)
def product_comment(self, product_template_id, **post):
cr, uid, context = request.cr, request.uid, request.context
if post.get('comment'):
context=dict(context, mail_create_nosubcribe=True))
return werkzeug.utils.redirect(request.httprequest.referrer + "#comments")
- @website.route(['/shop/add_product/'], type='http', auth="user", multilang=True, methods=['POST'])
+ @http.route(['/shop/add_product/'], type='http', auth="user", methods=['POST'], website=True, multilang=True)
def add_product(self, name="New Product", category=0, **post):
Product = request.registry.get('product.product')
product_id = Product.create(request.cr, request.uid, {
return request.redirect("/shop/product/%s/?enable_editor=1" % product.product_tmpl_id.id)
- @website.route(['/shop/mycart/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/mycart/'], type='http', auth="public", website=True, multilang=True)
def mycart(self, **post):
cr, uid, context = request.cr, request.uid, request.context
prod_obj = request.registry.get('product.product')
}
return request.website.render("website_sale.mycart", values)
- @website.route(['/shop/add_cart/'], type='http', auth="public", multilang=True, methods=['POST'])
+ @http.route(['/shop/add_cart/'], type='http', auth="public", methods=['POST'], website=True, multilang=True)
def add_cart(self, product_id, remove=None, **kw):
request.registry['website']._ecommerce_add_product_to_cart(request.cr, request.uid,
product_id=int(product_id),
context=request.context)
return request.redirect("/shop/mycart/")
- @website.route(['/shop/change_cart/<int:order_line_id>/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/change_cart/<int:order_line_id>/'], type='http', auth="public", website=True, multilang=True)
def add_cart_order_line(self, order_line_id=None, remove=None, **kw):
request.registry['website']._ecommerce_add_product_to_cart(request.cr, request.uid,
order_line_id=order_line_id, number=(remove and -1 or 1),
context=request.context)
return request.redirect("/shop/mycart/")
- @website.route(['/shop/add_cart_json/'], type='json', auth="public")
+ @http.route(['/shop/add_cart_json/'], type='json', auth="public", website=True)
def add_cart_json(self, product_id=None, order_line_id=None, remove=None):
quantity = request.registry['website']._ecommerce_add_product_to_cart(request.cr, request.uid,
product_id=product_id, order_line_id=order_line_id, number=(remove and -1 or 1),
order.amount_total,
request.website._render("website_sale.total", {'website_sale_order': order})]
- @website.route(['/shop/set_cart_json/'], type='json', auth="public")
+ @http.route(['/shop/set_cart_json/'], type='json', auth="public", website=True)
def set_cart_json(self, path=None, product_id=None, order_line_id=None, set_number=0, json=None):
return request.registry['website']._ecommerce_add_product_to_cart(request.cr, request.uid,
product_id=product_id, order_line_id=order_line_id, set_number=set_number,
context=request.context)
- @website.route(['/shop/checkout/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/checkout/'], type='http', auth="public", website=True, multilang=True)
def checkout(self, **post):
cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
return request.website.render("website_sale.checkout", values)
- @website.route(['/shop/confirm_order/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/confirm_order/'], type='http', auth="public", website=True, multilang=True)
def confirm_order(self, **post):
cr, uid, context, registry = request.cr, request.uid, request.context, request.registry
order_line_obj = request.registry.get('sale.order')
return request.redirect("/shop/payment/")
- @website.route(['/shop/payment/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/payment/'], type='http', auth="public", website=True, multilang=True)
def payment(self, **post):
""" Payment step. This page proposes several payment means based on available
payment.acquirer. State at this point :
return request.website.render("website_sale.payment", values)
- @website.route(['/shop/payment/transaction/<int:acquirer_id>'],
- type='http', methods=['POST'], auth="public")
+ @http.route(['/shop/payment/transaction/<int:acquirer_id>'],
+ type='http', methods=['POST'], auth="public", website=True)
def payment_transaction(self, acquirer_id, **post):
""" Hook method that creates a payment.transaction and redirect to the
acquirer, using post values to re-create the post action.
acquirer_total_url = '%s?%s' % (acquirer_form_post_url, urllib.urlencode(post))
return request.redirect(acquirer_total_url)
- @website.route('/shop/payment/get_status/<int:sale_order_id>', type='json', auth="public", multilang=True)
+ @http.route('/shop/payment/get_status/<int:sale_order_id>', type='json', auth="public", website=True, multilang=True)
def payment_get_status(self, sale_order_id, **post):
cr, uid, context = request.cr, request.uid, request.context
'state': tx.state,
}
- @website.route('/shop/payment/validate/', type='http', auth="public", multilang=True)
+ @http.route('/shop/payment/validate/', type='http', auth="public", website=True, multilang=True)
def payment_validate(self, transaction_id=None, sale_order_id=None, **post):
""" Method that should be called by the server when receiving an update
for a transaction. State at this point :
return request.redirect('/shop/confirmation/%s' % order.id)
- @website.route(['/shop/confirmation/<int:sale_order_id>'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/confirmation/<int:sale_order_id>'], type='http', auth="public", website=True, multilang=True)
def payment_confirmation(self, sale_order_id, **post):
""" End of checkout process controller. Confirmation is basically seing
the status of a sale.order. State at this point :
return request.website.render("website_sale.confirmation", {'order': order})
- @website.route(['/shop/change_sequence/'], type='json', auth="public")
+ @http.route(['/shop/change_sequence/'], type='json', auth="public", website=True)
def change_sequence(self, id, sequence):
product_obj = request.registry.get('product.template')
if sequence == "top":
elif sequence == "down":
product_obj.set_sequence_down(request.cr, request.uid, [id], context=request.context)
- @website.route(['/shop/change_styles/'], type='json', auth="public")
+ @http.route(['/shop/change_styles/'], type='json', auth="public", website=True)
def change_styles(self, id, style_id):
product_obj = request.registry.get('product.template')
product = product_obj.browse(request.cr, request.uid, id, context=request.context)
return not active
- @website.route(['/shop/change_size/'], type='json', auth="public")
+ @http.route(['/shop/change_size/'], type='json', auth="public", website=True)
def change_size(self, id, x, y):
product_obj = request.registry.get('product.template')
product = product_obj.browse(request.cr, request.uid, id, context=request.context)
# -*- coding: utf-8 -*-
from openerp.addons.website_sale.controllers.main import Ecommerce
+from openerp.addons.web import http
from openerp.addons.web.http import request
-from openerp.addons.website.models import website
from openerp import SUPERUSER_ID
class Ecommerce(Ecommerce):
- @website.route(['/shop/payment/'], type='http', auth="public", multilang=True)
+ @http.route(['/shop/payment/'], type='http', auth="public", website=True, multilang=True)
def payment(self, **post):
cr, uid, context = request.cr, request.uid, request.context
order = self.get_order()
projects / odoo / odoo.git / commitdiff