Пример #1
0
async def decrement(request: web.Request):
    if _validate_user_agent(request):
        user_id = request.match_info.get("userid")
        await request.app["db"].execute("DECR", user_id)
    await _set_last(request.app["db"], request)
    raise web.HTTPFound(location="/")
Пример #2
0
async def test(request):
    await set_session(request, 'name', 'heyingliang')
    location = request.app.router['index'].url_for()
    raise web.HTTPFound(location=location)
Пример #3
0
async def transaction_delete(request):
    tid = request.match_info.get('tid')
    transaction = Transaction.get(Transaction.id == tid)
    transaction.delete_instance()
    return web.HTTPFound('/')
Пример #4
0
 def redirect(request):
     count = int(request.match_info['count'])
     if count:
         return web.HTTPFound(location='/redirect/{}'.format(count - 1))
     else:
         return web.HTTPFound(location='/')
Пример #5
0
async def round_socket_handler(request):

    users = request.app["users"]
    sockets = request.app["lobbysockets"]
    seeks = request.app["seeks"]
    games = request.app["games"]
    db = request.app["db"]

    ws = WebSocketResponse(heartbeat=3.0, receive_timeout=10.0)

    ws_ready = ws.can_prepare(request)
    if not ws_ready.ok:
        raise web.HTTPFound("/")

    await ws.prepare(request)

    session = await aiohttp_session.get_session(request)
    session_user = session.get("user_name")
    user = users[
        session_user] if session_user is not None and session_user in users else None

    game = None
    opp_ws = None

    log.debug("-------------------------- NEW round WEBSOCKET by %s" % user)

    try:
        async for msg in ws:
            if msg.type == aiohttp.WSMsgType.TEXT:
                if msg.data == "close":
                    log.debug("Got 'close' msg.")
                    break
                else:
                    data = json.loads(msg.data)
                    # log.debug("Websocket (%s) message: %s" % (id(ws), msg))

                    if data["type"] == "move":
                        # log.info("Got USER move %s %s %s" % (user.username, data["gameId"], data["move"]))
                        game = await load_game(request.app, data["gameId"])
                        move = data["move"]
                        await play_move(request.app, user, game, move,
                                        data["clocks"], data["ply"])

                    elif data["type"] == "ready":
                        game = await load_game(request.app, data["gameId"])
                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]
                        if opp_player.bot:
                            # Janggi game start have to wait for human player setup!
                            if game.variant != "janggi" or not (game.bsetup or
                                                                game.wsetup):
                                await opp_player.event_queue.put(
                                    game.game_start)

                            response = {
                                "type": "gameStart",
                                "gameId": data["gameId"]
                            }
                            await ws.send_json(response)
                        else:
                            response = {
                                "type": "gameStart",
                                "gameId": data["gameId"]
                            }
                            await ws.send_json(response)

                            response = {
                                "type": "user_present",
                                "username": user.username
                            }
                            await round_broadcast(game,
                                                  users,
                                                  game.spectator_list,
                                                  full=True)

                    elif data["type"] == "board":
                        game = await load_game(request.app, data["gameId"])
                        if game.variant == "janggi":
                            if (game.bsetup
                                    or game.wsetup) and game.status <= STARTED:
                                if game.bsetup:
                                    await ws.send_json({
                                        "type":
                                        "setup",
                                        "color":
                                        "black",
                                        "fen":
                                        game.board.initial_fen
                                    })
                                elif game.wsetup:
                                    await ws.send_json({
                                        "type":
                                        "setup",
                                        "color":
                                        "white",
                                        "fen":
                                        game.board.initial_fen
                                    })
                            else:
                                board_response = game.get_board(full=True)
                                await ws.send_json(board_response)
                        else:
                            board_response = game.get_board(full=True)
                            await ws.send_json(board_response)

                    elif data["type"] == "setup":
                        # Janggi game starts with a prelude phase to set up horses and elephants
                        # First the second player (Red) choses his setup! Then the first player (Blue)
                        game = await load_game(request.app, data["gameId"])
                        game.board.initial_fen = data["fen"]
                        game.initial_fen = game.board.initial_fen
                        game.board.fen = game.board.initial_fen
                        # print("--- Got FEN from %s %s" % (data["color"], data["fen"]))

                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]

                        game.steps[0]["fen"] = data["fen"]
                        game.set_dests()

                        if data["color"] == "black":
                            game.bsetup = False
                            response = {
                                "type": "setup",
                                "color": "white",
                                "fen": data["fen"]
                            }
                            await ws.send_json(response)

                            if opp_player.bot:
                                game.board.janggi_setup("w")
                                game.steps[0]["fen"] = game.board.initial_fen
                                game.set_dests()
                            else:
                                opp_ws = users[opp_name].game_sockets[
                                    data["gameId"]]
                                await opp_ws.send_json(response)
                        else:
                            game.wsetup = False
                            response = game.get_board(full=True)
                            # log.info("User %s asked board. Server sent: %s" % (user.username, board_response["fen"]))
                            await ws.send_json(response)

                            if not opp_player.bot:
                                opp_ws = users[opp_name].game_sockets[
                                    data["gameId"]]
                                await opp_ws.send_json(response)

                        if opp_player.bot:
                            await opp_player.event_queue.put(game.game_start)

                    elif data["type"] == "analysis":
                        game = await load_game(request.app, data["gameId"])

                        # If there is any fishnet client, use it.
                        if len(request.app["workers"]) > 0:
                            work_id = "".join(
                                random.choice(string.ascii_letters +
                                              string.digits) for x in range(6))
                            work = {
                                "work": {
                                    "type": "analysis",
                                    "id": work_id,
                                },
                                # or:
                                # "work": {
                                #   "type": "move",
                                #   "id": "work_id",
                                #   "level": 5 // 1 to 8
                                # },
                                "username": data["username"],
                                "game_id": data["gameId"],  # optional
                                "position": game.board.
                                initial_fen,  # start position (X-FEN)
                                "variant": game.variant,
                                "chess960": game.chess960,
                                "moves": " ".join(game.board.move_stack
                                                  ),  # moves of the game (UCI)
                                "nodes": 500000,  # optional limit
                                #  "skipPositions": [1, 4, 5]  # 0 is the first position
                            }
                            request.app["works"][work_id] = work
                            request.app["fishnet"].put_nowait(
                                (ANALYSIS, work_id))
                        else:
                            engine = users.get("Fairy-Stockfish")

                            if (engine is not None) and engine.online():
                                engine.game_queues[
                                    data["gameId"]] = asyncio.Queue()
                                await engine.event_queue.put(
                                    game.analysis_start(data["username"]))

                        response = {
                            "type": "roundchat",
                            "user": "",
                            "room": "spectator",
                            "message": "Analysis request sent..."
                        }
                        await ws.send_json(response)

                    elif data["type"] == "rematch":
                        game = await load_game(request.app, data["gameId"])

                        if game is None:
                            log.debug("Requested game %s not found!")
                            response = {
                                "type": "game_not_found",
                                "username": user.username,
                                "gameId": data["gameId"]
                            }
                            await ws.send_json(response)
                            continue

                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]
                        handicap = data["handicap"]
                        fen = "" if game.variant == "janggi" else game.initial_fen

                        if opp_player.bot:
                            if opp_player.username == "Random-Mover":
                                engine = users.get("Random-Mover")
                            else:
                                engine = users.get("Fairy-Stockfish")

                            if engine is None or not engine.online():
                                # TODO: message that engine is offline, but capture BOT will play instead
                                engine = users.get("Random-Mover")

                            color = "w" if game.wplayer.username == opp_name else "b"
                            if handicap:
                                color = "w" if color == "b" else "b"
                            seek = Seek(user,
                                        game.variant,
                                        fen=fen,
                                        color=color,
                                        base=game.base,
                                        inc=game.inc,
                                        byoyomi_period=game.byoyomi_period,
                                        level=game.level,
                                        rated=game.rated,
                                        chess960=game.chess960)
                            seeks[seek.id] = seek

                            response = await new_game(request.app, engine,
                                                      seek.id)
                            await ws.send_json(response)

                            await engine.event_queue.put(
                                challenge(seek, response))
                            gameId = response["gameId"]
                            engine.game_queues[gameId] = asyncio.Queue()
                        else:
                            opp_ws = users[opp_name].game_sockets[
                                data["gameId"]]
                            if opp_name in game.rematch_offers:
                                color = "w" if game.wplayer.username == opp_name else "b"
                                if handicap:
                                    color = "w" if color == "b" else "b"
                                seek = Seek(user,
                                            game.variant,
                                            fen=fen,
                                            color=color,
                                            base=game.base,
                                            inc=game.inc,
                                            byoyomi_period=game.byoyomi_period,
                                            level=game.level,
                                            rated=game.rated,
                                            chess960=game.chess960)
                                seeks[seek.id] = seek

                                response = await new_game(
                                    request.app, opp_player, seek.id)
                                await ws.send_json(response)
                                await opp_ws.send_json(response)
                            else:
                                game.rematch_offers.add(user.username)
                                response = {
                                    "type": "offer",
                                    "message": "Rematch offer sent",
                                    "room": "player",
                                    "user": ""
                                }
                                game.messages.append(response)
                                await ws.send_json(response)
                                await opp_ws.send_json(response)

                    elif data["type"] == "draw":
                        game = await load_game(request.app, data["gameId"])
                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]

                        response = await draw(games,
                                              data,
                                              agreement=opp_name
                                              in game.draw_offers)
                        await ws.send_json(response)
                        if opp_player.bot:
                            if game.status > STARTED:
                                await opp_player.game_queues[
                                    data["gameId"]].put(game.game_end)
                        else:
                            opp_ws = users[opp_name].game_sockets[
                                data["gameId"]]
                            await opp_ws.send_json(response)

                        if opp_name not in game.draw_offers:
                            game.draw_offers.add(user.username)

                        await round_broadcast(game, users, response)

                    elif data["type"] == "logout":
                        await ws.close()

                    elif data["type"] == "byoyomi":
                        game = await load_game(request.app, data["gameId"])
                        game.byo_correction += game.inc * 1000
                        game.byoyomi_periods[0 if data["color"] ==
                                             "white" else 1] = data["period"]
                        # print("BYOYOMI:", data)

                    elif data["type"] in ("abort", "resign", "abandone",
                                          "flag"):
                        game = await load_game(request.app, data["gameId"])
                        if data["type"] == "abort" and (
                                game is not None) and game.board.ply > 2:
                            continue

                        response = await game.game_ended(user, data["type"])

                        await ws.send_json(response)

                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]
                        if opp_player.bot:
                            await opp_player.game_queues[data["gameId"]
                                                         ].put(game.game_end)
                        else:
                            if data["gameId"] in users[opp_name].game_sockets:
                                opp_ws = users[opp_name].game_sockets[
                                    data["gameId"]]
                                await opp_ws.send_json(response)

                        await round_broadcast(game, users, response)

                    elif data["type"] == "game_user_connected":
                        game = await load_game(request.app, data["gameId"])
                        if session_user is not None:
                            if data["username"] and data[
                                    "username"] != session_user:
                                log.info(
                                    "+++ Existing game_user %s socket connected as %s."
                                    % (session_user, data["username"]))
                                session_user = data["username"]
                                if session_user in users:
                                    user = users[session_user]
                                else:
                                    user = User(
                                        request.app,
                                        username=data["username"],
                                        anon=data["username"].startswith(
                                            "Anon-"))
                                    users[user.username] = user

                                # Update logged in users as spactators
                                if user.username != game.wplayer.username and user.username != game.bplayer.username and game is not None:
                                    game.spectators.add(user)
                            else:
                                if session_user in users:
                                    user = users[session_user]
                                else:
                                    user = User(
                                        request.app,
                                        username=data["username"],
                                        anon=data["username"].startswith(
                                            "Anon-"))
                                    users[user.username] = user
                        else:
                            log.info(
                                "+++ Existing game_user %s socket reconnected."
                                % data["username"])
                            session_user = data["username"]
                            if session_user in users:
                                user = users[session_user]
                            else:
                                user = User(
                                    request.app,
                                    username=data["username"],
                                    anon=data["username"].startswith("Anon-"))
                                users[user.username] = user
                        user.ping_counter = 0

                        # update websocket
                        if data["gameId"] in user.game_sockets:
                            await user.game_sockets[data["gameId"]].close()
                        user.game_sockets[data["gameId"]] = ws

                        # remove user seeks
                        if len(user.lobby_sockets) == 0 or (
                                game.status <= STARTED and
                            (user.username == game.wplayer.username
                             or user.username == game.bplayer.username)):
                            await user.clear_seeks(sockets, seeks)

                        if game is None:
                            log.debug("Requested game %s not found!")
                            response = {
                                "type": "game_not_found",
                                "username": user.username,
                                "gameId": data["gameId"]
                            }
                            await ws.send_json(response)
                            continue
                        else:
                            games[data["gameId"]] = game
                            if user.username != game.wplayer.username and user.username != game.bplayer.username:
                                game.spectators.add(user)
                                await round_broadcast(game,
                                                      users,
                                                      game.spectator_list,
                                                      full=True)

                            response = {
                                "type": "game_user_connected",
                                "username": user.username,
                                "gameId": data["gameId"],
                                "ply": game.board.ply
                            }
                            await ws.send_json(response)

                        response = {
                            "type": "crosstable",
                            "ct": game.crosstable
                        }
                        await ws.send_json(response)

                        response = {
                            "type": "fullchat",
                            "lines": list(game.messages)
                        }
                        await ws.send_json(response)

                        response = {
                            "type": "user_present",
                            "username": user.username
                        }
                        await round_broadcast(game, users, response, full=True)

                        # not connected to lobby socket but connected to game socket
                        if len(user.game_sockets
                               ) == 1 and user.username not in sockets:
                            request.app["u_cnt"] += 1
                            response = {
                                "type": "u_cnt",
                                "cnt": request.app["u_cnt"]
                            }
                            await lobby_broadcast(sockets, response)

                    elif data["type"] == "is_user_present":
                        player_name = data["username"]
                        player = users.get(player_name)
                        await asyncio.sleep(1)
                        if player is not None and data["gameId"] in (
                                player.game_queues
                                if player.bot else player.game_sockets):
                            response = {
                                "type": "user_present",
                                "username": player_name
                            }
                        else:
                            response = {
                                "type": "user_disconnected",
                                "username": player_name
                            }
                        await ws.send_json(response)

                    elif data["type"] == "moretime":
                        # TODO: stop and update game stopwatch time with updated secs
                        game = await load_game(request.app, data["gameId"])

                        opp_color = WHITE if user.username == game.bplayer.username else BLACK
                        if opp_color == game.stopwatch.color:
                            opp_time = game.stopwatch.stop()
                            game.stopwatch.restart(opp_time + MORE_TIME)

                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]

                        if not opp_player.bot:
                            opp_ws = users[opp_name].game_sockets[
                                data["gameId"]]
                            response = {
                                "type": "moretime",
                                "username": opp_name
                            }
                            await opp_ws.send_json(response)
                            await round_broadcast(game, users, response)

                    elif data["type"] == "roundchat":
                        gameId = data["gameId"]
                        game = await load_game(request.app, gameId)
                        if data["message"] == "!analysis" and user.username in request.app[
                                "fishnet_versions"]:
                            for step in game.steps:
                                if "analysis" in step:
                                    del step["analysis"]
                            await ws.send_json({"type": "request_analysis"})
                            continue

                        response = {
                            "type": "roundchat",
                            "user": user.username,
                            "message": data["message"],
                            "room": data["room"]
                        }
                        game.messages.append(response)

                        for name in (game.wplayer.username,
                                     game.bplayer.username):
                            player = users[name]
                            if player.bot:
                                if gameId in player.game_queues:
                                    await player.game_queues[gameId].put(
                                        '{"type": "chatLine", "username": "******", "room": "spectator", "text": "%s"}\n'
                                        % (user.username, data["message"]))
                            else:
                                if gameId in player.game_sockets:
                                    player_ws = player.game_sockets[gameId]
                                    await player_ws.send_json(response)

                        await round_broadcast(game, users, response)

                    elif data["type"] == "leave":
                        response = {
                            "type": "roundchat",
                            "user": "",
                            "message": "%s left the game" % user.username,
                            "room": "player"
                        }
                        gameId = data["gameId"]
                        game = await load_game(request.app, gameId)
                        game.messages.append(response)

                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]
                        if not opp_player.bot and gameId in opp_player.game_sockets:
                            opp_player_ws = opp_player.game_sockets[gameId]
                            await opp_player_ws.send_json(response)

                            response = {
                                "type": "user_disconnected",
                                "username": user.username
                            }
                            await opp_player_ws.send_json(response)

                        await round_broadcast(game, users, response)

                    elif data["type"] == "updateTV":
                        if "profileId" in data and data["profileId"] != "":
                            gameId = await tv_game_user(
                                db, users, data["profileId"])
                        else:
                            gameId = await tv_game(db, request.app)

                        if gameId != data["gameId"] and gameId is not None:
                            response = {"type": "updateTV", "gameId": gameId}
                            await ws.send_json(response)

                    elif data["type"] == "count":

                        game = await load_game(request.app, data["gameId"])
                        cur_player = game.bplayer if game.board.color == BLACK else game.wplayer
                        opp_name = game.wplayer.username if user.username == game.bplayer.username else game.bplayer.username
                        opp_player = users[opp_name]
                        opp_ws = users[opp_name].game_sockets[data["gameId"]]

                        if user.username == cur_player.username:
                            if data["mode"] == "start":
                                game.start_manual_count()
                                response = {
                                    "type": "count",
                                    "message":
                                    "Board's honor counting started",
                                    "room": "player",
                                    "user": ""
                                }
                                await ws.send_json(response)
                                await opp_ws.send_json(response)
                                await round_broadcast(game, users, response)
                            elif data["mode"] == "stop":
                                game.stop_manual_count()
                                response = {
                                    "type": "count",
                                    "message":
                                    "Board's honor counting stopped",
                                    "room": "player",
                                    "user": ""
                                }
                                await ws.send_json(response)
                                await opp_ws.send_json(response)
                                await round_broadcast(game, users, response)
                        else:
                            response = {
                                "type": "count",
                                "message":
                                "You can only start/stop board's honor counting on your own turn!",
                                "room": "player",
                                "user": ""
                            }
                            await ws.send_json(response)

            elif msg.type == aiohttp.WSMsgType.CLOSED:
                log.debug(
                    "--- Round websocket %s msg.type == aiohttp.WSMsgType.CLOSED"
                    % id(ws))
                break

            elif msg.type == aiohttp.WSMsgType.ERROR:
                log.error(
                    "--- Round ws %s msg.type == aiohttp.WSMsgType.ERROR" %
                    id(ws))
                break

            else:
                log.debug("--- Round ws other msg.type %s %s" %
                          (msg.type, msg))

    except Exception as e:
        log.error("!!! Round ws exception occured: %s" % type(e))

    finally:
        log.debug("---fianlly: await ws.close()")
        await ws.close()

    if game is not None and not user.bot:
        if game.id in user.game_sockets:
            del user.game_sockets[game.id]

        if user.username != game.wplayer.username and user.username != game.bplayer.username:
            game.spectators.discard(user)
            await round_broadcast(game, users, game.spectator_list, full=True)

        # not connected to lobby socket and not connected to game socket
        if len(user.game_sockets) == 0 and user.username not in sockets:
            request.app["u_cnt"] -= 1
            response = {"type": "u_cnt", "cnt": request.app["u_cnt"]}
            await lobby_broadcast(sockets, response)

    if game is not None:
        response = {"type": "user_disconnected", "username": user.username}
        await round_broadcast(game, users, response, full=True)

    return ws
