def web_login(self, *args, **kw): ensure_db() response = super().web_login(*args, **kw) response.qcontext.update(self.get_auth_signup_config()) if request.session.uid: if request.httprequest.method == 'GET' and request.params.get('redirect'): # Redirect if already logged in and redirect param is present return request.redirect(request.params.get('redirect')) # Add message for non-internal user account without redirect if account was just created if response.location == '/web/login_successful' and kw.get('confirm_password'): return request.redirect_query('/web/login_successful', query={'account_created': True}) return response
def _pre_dispatch(cls, rule, args): super()._pre_dispatch(rule, args) cls._geoip_setup_resolver() cls._geoip_resolve() if request.is_frontend: cls._frontend_pre_dispatch() # update the context of "<model(...):...>" args for key, val in list(args.items()): if isinstance(val, models.BaseModel): args[key] = val.with_context(request.context) if request.is_frontend_multilang: # A product with id 1 and named 'egg' is accessible via a # frontend multilang enpoint 'foo' at the URL '/foo/1'. # The preferred URL to access the product (and to generate # URLs pointing it) should instead be the sluggified URL # '/foo/egg-1'. This code is responsible of redirecting the # browser from '/foo/1' to '/foo/egg-1', or '/fr/foo/1' to # '/fr/foo/oeuf-1'. While it is nice (for humans) to have a # pretty URL, the real reason of this redirection is SEO. if request.httprequest.method in ('GET', 'HEAD'): try: _, path = rule.build(args) except odoo.exceptions.MissingError: raise werkzeug.exceptions.NotFound() assert path is not None generated_path = werkzeug.urls.url_unquote_plus(path) current_path = werkzeug.urls.url_unquote_plus(request.httprequest.path) if generated_path != current_path: if request.lang != cls._get_default_lang(): path = f'/{request.lang.url_code}{path}' redirect = request.redirect_query(path, request.httprequest.args, code=301) werkzeug.exceptions.abort(redirect)
def index(self, s_action=None, db=None, **kw): return request.redirect_query('/web', query=request.params)
def web_client(self, s_action=None, **kw): if request.session.uid and not is_user_internal(request.session.uid): return request.redirect_query('/my', query=request.params) return super().web_client(s_action, **kw)
def index(self, *args, **kw): if request.session.uid and not is_user_internal(request.session.uid): return request.redirect_query('/my', query=request.params) return super().index(*args, **kw)
def _match(cls, path): """ Grant multilang support to URL matching by using http 3xx redirections and URL rewrite. This method also grants various attributes such as ``lang`` and ``is_frontend`` on the current ``request`` object. 1/ Use the URL as-is when it matches a non-multilang compatible endpoint. 2/ Use the URL as-is when the lang is not present in the URL and that the default lang has been requested. 3/ Use the URL as-is saving the requested lang when the user is a bot and that the lang is missing from the URL. 4/ Redirect the browser when the lang is missing from the URL but another lang than the default one has been requested. The requested lang is injected before the original path. 5) Use the url as-is when the lang is missing from the URL, that another lang than the default one has been requested but that it is forbidden to redirect (e.g. POST) 6/ Redirect the browser when the lang is present in the URL but it is the default lang. The lang is removed from the original URL. 7/ Redirect the browser when the lang present in the URL is an alias of the preferred lang url code (e.g. fr_FR -> fr) 8/ Redirect the browser when the requested page is the homepage but that there is a trailing slash. 9/ Rewrite the URL when the lang is present in the URL, that it matches and that this lang is not the default one. The URL is rewritten to remove the lang. Note: The "requested lang" is (in order) either (1) the lang in the URL or (2) the lang in the ``frontend_lang`` request cookie or (3) the lang in the context or (4) the default lang of the website. """ # The URL has been rewritten already if hasattr(request, 'is_frontend'): return super()._match(path) # See /1, match a non website endpoint with contextlib.suppress(NotFound): rule, args = super()._match(path) routing = rule.endpoint.routing request.is_frontend = routing.get('website', False) request.is_frontend_multilang = request.is_frontend and routing.get('multilang', routing['type'] == 'http') if not request.is_frontend: return rule, args _, url_lang_str, *rest = path.split('/', 2) path_no_lang = '/' + (rest[0] if rest else '') allow_redirect = request.httprequest.method != 'POST' # There is no user on the environment yet but the following code # requires one to set the lang on the request. Temporary grant # the public user. Don't try it at home! real_env = request.env try: request.registry['ir.http']._auth_method_public() # it calls update_env nearest_url_lang = cls.get_nearest_lang(request.env['res.lang']._lang_get_code(url_lang_str)) cookie_lang = cls.get_nearest_lang(request.httprequest.cookies.get('frontend_lang')) context_lang = cls.get_nearest_lang(real_env.context.get('lang')) default_lang = cls._get_default_lang() request.lang = request.env['res.lang']._lang_get( nearest_url_lang or cookie_lang or context_lang or default_lang._get_cached('code') ) request_url_code = request.lang._get_cached('url_code') finally: request.env = real_env if not nearest_url_lang: url_lang_str = None # See /2, no lang in url and default website if not url_lang_str and request.lang == default_lang: _logger.debug("%r (lang: %r) no lang in url and default website, continue", path, request_url_code) # See /3, missing lang in url but user-agent is a bot elif not url_lang_str and request.env['ir.http'].is_a_bot(): _logger.debug("%r (lang: %r) missing lang in url but user-agent is a bot, continue", path, request_url_code) request.lang = default_lang # See /4, no lang in url and should not redirect (e.g. POST), continue elif not url_lang_str and not allow_redirect: _logger.debug("%r (lang: %r) no lang in url and should not redirect (e.g. POST), continue", path, request_url_code) # See /5, missing lang in url, /home -> /fr/home elif not url_lang_str: _logger.debug("%r (lang: %r) missing lang in url, redirect", path, request_url_code) redirect = request.redirect_query(f'/{request_url_code}{path}', request.httprequest.args) redirect.set_cookie('frontend_lang', request.lang._get_cached('code')) werkzeug.exceptions.abort(redirect) # See /6, default lang in url, /en/home -> /home elif url_lang_str == default_lang.url_code and allow_redirect: _logger.debug("%r (lang: %r) default lang in url, redirect", path, request_url_code) redirect = request.redirect_query(path_no_lang, request.httprequest.args) redirect.set_cookie('frontend_lang', default_lang._get_cached('code')) werkzeug.exceptions.abort(redirect) # See /7, lang alias in url, /fr_FR/home -> /fr/home elif url_lang_str != request_url_code and allow_redirect: _logger.debug("%r (lang: %r) lang alias in url, redirect", path, request_url_code) redirect = request.redirect_query(f'/{request_url_code}{path_no_lang}', request.httprequest.args, code=301) redirect.set_cookie('frontend_lang', request.lang._get_cached('code')) werkzeug.exceptions.abort(redirect) # See /8, homepage with trailing slash. /fr_BE/ -> /fr_BE elif path == f'/{url_lang_str}/' and allow_redirect: _logger.debug("%r (lang: %r) homepage with trailing slash, redirect", path, request_url_code) redirect = request.redirect_query(path[:-1], request.httprequest.args, code=301) redirect.set_cookie('frontend_lang', default_lang._get_cached('code')) werkzeug.exceptions.abort(redirect) # See /9, valid lang in url elif url_lang_str == request_url_code: # Rewrite the URL to remove the lang _logger.debug("%r (lang: %r) valid lang in url, rewrite url and continue", path, request_url_code) cls.reroute(path_no_lang) path = path_no_lang else: _logger.warning("%r (lang: %r) couldn't not correctly route this frontend request, url used as-is.", path, request_url_code) # Re-match using rewritten route and really raise for 404 errors try: rule, args = super()._match(path) routing = rule.endpoint.routing request.is_frontend = routing.get('website', False) request.is_frontend_multilang = request.is_frontend and routing.get('multilang', routing['type'] == 'http') return rule, args except NotFound: # Use website to render a nice 404 Not Found html page request.is_frontend = True request.is_frontend_multilang = True raise
def index(self, s_action=None, db=None, **kw): if request.session.uid and not is_user_internal(request.session.uid): return request.redirect_query('/web/login_successful', query=request.params) return request.redirect_query('/web', query=request.params)
def web_client(self, s_action=None, **kw): if request.session.uid and not request.env['res.users'].sudo().browse( request.session.uid).has_group('base.group_user'): return request.redirect_query('/my', query=request.params) return super().web_client(s_action, **kw)
def index(self, *args, **kw): if request.session.uid and not request.env['res.users'].sudo().browse( request.session.uid).has_group('base.group_user'): return request.redirect_query('/my', query=request.params) return super().index(*args, **kw)