async def redirect_301(request): # $ requestHandler if not "kwarg" in request.url.query: raise web.HTTPMovedPermanently( "/login" ) # $ HttpResponse HttpRedirectResponse mimetype=application/octet-stream redirectLocation="/login" else: raise web.HTTPMovedPermanently( location="/logout" ) # $ HttpResponse HttpRedirectResponse mimetype=application/octet-stream redirectLocation="/logout"
def redirect(request, router_name: str, *, permanent=False, url: str = None, reason="HttpFound", **kwargs): """ Redirect to given URL name :param request: current request for web app :param router_name: router name for creating redirect url (used if url not specified) :param permanent: use permanent redirect :param url: directly set url for redirecting :param reason: Http reason for redirect moving ('HttpFound' by default) :param kwargs: url-kwargs for forming redirecting url :raises `aiohttp.web.HTTPMovedPermanently` `aiohttp.web.HTTPFound` """ if not url: for key in kwargs.keys(): kwargs[key] = str(kwargs[key]) url = request.app.router[router_name].url_for(**kwargs) if permanent: raise web.HTTPMovedPermanently(url, reason=reason) raise web.HTTPFound(url, reason=reason)
async def middleware_handler(request, handler): try: resp = await handler(request) override = overrides.get(resp.status) return await override(request) if override else resp except web.HTTPNotFound: index_resource = request.app.router['Index:get'] if request.path + '/' == index_resource.canonical: logger.debug('Redirecting to index', path=request.path) raise web.HTTPMovedPermanently(index_resource.url_for()) return await not_found_error(request) except CompletedCaseError: return await completed_case(request) except InactiveIACError: return await inactive_iac(request) except ExerciseClosedError as ex: return await ce_closed(request, ex.collection_exercise_id) except InvalidEqPayLoad as ex: return await eq_error(request, ex.message) except ClientConnectionError as ex: return await connection_error(request, ex.args[0]) except ClientConnectorError as ex: return await connection_error(request, ex.os_error.strerror) except ContentTypeError as ex: return await payload_error(request, str(ex.request_info.url)) except ClientResponseError: return await response_error(request)
def redirect(request, router_name, *, permanent=False, **kwargs): """ Redirect to given URL name """ parts = kwargs.get('parts', {}) url = request.app.router[router_name].url_for(**parts) if permanent: raise web.HTTPMovedPermanently(url) raise web.HTTPFound(url)
async def _request_handler(self, request): if request.query_string: raise web.HTTPBadRequest self._windows_check(request.path) path = self._re_pattern.sub('/', request.path) if path != request.path: raise web.HTTPMovedPermanently(path) self._log(request.remote, '->', request.host, request.method, request.path, request.headers.get('Range', '')) rname, root, ro, to_handle = self._web_path(path, request.method) if root is None: return self._get_mainpage() path = self._local_path_check(root / to_handle, root, True) post_result = '' if request.method == 'POST': try: post_result = await self._post_handler(request, path, root) except web.HTTPException: # web.HTTPError would also work raise except Exception: raise web.HTTPBadRequest if path.is_dir(): return self._get_dir(request, rname, path, ro, root, post_result) elif path.is_file(): return self._get_file(request, path) else: raise web.HTTPInternalServerError
async def middleware_handler(request, handler): try: resp = await handler(request) override = overrides.get(resp.status) return await override(request) if override else resp except web.HTTPNotFound: path_prefix = request.app['URL_PATH_PREFIX'] def path_starts_with(suffix): return request.path.startswith(path_prefix + suffix) index_resource = request.app.router['Start:get'] if path_starts_with('/ni'): display_region = 'ni' elif path_starts_with('/cy'): display_region = 'cy' else: display_region = 'en' if request.path + '/' == index_resource.canonical.replace( '{display_region}', display_region): logger.debug('redirecting to index', client_ip=request['client_ip'], client_id=request['client_id'], trace=request['trace'], path=request.path) raise web.HTTPMovedPermanently( index_resource.url_for(display_region=display_region)) return await not_found_error(request) except web.HTTPForbidden: return await forbidden(request) except InvalidAccessCode: return await invalid_access_code(request) except SessionTimeout as ex: return await session_timeout(request, ex.user_journey, ex.sub_user_journey) except TooManyRequests as ex: return await too_many_requests(request, ex.sub_user_journey) except TooManyRequestsWebForm: return await too_many_requests_web_form(request) except TooManyRequestsEQLaunch: return await too_many_requests_eq_launch(request) except InactiveCaseError as ex: return await inactive_case(request, ex.case_type) except ExerciseClosedError as ex: return await ce_closed(request, ex.collection_exercise_id) except InvalidEqPayLoad as ex: return await eq_error(request, ex.message) except ClientConnectionError as ex: return await connection_error(request, ex.args[0]) except ClientConnectorError as ex: return await connection_error(request, ex.os_error.strerror) except ContentTypeError as ex: return await payload_error(request, str(ex.request_info.url)) except KeyError as error: return await key_error(request, error) except ClientResponseError as ex: return await response_error(request, ex)
def remove_trailing_slashes_middleware(self, request, handler): path = request.url.path if path.endswith("/") and len(path) > 1: while path.endswith("/"): path = path[:-1] if len(path) == 0: path = "/" return web.HTTPMovedPermanently(path) res = yield from handler(request) return res
async def get(self): """Reply to HTTP GET request.""" # if the train number is specified through # a GET parameter, redirect to the perma link self.train_number = self.request.GET.get('train', None) if self.train_number: return web.HTTPMovedPermanently( '/%s/train/%s' % (self.request.language, self.train_number)) self.train_number = self.request.match_info.get('train') return await super(TrainView, self).get()
def _get_dir(self, request, rname, path, ro, root, post_result): if not request.path.endswith('/'): raise web.HTTPMovedPermanently(request.path + '/') if post_result: post_result = self._html8.format(post_result) resp = [ self._html0, self._html1.format( html.escape( pathlib.Path(rname, path.relative_to(root)).as_posix()), post_result), self._html2.format('<b>Name</b>', '<b>Size</b>') ] body = [[], [], {}] # python 3.6 dict: keys are kept in insertion order try: resp.append( self._html2.format(self._html7.format('../', '../'), 'DIR')) for item in path.iterdir(): if item.is_symlink(): body[0].append(item.name) elif item.is_dir(): body[1].append(item.name) elif item.is_file(): body[2][item.name] = item.stat().st_size else: raise web.HTTPInternalServerError except PermissionError: raise web.HTTPForbidden resp.extend( self._html2.format( self._html7.format(parse.quote(item_name), html.escape(item_name + '@')), 'LNK') for item_name in sorted(body[0])) resp.extend( self._html2.format( self._html7.format(parse.quote(item_name + '/'), html.escape(item_name + '/')), 'DIR') for item_name in sorted(body[1])) resp.extend( self._html2.format( self._html7.format(parse.quote(item_name), html.escape(item_name)), size) for item_name, size in sorted(body[2].items())) resp.append(self._html3) if not ro: resp.append(self._html4) # resp.append(self._html7.format('/', 'Home Page')) resp.append(self._html5) return web.Response(text='\n'.join(resp), content_type='text/html')
def normalize_path(raw_path: str): segments = raw_path.split('/') resolved = [] for segment in segments: if segment == "..": if resolved: resolved.pop() elif segment != ".": resolved.append(segment) # Remove any null segments or trailing slashes, even though they're technically different paths resolved = [r for r in resolved if len(r)] norm_path = "/" + "/".join(resolved) if norm_path != raw_path: raise web.HTTPMovedPermanently(location=norm_path) return resolved
async def documentation(request): project_name = request.match_info["project_name"] path = request.match_info.get("path", "") if project_name in request.app["redirects"]: location = request.app["redirects"][project_name]["base_uri"] if request.app["redirects"][project_name]["include_path"]: location = f"{location}/{path}" return web.Response( status=302, headers={ "Location": location, } ) path = f"{project_name}/{path}" if path.endswith("/"): path += "index.html" bucket = request.app["settings"]["docs_bucket"] session = request.app["boto.session"] async with session.create_client('s3', config=ANON_CONFIG) as s3: try: key = await fetch_key(s3, request, bucket, path) except botocore.exceptions.ClientError: try: key = await fetch_key(s3, request, bucket, path + "/index.html") except botocore.exceptions.ClientError: return web.Response(status=404) else: return web.HTTPMovedPermanently(location="/" + path + "/") content_type, content_encoding = mimetypes.guess_type(path) response = web.StreamResponse(status=200, reason='OK') response.content_type = content_type response.content_encoding = content_encoding body = key['Body'] await response.prepare(request) while True: data = await body.read(4096) await response.write(data) await response.drain() if not data: body.close() break return response
async def get(self): """ Return redirect to a URL specified by a key. """ key: str = self.request.match_info.get("key") if key is None: return web.json_response( { "ok": False, "errors": "A link with a given key was not found." }, status=HTTPStatus.NOT_FOUND.value, ) link = await get_link(self.client, key) raise web.HTTPMovedPermanently(link)
async def normalize_postcode_middleware(request, handler): """ If there is a postcode in the url it validates and normalizes it. """ postcode: Optional[str] = request.match_info.get('postcode', None) if postcode is None or postcode == "random": return await handler(request) elif not is_uk_postcode(postcode): raise web.HTTPNotFound(text="Invalid Postcode") postcode_processed = postcode.upper().replace(" ", "") if postcode_processed == postcode: return await handler(request) else: url_name = request.match_info.route.name url = request.app.router[url_name] params = dict(request.match_info) params['postcode'] = postcode_processed raise web.HTTPMovedPermanently(str(url.url_for(**params)))
def get(obj): if not DIMENSIONS: return icon_path = _get_best_fit(obj.extension, obj.width, obj.height) if icon_path is None: return if ICON_REDIRECT: # Redirect browser to icon. url = '%s/%s' % (ICON_REDIRECT.rstrip('/'), icon_path) raise web.HTTPMovedPermanently(location=url) # Convert to full local path. icon_path = pathjoin(ICON_ROOT, icon_path) LOGGER.debug('Using icon: %s', icon_path) obj.src = PathModel(icon_path) if ICON_RESIZE: # Resize or convert the icon to the desired size / format. Backend.preview(obj) return True
def _web_path(self, pathstr, method=None): if not pathstr.startswith(self._prefix): raise web.HTTPMovedPermanently(self._prefix) pathstr = pathstr[len(self._prefix):] share_name, sep, rest = pathstr.partition('/') if len(share_name) == 0: assert len(sep) == 0 and len(rest) == 0 root = None elif share_name in self._fd: root = self._fd[share_name] else: raise web.HTTPNotFound if callable(root): return root readonly = root is None or share_name in self._ro if method is not None: if readonly and method != 'GET': raise web.HTTPMethodNotAllowed(method, ['GET']) if method != 'GET' and method != 'POST': raise web.HTTPMethodNotAllowed(method, ['GET', 'POST']) rest = pathlib.Path(rest) if rest.anchor: raise web.HTTPForbidden return share_name, root, readonly, rest
async def handler(request): return web.HTTPMovedPermanently( location=subapp.router['name'].url_for(filename=fname))
async def handler(request): return web.HTTPMovedPermanently( location=subapp.router['name'].url_for(part='final'))
def redirect(request, router_name, *, permanent=False, **kwargs): """ Редирект """ url = request.app.router[router_name].url(**kwargs) if permanent: raise web.HTTPMovedPermanently(url) raise web.HTTPFound(url)
def function146(arg1145): raise web.HTTPMovedPermanently(location='/path')
async def index(request): """Redirects to the GitHub repo's page""" return web.HTTPMovedPermanently( 'https://github.com/atbaker/twiml-boomerang')
async def handler(request): raise web.HTTPMovedPermanently( location=subapp.router['name'].url_for())
r = await self.url_conn.insert_authorized_key( user, super_user=bool(field.get('super_user', 'false').lower())) await self.redis.sadd('us_auth', r) return web.json_response(dict(status=200, result=r)) if self.debug_mode: logger.debug('Post user => %d', user) return web.HTTPBadRequest() async def handle_redirect(self, request: web.Request) -> web.Response: if not (url := request.match_info.get('url')): return await self.handle_help_page(request) if redis_result := await self.redis.get(f'us_{url}'): url = redis_result.decode() if url != 'Null': return web.HTTPMovedPermanently(url) return web.HTTPBadRequest() if result := await self.url_conn.query_url(url): asyncio.run_coroutine_threadsafe( self.save_query_result(url, result), asyncio.get_event_loop()) return web.HTTPMovedPermanently(url) asyncio.run_coroutine_threadsafe(self.save_query_result(url, "Null"), asyncio.get_event_loop()) return web.HTTPBadRequest() async def handle_create_link(self, request: web.Request) -> web.Response: # Authorization: Bearer user_id:auth_string if not isinstance(bearer := await self.verify_identify(request), str): return bearer data = await request.post() if not (url := data.get('url')):
def func(request): raise web.HTTPMovedPermanently(location='/')
async def documentation_top(request): project_name = request.match_info["project_name"] return web.HTTPMovedPermanently(location=f"/{project_name}/")
async def handle_add_slash(self, request): raise web.HTTPMovedPermanently( str(request.rel_url.with_path(request.rel_url.path + '/')))
def root(request): return web.HTTPMovedPermanently("/static/index.html")
async def get_index(request): return web.HTTPMovedPermanently(location='/static/index.html')
def redirect(request): raise web.HTTPMovedPermanently( location=self.base_path + console_ui_path + '/' )
def handler(request): raise web.HTTPMovedPermanently(location='/path')
async def _redirect(request: web.Request) -> web.Response: return web.HTTPMovedPermanently(f"{request.path}/")