def signout(request):
    referer = request.headers.get('Referer')
    r = web.HTTPFound(referer or '/')
    r.set_cookie(COOKIE_NAME, '-deleted-', max_age=0, httponly=True)
    logging.info('user signed out.')
    return r
Пример #7
0
 def redirect(request):
     return web.HTTPFound(location='ftp://127.0.0.1/test/')
Пример #8
0
 def redirector(request):
     raise web.HTTPFound(location=URL('/redirected'))
Пример #9
0
def redirect(req):
    return web.HTTPFound('/response/json')
Пример #10
0
 async def static_favicon(req):
     raise web.HTTPFound(location='https://wiltforcongress.com/favicon.ico')
Пример #11
0
 async def index(req):
     raise web.HTTPFound(location='https://wiltforcongress.com/')
Пример #12
0
async def epoll(req):
    contact = await Contact.find_by_id(req.match_info['hash'])
    if contact is None:
        raise web.HTTPFound('/earlybird_sites')
    triplet = dict(
        zip(('house', 'street', 'zip'),
            (contact.house, contact.street, contact.zipcode)))
    await asyncio.create_task(tag_contact_with(contact,
                                               'vote4robin_earlybird'))
    early_polling_sites = (
        '57 St. Paul St., 2nd Floor, Rochester, NY 14604',
        '700 North St., Rochester, NY 14605',
        '310 Arnett Blvd., Rochester, NY 14619',
        '10 Felix St., Rochester, NY 14608',
        '680 Westfall Rd., Rochester, NY 14620',
        '1039 N. Greece Rd., Rochester, NY 14626',
        '1 Miracle Mile Dr., Rochester, NY 14623',
        '1290 Titus Ave., Rochester, NY 14617',
        '3100 Atlantic Ave., Penfield, NY 14526',
        '6720 Pittsford Palmyra Rd., Fairport, NY 14450',
        '4761 Redman Rd., Brockport, NY 14420',
        '1350 Chiyoda Dr., Webster, NY 14580',
    )
    residence = uriquote(
        f'{contact.house} {contact.street}, {contact.zipcode}')
    cull = {'residence': triplet, 'site': {'$in': early_polling_sites}}
    reapc = await DB.early_polling.count_documents(cull)
    if reapc < 1:
        lat, lng = await geocode(contact.house, contact.street,
                                 contact.zipcode)
        q = {'type': 'Point', 'coordinates': (lat, lng)}
        q = {'geo': {'$near': {'$geometry': q}}}
        top_three = []
        sites = DB.early_polling_sites.find(q, {'address': 1})
        async for site in sites:
            top_three.append(site['address'])
            if len(top_three) == 3:
                break
        try:
            closest = await address_closest(residence, *top_three)
        except Exception:
            raise web.HTTPFound(location='/earlybird_sites')
        sow = {'$set': {'residence': triplet, 'site': closest}}
        await DB.early_polling.update_many(cull, sow, upsert=True)
    else:
        reap = {'site': 1}
        harvest = await DB.early_polling.find_one(cull, reap)
        closest = harvest['site']
    closest = uriquote(closest)
    doc, tag, text = Doc().tagtext()
    doc.asis('<!DOCTYPE html>')
    with tag('head'):
        with tag('title'):
            text(f"{contact.forename}'s Early Polling Sites")

        with tag('script'):
            text('''
                 const msg = (
                     'The Board of Elections is encouraging all who have waited ' +
                     'over a week for their absentee ballot to consider voting ' +
                     'in person at _any_ early polling site through Sunday, June ' +
                     '21. Click OK to see the closest site to your registered ' +
                     'address and a list of all early voting sites.');
                 alert(msg);
                 ''')
        with tag('style'):
            text('''
                 a { text-decoration: none;
                     color: #4287f5;
                     font-size: xx-large;
                     padding: 0.5em;
                     font-family: Roboto, Arial, 'sans-serif'; }
                 a:hover { color: #1bf5ee; }
                 div.flex { display: flex;
                            float: center;
                            margin: auto;
                            width: 80%;
                            height: 100vh;
                            padding: 2em;
                            flex-direction: column; }
                 ''')
    with tag('body'):
        closest_src = (
            r'https://www.google.com/maps/embed/v1/directions'
            f'?origin={residence}&destination={closest}&key={DM_TOKEN}')
        center = urlencode({
            'house': contact.house,
            'street': contact.street,
            'zip': contact.zipcode
        })
        browse_src = f'/earlybird_sites?{center}'
        with tag('div', klass='flex'):
            with tag('a', href=f'https://google.com/maps/place/{closest}'):
                text(r'Closest early polling to '
                     f'{contact.house} {contact.street}')
            with tag('iframe', src=closest_src, height='50%'):
                pass
            with tag('a', href=browse_src):
                text('Browse all early polling sites')
            with tag('iframe', src=browse_src, height='50%'):
                pass

    return web.Response(text=doc.getvalue(), content_type='text/html')
