async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/credential/{id}", credentials_get), web.post("/credential/{id}/remove", credentials_remove), web.get("/credentials", credentials_list), web.get("/credential_exchange", credential_exchange_list), web.get("/credential_exchange/{id}", credential_exchange_retrieve), web.post("/credential_exchange/send", credential_exchange_send), web.post("/credential_exchange/send-offer", credential_exchange_send_offer), web.post( "/credential_exchange/{id}/send-request", credential_exchange_send_request, ), web.post("/credential_exchange/{id}/issue", credential_exchange_issue), web.post("/credential_exchange/{id}/store", credential_exchange_store), web.post( "/credential_exchange/{id}/problem_report", credential_exchange_problem_report, ), web.post("/credential_exchange/{id}/remove", credential_exchange_remove), ])
def setup_statics(app: web.Application): # NOTE: source-output and build-output have both the same subfolder structure cfg = app[APP_CONFIG_KEY]["main"] app[APP_STATICS_OUTDIR_KEY] = statics_dir = Path( cfg["client_outdir"]).expanduser() # Creating static routes routes = web.RouteTableDef() is_dev: bool = app[APP_SETTINGS_KEY].build_target in [None, "development"] for name in STATIC_DIRNAMES: folder = statics_dir / name # avoids problems restarting when qx-compile takes longer to product outputs if not folder.exists() and is_dev: os.makedirs(folder, exist_ok=True) # can navigate file index in dev mode routes.static(f"/{folder.name}", folder, show_index=is_dev) app.add_routes(routes) # Create dynamic route to serve front-end client app.router.add_get("/", get_frontend_ria, name=INDEX_RESOURCE_NAME) # Delayed creation of statics.json (mostly for dev mode) app.on_startup.append(_start_statics)
async def init_routes(app: web.Application) -> None: """ Initializing the Routes :param app: :return: """ try: log.info(f'Initializing the routes') base_prefix = '/product' add_route = app.router.add_route add_route('*', '/', index, name='index') # added static dir app.router.add_static( '/static/', path=(PROJECT_PATH / 'static'), name='static', ) await vh.init_version_routes(app, base_prefix) await ph.init_product_routes(app, base_prefix) # Updating the version server routes app.add_routes(routes) except Exception as e: log.error('init_routes Error {}'.format(e))
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/revocation/create-registry", revocation_create_registry), web.get( "/revocation/registries/created", revocation_registries_created, allow_head=False, ), web.get("/revocation/registry/{rev_reg_id}", get_registry, allow_head=False), web.get( "/revocation/active-registry/{cred_def_id}", get_active_registry, allow_head=False, ), web.get( "/revocation/registry/{rev_reg_id}/tails-file", get_tails_file, allow_head=False, ), web.patch("/revocation/registry/{rev_reg_id}", update_registry), web.post("/revocation/registry/{rev_reg_id}/publish", publish_registry), ])
def setup() -> _T: state: Dict[str, str] = {} async def reg(request: Request) -> None: nonlocal state state["method"] = request.method state["body"] = await request.read() async def handler(request: Request) -> Response: await reg(request) return Response(text="Some text") async def json_handler(request: Request) -> Response: await reg(request) return json_response({"key": "value"}) app = Application() app.add_routes([ web.get("/url/", handler), web.post("/url/", handler), web.options("/url/", handler), web.put("/url/", handler), web.patch("/url/", handler), web.delete("/url/", handler), web.get("/json_url/", json_handler), ]) return app, state
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/revocation/create-registry", create_rev_reg), web.get( "/revocation/registries/created", rev_regs_created, allow_head=False, ), web.get("/revocation/registry/{rev_reg_id}", get_rev_reg, allow_head=False), web.get( "/revocation/active-registry/{cred_def_id}", get_active_rev_reg, allow_head=False, ), web.get( "/revocation/registry/{rev_reg_id}/tails-file", get_tails_file, allow_head=False, ), web.put("/revocation/registry/{rev_reg_id}/tails-file", upload_tails_file), web.patch("/revocation/registry/{rev_reg_id}", update_rev_reg), web.post("/revocation/registry/{rev_reg_id}/definition", send_rev_reg_def), web.post("/revocation/registry/{rev_reg_id}/entry", send_rev_reg_entry), web.patch( "/revocation/registry/{rev_reg_id}/set-state", set_rev_reg_state, ), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/connections", connections_list), web.get("/connections/{id}", connections_retrieve), web.post("/connections/create-invitation", connections_create_invitation), # ************Edited Beginning************ # Written for signature and verification # Begin written by Ashlin, Minto, Athul Antony web.post("/connections/create-signing-did", createSigningDid), web.post("/connections/put-key-ledger", putVerificationToLedger), web.post("/connections/sign-transaction", getSignedTransaction), web.post("/connections/verify-transaction", verifySignedTransaction), # Written for signature and verification # End written by Ashlin, Minto, Athul Antony # ************Edited End****************** web.post("/connections/receive-invitation", connections_receive_invitation), web.post("/connections/{id}/accept-invitation", connections_accept_invitation), web.post("/connections/{id}/accept-request", connections_accept_request), web.post( "/connections/{id}/establish-inbound/{ref_id}", connections_establish_inbound, ), web.post("/connections/{id}/remove", connections_remove), ])
def routes(app: web.Application) -> None: app.add_routes([ web.get("/", login), web.get("/login", login), web.post("/logging_in", logging_in), web.post("/login/logging_in", logging_in), ])
def _get_session(self, connector: TCPConnector) -> BaseTestClient: app = Application() app.add_routes([view('/1.0/certificates', CertificatesView)]) server = TestServer(app, ) return BaseTestClient(server, )
async def test_decorator_limiter_called_correctly(self, limit_class): app = Application() routes = RouteTableDef() async def test_view(request): return json_response("bad", status=400) async def test_view2(request): return json_response("bad", status=429) @routes.get("/") @aiopylimit("root_view", (60, 1), limit_reached_view=test_view) async def test(request): return json_response({"test": True}) app.add_routes(routes) request = UserDict() request.app = UserDict() request.app['limit_global_namespace_prefix'] = "aiohttp" request.app['limit_key_func'] = lambda x: "key" request.app['limit_reached_view'] = test_view2 ret = await test(request) limit_class.assert_called_once_with(60, 1) self.assertEqual(ret.status, 400)
async def register(app: web.Application): app.add_routes( [ web.post("/verifiable-services/add", add_service), web.post("/verifiable-services/apply", apply), web.post("/verifiable-services/get-issue-self", get_issue_self,), web.post("/verifiable-services/process-application", process_application,), web.get( "/verifiable-services/request-service-list/{connection_id}", request_services_list, allow_head=False, ), web.get( "/verifiable-services/self-service-list", self_service_list, allow_head=False, ), web.get( "/verifiable-services/DEBUGrequest/{connection_id}", DEBUGrequest_services_list, allow_head=False, ), # web.get( # "/verifiable-services/get-credential-data/{data_dri}", # DEBUGget_credential_data, # allow_head=False, # ), # web.get( # "/verifiable-services/apply-status", # DEBUGapply_status, # allow_head=False, # ), ] )
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/connections/{conn_id}/test-protocolexample", connections_send_ping) ])
async def initialize(appctx): @middleware async def context_injection_middleware(request, handler): if not handler.__annotations__: return await handler(request) params = {} new_session = handler.__annotations__.pop('__new_session', False) for name, t in handler.__annotations__.items(): if t is AppConfig: params[name] = appctx elif t is AuthnSession: if new_session: params[name] = await aiohttp_session.new_session(request) else: params[name] = await aiohttp_session.get_session(request) elif t is Request: continue elif name == 'return': continue else: raise RuntimeError(f"don't know how to inject {name}") return await handler(request, **params) app = Application(middlewares=[ aiohttp_session.session_middleware( appctx.session_store.get()), util.web.json_response_middleware, message_middleware, context_injection_middleware ]) app.add_routes(appctx.routes.get()) app['appctx'] = appctx return app
def init(cfg: Config, app: web.Application) -> None: global host, secret, config config = cfg secret = cfg["bridges.mautrix-facebook.secret"] if secret: host = URL(cfg["bridges.mautrix-facebook.url"]) app.add_routes(routes)
def register_routes(app: web.Application): app.add_routes([ web.get("/echo", echo), web.get("/endpoints", list_endpoints), web.post("/endpoints", add_endpoints), web.delete("/endpoints", delete_endpoints), ])
def add_routes(app: web.Application, handlers: dict) -> None: try: controller_names = handlers.keys() for controller_name in controller_names: controllers = handlers[controller_name] for controller in controllers: handler_name = next(iter(controller.keys())) pkg = import_module(f"controllers.{controller_name}") imported_handler = eval(f"pkg.{handler_name}") path_no_slash = str(controller[handler_name]['paths'][0]) path_trailing_slash = f"{controller[handler_name]['paths'][0]}/" app.add_routes([ web.route(controller[handler_name]["method"], path_no_slash, imported_handler), web.route(controller[handler_name]["method"], path_trailing_slash, imported_handler) ]) app.add_routes([ web.route("GET", "/ping", ping), web.route("GET", "/ping/", ping), web.route("GET", "/metrics", metrics), web.route("GET", "/metrics/", metrics), web.route("*", "/{tail:.*}", error_handler), ]) except: raise
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/issue-credential/mime-types/{credential_id}", attribute_mime_types_get), web.get("/issue-credential/records", credential_exchange_list), web.get("/issue-credential/records/{cred_ex_id}", credential_exchange_retrieve), web.post("/issue-credential/send", credential_exchange_send), web.post("/issue-credential/send-proposal", credential_exchange_send_proposal), web.post("/issue-credential/send-offer", credential_exchange_send_free_offer), web.post("/issue-credential/records/{cred_ex_id}/send-offer", credential_exchange_send_bound_offer), web.post("/issue-credential/records/{cred_ex_id}/send-request", credential_exchange_send_request), web.post("/issue-credential/records/{cred_ex_id}/issue", credential_exchange_issue), web.post("/issue-credential/records/{cred_ex_id}/store", credential_exchange_store), web.post("/issue-credential/records/{cred_ex_id}/problem-report", credential_exchange_problem_report), web.post("/issue-credential/records/{cred_ex_id}/remove", credential_exchange_remove) ])
def init_routes(app_authenticate: web.Application) -> None: app_authenticate.add_routes([ web.view('/login', apis.Login, name='login'), # type: ignore web.view('/refresh-token', apis.RefreshToken, name='refresh-token'), # type: ignore web.view('/logout', apis.Logout, name='logout') # type: ignore ])
def routes(app: web.Application) -> None: app.add_routes([ web.get("/", home), web.get("/{service_name}", service), web.get("/{service_name}/{ex_path}", service), web.post("/{service_name}/{ex_path}", service), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/connections/{conn_id}/start-introduction", introduction_start) ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/credential/{credential_id}", credentials_get, allow_head=False), web.get( "/credential/revoked/{credential_id}", credentials_revoked, allow_head=False, ), web.get( "/credential/mime-types/{credential_id}", credentials_attr_mime_types_get, allow_head=False, ), web.delete("/credential/{credential_id}", credentials_remove), web.get("/credentials", credentials_list, allow_head=False), web.get( "/credential/w3c/{credential_id}", w3c_cred_get, allow_head=False, ), web.delete("/credential/w3c/{credential_id}", w3c_cred_remove), web.post("/credentials/w3c", w3c_creds_list), ])
async def register(app: web.Application): """Register routes.""" app.add_routes( [ web.get("/mediation/requests", list_mediation_requests, allow_head=False), web.get( "/mediation/requests/{mediation_id}", retrieve_mediation_request, allow_head=False, ), web.delete("/mediation/requests/{mediation_id}", delete_mediation_request), web.post( "/mediation/requests/{mediation_id}/grant", mediation_request_grant, ), web.post("/mediation/requests/{mediation_id}/deny", mediation_request_deny), web.post("/mediation/request/{conn_id}", request_mediation), web.get("/mediation/keylists", get_keylist, allow_head=False), web.post( "/mediation/keylists/{mediation_id}/send-keylist-update", send_keylist_update, ), web.post( "/mediation/keylists/{mediation_id}/send-keylist-query", send_keylist_query, ), web.get( "/mediation/default-mediator", get_default_mediator, allow_head=False ), web.put("/mediation/{mediation_id}/default-mediator", set_default_mediator), web.delete("/mediation/default-mediator", clear_default_mediator), ] )
async def register(app: web.Application): """Register routes.""" app.add_routes( [ web.post( "/present-proof/request", request_presentation_endpoint, ), web.post( "/present-proof/present", present_proof_endpoint, ), web.post( "/present-proof/reject", present_proof_reject_endpoint, ), web.post( "/present-proof/acknowledge", acknowledge_proof, ), web.get( "/present-proof/exchange/record", retrieve_credential_exchange_api, allow_head=False, ), ] )
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/presentation_exchange", presentation_exchange_list), web.get("/presentation_exchange/{id}", presentation_exchange_retrieve), web.get( "/presentation_exchange/{id}/credentials", presentation_exchange_credentials_list, ), web.get( "/presentation_exchange/{id}/credentials/{referent}", presentation_exchange_credentials_list, ), web.post( "/presentation_exchange/create_request", presentation_exchange_create_request, ), web.post( "/presentation_exchange/send_request", presentation_exchange_send_request, ), web.post( "/presentation_exchange/{id}/send_presentation", presentation_exchange_send_credential_presentation, ), web.post( "/presentation_exchange/{id}/verify_presentation", presentation_exchange_verify_credential_presentation, ), web.post("/presentation_exchange/{id}/remove", presentation_exchange_remove), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/schemas", schemas_send_schema), web.get("/schemas/created", schemas_created, allow_head=False), web.get("/schemas/{schema_id}", schemas_get_schema, allow_head=False), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/connections", connections_list, allow_head=False), web.get("/connections/{conn_id}", connections_retrieve, allow_head=False), web.post("/connections/create-static", connections_create_static), web.post("/connections/create-invitation", connections_create_invitation), web.post("/connections/receive-invitation", connections_receive_invitation), web.post( "/connections/{conn_id}/accept-invitation", connections_accept_invitation, ), web.post("/connections/{conn_id}/accept-request", connections_accept_request), web.post( "/connections/{conn_id}/establish-inbound/{ref_id}", connections_establish_inbound, ), web.post("/connections/{conn_id}/remove", connections_remove), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/connections/{id}/send-ping", connections_send_ping), web.post("/connections/{id}/send-ping-v2", connections_send_ping_v2), ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.post("/connections/{conn_id}/send-message", connections_send_message) ])
async def register(app: web.Application): """Register routes.""" app.add_routes([ web.get("/discover-features/query", query_features, allow_head=False), web.get("/discover-features/records", query_records, allow_head=False), ])
def init(cfg: Config, app: web.Application) -> None: global host, secret, config config = cfg secret = cfg["bridges.mx-puppet-twitter.secret"] if secret: host = URL(cfg["bridges.mx-puppet-twitter.url"]) app.add_routes(routes)
def setup_routes(app: web.Application) -> None: app.add_routes([web.view('/connect/authorize', AuthorizeView), web.view('/connect/token', TokenView), web.view('/client', ClientListView), web.view('/client/register', RegisterClientView), web.view('/account', AccountListView), web.view('/account/create', CreateAccountView), web.view('/account/{username}', GetAccountView), web.route('*', '/{tail:.*}', catch_all)]) project_root = pathlib.Path(__file__).parent.parent app.add_routes([web.static('/static/', path=project_root / 'static', name='static')])
def setup_routes(app: web.Application) -> None: app.add_routes([web.route('*', '/.well-known/webfinger', negotiate.route)])