async def iam_login(request): client = request.app.iam_client # Check if is not redirect from provider if client.shared_key not in request.query: # Redirect client to provider return web.HTTPTemporaryRedirect( client.get_authorize_url(access_type='offline')) try: meta, userinfo = await auth.get_token_userinfo(request) except web.HTTPInternalServerError as e: raise e except Exception: return web.HTTPTemporaryRedirect( client.get_authorize_url(access_type='offline')) session = await aiohttp_session.get_session(request) session["userinfo"] = userinfo session["username"] = userinfo["name"] session["gravatar"] = utils.avatar(userinfo["email"], 26) session['organisation_name'] = userinfo['organisation_name'] user_id = userinfo["sub"] redirect_response = web.HTTPFound("/") await aiohttp_security.remember(request, redirect_response, user_id) request.app.sla_loader = await sla.load_slas_as_task(request) return redirect_response
async def middleware(request, handler): path = request.url.path if len(path) > 100: return web.HTTPTemporaryRedirect('/nou') if request.url.path[-1] == '/' and request.url.path != '/': stripped_url = request.url.path.rstrip('/') return web.HTTPPermanentRedirect(stripped_url) r = await handler(request) if isinstance(r, str): r = web.Response(text=r, headers={'content-type': 'text/html'}) content_types = { 'css': 'text/css', 'js': 'text/javascript', 'html': 'text/html', 'json': 'application/json', 'xml': 'application/xml', 'rss': 'application/rss+xml', 'png': 'image/png' } # if r.content_type == 'application/octet-stream': parts = request.url.parts last_path = parts[-1] ext = last_path.rsplit('.', 1)[-1] if ext in content_types: r.content_type = content_types[ext] else: if r.content_type == 'application/octet-stream': r.content_type = 'text/plain' try: r = await custom_replace(r, request) except AttributeError: pass return r
async def get(self, request: web.Request, camera_id: str, event_id: str) -> web.Response: """ start a GET request. """ authenticated = request.get(KEY_AUTHENTICATED, False) if not authenticated: token: str = request.query.get("token") if not token: raise web.HTTPUnauthorized() data: dict = self.hass.data.get(DOMAIN_DATA) data = data.get(MEDIA_SOURCE) if data else None tokens: List[str] = data.get(LONG_TOKENS) if data else None if not tokens or not token in tokens: raise web.HTTPUnauthorized() if not camera_id or not event_id: raise web.HTTPNotFound() data: Dict[str, dict] = self.hass.data[DOMAIN] base: ReolinkBase = (data[camera_id].get(BASE, None) if camera_id in data else None) if not base: _LOGGER.debug("camera %s not found", camera_id) raise web.HTTPNotFound() file = unquote_plus(event_id) url = await base.api.get_vod_source(file) return web.HTTPTemporaryRedirect(url)
async def logout(request: web.Request) -> web.Response: session = await aiohttp_session.get_session(request) if "sp_user_id" in session: del session["sp_user_id"] return web.HTTPTemporaryRedirect( location=request.app.router["index"].url_for() )
async def link_redirect(request: web.Request): dataset = request.match_info['dataset'] distribution = request.match_info['distribution'] etag_if_none_match = conditional.parse_if_header( request, conditional.HEADER_IF_NONE_MATCH) if etag_if_none_match == '*': raise web.HTTPBadRequest( body='Endpoint does not support * in the If-None-Match header.') try: doc, etag = await request.app.hooks.storage_retrieve( app=request.app, docid=dataset, etags=etag_if_none_match) except KeyError: raise web.HTTPNotFound() if doc is None: raise web.HTTPNotModified(headers={'ETag': etag}) headers = {'ETag': etag} resource_url = None for dist in doc.get('dcat:distribution', []): if dist.get('dc:identifier', None) == distribution: resource_url = dist.get('dcat:accessURL', None) break if resource_url is None: raise web.HTTPNotFound(headers=headers) raise web.HTTPTemporaryRedirect(location=resource_url, headers=headers)
async def so_callback(req: web.Request) -> web.Response: """Handle OAuth2 callback from stack exchange API. Expects code in query and exchanges it for a token. """ if req.query.get("error"): return web.Response(text="Error: " + req.query.get("error")) res_code = req.query.get("code") if not res_code: return web.Response(text="Error: Missing code") def token_error(msg: str) -> web.Response: return web.Response(text=f"OAuth2 Token retrieval error: {msg}", status=500) async with sess.post( "https://stackoverflow.com/oauth/access_token/json", data={ "client_id": CLIENT_ID, "client_secret": CLIENT_SECRET, "code": res_code, "redirect_uri": REDIRECT_URI, }, ) as r: if r.status != 200: text = await r.text() return token_error(text) data = await r.json() if "error_message" in data: return token_error(data.get("error_message")) if "access_token" not in data: return token_error("Missing token in response: " + str(data)) return web.HTTPTemporaryRedirect( "/so/success?" + urlencode({"token": data["access_token"]}))
async def get_request(self, request): ''' Handle the request from client if leader, otherwise redirect to the leader. ''' self._log.info("%d: on request", self._index) if not self._is_leader: if self._leader != None: raise web.HTTPTemporaryRedirect( self.make_url(self._nodes[self._leader], MessageType.REQUEST)) else: raise web.HTTPServiceUnavailable() else: # print(request.headers) # print(request.__dict__) json_data = await request.json() # print("\t\t--->node"+str(self._index)+": on request :") # print(json_data) await self.preprepare(json_data) return web.Response()
async def get_obs_request(self, get_obs_request): """ Node function. If not leader, re-directs to leader. Calls preprepare function. :return: """ if self._index != self.leader: # if self is not leader redirect to leader raise web.HTTPTemporaryRedirect(make_url(self.leader, 'get_obs_request')) else: j = await get_obs_request.json() if self.observations_recieved is None: self.observations_recieved = {} self.time_started = time.time() self.observations_recieved[j['id'][0]] = j['data'] #if not self._sent: print(self.observations_recieved) if ("LF" not in self.method) and (self.value_to_send is None) and (len(self.observations_recieved.keys()) >= ((2 * self._f) + 1)): vals = (list(self.observations_recieved.values())) self.value_to_send = np.array([ast.literal_eval(val) for val in vals])[0] elif (self.value_to_send is None) and (len(self.observations_recieved.keys()) >= ((2 * self._f) + 1)): #### CHANGED THIS TO >= vals = (list(self.observations_recieved.values())) # list of strings self.value_to_send = np.array([ast.literal_eval(val) for val in vals]) self.value_to_send = np.median(self.value_to_send, axis=0) if self.value_to_send is not None and not self._sent: self._sent = True self.log(f"VALUE TO SEND: {self.value_to_send}") request = { 'leader': self._index, 'data': json.dumps(self.value_to_send.tolist())} await self.preprepare(request) return web.Response()
async def handle_logout(request): session = await get_session(request) sid = session.get('id') if sid is not None: db_sessions.delete_one({'_id': ObjectId(sid)}) session.invalidate() return web.HTTPTemporaryRedirect(location="/")
def get(self): item = self.ctx.get('submittedhomework', self.request.match_info['id']) for homework in item.course.children['homework']: if f'SubmittedHomework-{self.id}' in homework.meta['children']: raise web.HTTPTemporaryRedirect( f'/homework/{homework.meta["id"]}/submissions/{self.id}') raise web.HTTPServerError
def icon_redirect(request): filename = request.match_info['filename'] try: icon = ICON_MAPPING[filename] except KeyError: raise web.HTTPNotFound raise web.HTTPTemporaryRedirect( f'https://fonts.gstatic.com/s/i/materialicons/{icon}/v6/24px.svg')
async def wrapped(request: web.Request) -> web.Response: session = await aiohttp_session.get_session(request) auth = session.get("spotify_auth") if auth is None: raise web.HTTPTemporaryRedirect( location=request.app["spotify_app"].router["auth"].url_for( ).with_query(redirect=request.url.path)) return await handler(request, SpotifyAuth(*auth))
async def confirm_18plus(request): target = request.query.get('next') if target is None: return web.HTTPTemporaryRedirect('/') if not is_safe_url(request, target): return web.HTTPBadRequest() if '18+' in request.cookies: return web.HTTPTemporaryRedirect(target) is_18plus = request.query.get('confirm') if is_18plus is None: return await render_template('confirm-18+.html', target=target) elif is_18plus == 'false': response = web.HTTPTemporaryRedirect('/') return response response = web.HTTPTemporaryRedirect(target) response.set_cookie('18+', '', max_age=ONE_YEAR) return response
async def playlists_handler(self, request): try: display_list = await self.spotify_controller.get_user_playlists() return web.json_response(display_list) except requests.exceptions.HTTPError: self.goback = request.raw_path raise web.HTTPTemporaryRedirect('/auth') except: logger.info('error getting user playlists', exc_info=True) return web.json_response([])
async def move(request: web.Request): raw_state = request.match_info['state'] post_data = await request.post() move1 = Pot(int(post_data['pot'])) state = State([int(x) for x in raw_state.split(',')]) if move1 not in state.possible_moves(Player.ONE): raise web.HTTPTemporaryRedirect(f"/game/{state.to_web}") state = state.move(Player.ONE, move1) if not state.possible_moves(Player.ONE) or not state.possible_moves(Player.TWO): raise web.HTTPTemporaryRedirect(f"/end/{state.to_web}") move2 = state.suggest(Player.TWO) state = state.move(Player.TWO, move2) if not state.possible_moves(Player.ONE) or not state.possible_moves(Player.TWO): raise web.HTTPTemporaryRedirect(f"/end/{state.to_web}") raise web.HTTPTemporaryRedirect(f"/game/{state.to_web}")
async def on_github_login(request: web.Request, github_token): session = await get_session(request) async with request.app["session"].get( "https://api.github.com/user", headers={"Authorization": f"Bearer {github_token['access_token']}"}, ) as r: session["user"] = await r.json() return web.HTTPTemporaryRedirect(location="/")
async def get(self) -> web.Response: params = { 'client_id': self.request.app['CLIENT_ID'], 'redirect_uri': redirect_uri(self.request), 'response_type': 'code', **self.request.app['AUTH_EXTRAS'], } if self.request.app['SCOPES']: params['scope'] = " ".join(self.request.app['SCOPES']) location = str(URL(self.request.app['AUTHORIZE_URL']).with_query(params)) return web.HTTPTemporaryRedirect(location=location)
async def readFileHandler(request): filename = request.match_info['filename'] response = await readFile(filename) if response: if isinstance(response, str): # print('http://{}/file/{}'.format(response,filename)) raise web.HTTPTemporaryRedirect('http://{}/file/{}'.format( response, filename)) else: return web.Response(body=response) else: raise web.HTTPNotFound
async def redirect_handler(self, request): # this is part of the actual spotify service authentication callback after manual authentication try: vals = self.get_query_string_variables(request.query_string) if 'code' in vals: code = vals['code'] result = await self.spotify_controller.set_token(code) except: logger.error( '.. Error handling Spotify redirect callback after manual authentication', exc_info=True) raise web.HTTPTemporaryRedirect('/')
async def auth(request: web.Request) -> web.Response: session = await get_session(request) session["spotify_target_url"] = request.query.get("redirect") # Generate a state token state = secrets.token_urlsafe() session["spotify_state"] = state # Construct the redirect URL location = request.app["spotify_client"].get_oauth_url(state=state) return web.HTTPTemporaryRedirect(location=str(location))
async def setpreview_handler(self, request): try: playlist = await self.spotify_controller.get_playlist( request.match_info['playlist']) return web.json_response(playlist) except requests.exceptions.HTTPError: self.goback = request.raw_path raise web.HTTPTemporaryRedirect('/auth') except: logger.info('error getting playlist', exc_info=True) return web.json_response([])
async def get_shortener(request: web.Request): id = request.match_info['id'] if id is None: return web.HTTPBadRequest() doc = await request.app['db'].url_shortener.urls.find_one_and_update( {'id': id}, {'$inc': { 'count': 1 }}) if doc is None: return web.HTTPNotFound() url = doc['url'] return web.HTTPTemporaryRedirect(url)
async def blog_post_new(request): form = await request.post() username = await get_username(request) if username is None: return web.HTTPTemporaryRedirect('/blog/login') body = form['body'] title = form['title'] print(form) unlisted = form.get('unlisted', 'off') == 'on' r = await db.new_blog_post(title, body, username, unlisted=unlisted) print(r) return web.HTTPFound(f'/blog/post/{r}')
async def blog_post_preview(request): form = await request.post() username = await get_username(request) if username is None: return web.HTTPTemporaryRedirect('/blog/login') body = form['body'] title = form['title'] post = db.get_blog_post_dict(title, body, username) post = await db.convert_post(post, get_html=True) return await load_template('blogpost.html', p=post, is_admin=False, is_preview=True)
async def on_google_login(request: web.Request, login_data: Dict[str, Any]): session = await get_session(request) id_token = login_data.get('id_token') access_token = login_data.get('access_token') logger.debug('token: ' + str(id_token)) logger.debug('session: ' + str(session)) logger.debug('access_token: ' + str(access_token)) async with request.app['session'].get( 'https://oauth2.googleapis.com/tokeninfo?id_token=' + id_token, headers={'Authorization': f'Bearer {access_token}'}, ) as r: user_info = await r.json() session['user'] = user_info.get('name') return web.HTTPTemporaryRedirect(location="/")
async def test_donate(self, data: web.Request): # update_config() print(f"New test donation amount: {data.query['size']}", file=sys.stderr) donation = Donation({ "additional_data": "{}", "amount_main": int(data.query["size"]), "username": "******" }) await self.callback(donation) # asyncio.get_running_loop().create_task(self.callback(donation)) # asyncio.get_running_loop().create_task() return web.HTTPTemporaryRedirect("/")
async def playlist_handler(self, request): try: display_list = [] name = request.match_info['playlist'] playlist = self.spotify_controller.get_user_playlist( request.match_info['playlist']) display_list = self.spotify_controller.get_playlist_tracks( playlist['id']) return web.json_response(display_list) except requests.exceptions.HTTPError: self.goback = request.raw_path raise web.HTTPTemporaryRedirect('/auth') except: logger.info('error getting playlist', exc_info=True) return web.json_response([])
async def get(self) -> web.Response: params = { "client_id": self.request.app["CLIENT_ID"], "redirect_uri": redirect_uri(self.request), "response_type": "code", # "state": TODO **self.request.app["AUTH_EXTRAS"], } if self.request.app["SCOPES"]: params["scope"] = " ".join(self.request.app["SCOPES"]) location = str( URL(self.request.app["AUTHORIZE_URL"]).with_query(params)) return web.HTTPTemporaryRedirect(location=location)
async def facebook_login(request): session = await get_session(request) config = request.app['config'] params = request.url.query if 'error_reason' in params: return web.HTTPForbidden(text=("You denied us because: " "{error_description}").format(**params)) token_request_params = { "client_id": config['facebook']['app_id'], "redirect_uri": config['facebook']['redirect_uri'], "client_secret": config['facebook']['app_secret'], "code": params['code'], } access_token_url = "https://graph.facebook.com/v2.8/oauth/access_token" url = requests.build_url(access_token_url, token_request_params) access_token = await requests.get_json(url) fb_url = ("https://graph.facebook.com/v2.8/me?fields=email,name," "verified,albums.order(reverse_chronological).limit(1)" "&access_token={access_token}").format(**access_token) user_data = await requests.get_json(fb_url) if not user_data['verified']: raise web.HTTPForbidden(text="facebook_not_verified") first_album_date = user_data['albums']['data'][0]["created_time"] min_account_age = timedelta(days=365.25 * int(config['facebook']['min_account_years'])) now = datetime.now(timezone.utc) if abs(date_parser(first_album_date) - now) < min_account_age: raise web.HTTPForbidden(text="facebook_account_not_old_enough") user_data['id'] = obscure_id(int(user_data['id']), config['server']['fernet_secret'], 'facebook') try: userid = request.app['db'].new_user(user_data['name'], user_data['email'], user_data['id'], access_token['access_token']) except db.UserAlreadyExists: userid = user_data['id'] finally: session['userid'] = userid session['name'] = user_data['name'] return web.HTTPTemporaryRedirect('/login', body=b'Redirecting...')
async def handle_success(request: web.Request, auth: api.SpotifyAuth) -> web.Response: handler = request.app.get("spotify_handle_auth") if handler is not None: await handler(request, auth) handler = request.app.get("spotify_on_success") if handler is not None: return await handler(request, auth) session = await get_session(request) target_url = session.get("spotify_target_url") if target_url is None: target_url = request.app["spotify_default_redirect"] if target_url is None: return web.Response(body="authorized") return web.HTTPTemporaryRedirect(location=target_url)