Пример #13
0
async def gotv_passthrough(req):
    contact = await Contact.find_by_id(req.match_info['hash'])
    await asyncio.create_task(
        tag_contact_with(contact, 'vote4robin_gotv_passthrough'))
    raise web.HTTPFound('https://wiltforcongress.com/vote')
async def flash_handler(request):
    flash(request, 'You have just visited flash page')
    return web.HTTPFound('/')
Пример #15
0
def test_HTTPFound_empty_location():
    with pytest.raises(ValueError):
        web.HTTPFound(location='')

    with pytest.raises(ValueError):
        web.HTTPFound(location=None)
Пример #16
0
async def index(request):
    raise web.HTTPFound('/static/index.html')
Пример #17
0
async def index(request):
    return web.HTTPFound('/index.html')
Пример #18
0
async def index(request):
    loop = asyncio.get_event_loop()
    rel_did = await create_relationship(loop)
    session = await aiohttp_session.get_session(request)
    session['rel_did'] = rel_did
    raise web.HTTPFound('/static/qrcode.html')
Пример #19
0
 def redirect(request):
     return web.HTTPFound(location=client.make_url('/'))
Пример #20
0
async def completeconnect(request):
    loop = asyncio.get_event_loop()
    await create_connection(loop)
    raise web.HTTPFound('/static/connectioncomplete.html')
Пример #21
0
 def redirect(request):
     return web.HTTPFound(location='/')
Пример #22
0
async def prescribe(request):
    raise web.HTTPFound('/static/prescribe.html')
Пример #23
0
async def handle_index(request):
    session = await aiohttp_session.get_session(request)
    if session.get('uid') is not None:
        raise web.HTTPFound(request.app.router['user_page'].url_for())

    return dict(session=session)
Пример #24
0
 def login(request):
     response = web.HTTPFound(location='/')
     yield from remember(request, response, 'Andrew')
     return response
Пример #25
0
async def manage(request):
    return web.HTTPFound('/manage/blogs')
Пример #26
0
 def logout(request):
     response = web.HTTPFound(location='/')
     yield from forget(request, response)
     return response
Пример #27
0
def redirect(request, router_name):
    url = request.app.router[router_name].url_for()
    raise web.HTTPFound(url)
Пример #28
0
async def signout(request):
    # 退出登录
    referer = request.headers.get("Referer")
    resp = web.HTTPFound(referer or '/')
    resp.set_cookie(_COOKIE_NAME, "-deleted-", max_age=0, httponly=True)
    return resp
Пример #29
0
async def post_edit_resource(request, userdata):  # pylint: disable=unused-argument
    db = request.app['db']
    storage_client = request.app['storage_client']
    id = int(request.match_info['id'])
    old_record = await db.select_and_fetchone(
        '''
SELECT attachments FROM atgu_resources
WHERE id = %s;
''', (id))
    if not old_record:
        raise web.HTTPNotFound()

    old_attachments = json.loads(old_record['attachments'])

    checked_csrf = False
    attachments = {}
    post = {}
    reader = aiohttp.MultipartReader(request.headers, request.content)
    while True:
        part = await reader.next()  # pylint: disable=not-callable
        if not part:
            break
        if part.name == '_csrf':
            # check csrf token
            token1 = request.cookies.get('_csrf')
            token2 = await part.text()
            if token1 is None or token2 is None or token1 != token2:
                log.info('request made with invalid csrf tokens')
                raise web.HTTPUnauthorized()
            checked_csrf = True
        elif part.name == 'attachment':
            if not checked_csrf:
                raise web.HTTPUnauthorized()
            attachment_id = await part.text()
            assert attachment_id in old_attachments
            attachments[attachment_id] = old_attachments[attachment_id]
        elif part.name == 'file':
            filename = part.filename
            if not filename:
                continue
            attachment_id = secret_alnum_string()
            async with await storage_client.insert_object(
                    BUCKET, f'atgu/attachments/{attachment_id}') as f:
                while True:
                    chunk = await part.read_chunk()
                    if not chunk:
                        break
                    await f.write(chunk)
            attachments[attachment_id] = filename
        else:
            post[part.name] = await part.text()

    if not checked_csrf:
        raise web.HTTPUnauthorized()

    now = time_msecs()
    await db.execute_update(
        '''
UPDATE atgu_resources SET
title = %s,
description = %s,
contents = %s,
tags = %s,
attachments = %s,
time_updated = %s
WHERE id = %s
''', (post['title'], post['description'], post['contents'], post['tags'],
      json.dumps(attachments), now, id))

    return web.HTTPFound(deploy_config.external_url('atgu',
                                                    f'/resources/{id}'))
Пример #30
0
async def logout(request):
    session = await aiohttp_session.get_session(request)
    if "token" in session:
        del session["token"]
        del session["uid"]
    raise web.HTTPFound("/")