def test_can_have_same_custom_cors_configurations(self, sample_app): custom_cors = CORSConfig(allow_origin='https://foo.example.com', allow_headers=['X-Special-Header'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True) @sample_app.route('/cors', methods=['GET'], cors=custom_cors) def cors(): pass same_custom_cors = CORSConfig(allow_origin='https://foo.example.com', allow_headers=['X-Special-Header'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True) @sample_app.route('/cors', methods=['PUT'], cors=same_custom_cors) def same_cors(): pass try: validate_routes(sample_app.routes) except ValueError: pytest.fail('A ValueError was unexpectedly thrown. Applications ' 'may have multiple view functions that share the same ' 'route and CORS configuration.')
def test_cant_have_differing_cors_configurations(self, sample_app): custom_cors = CORSConfig(allow_origin='https://foo.example.com', allow_headers=['X-Special-Header'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True) @sample_app.route('/cors', methods=['GET'], cors=True) def cors(): pass @sample_app.route('/cors', methods=['PUT'], cors=custom_cors) def different_cors(): pass with pytest.raises(ValueError): validate_routes(sample_app.routes)
from chalice import Chalice, CORSConfig from chalicelib.trie import TrieBase from chalicelib.wordbase import WordBase app = Chalice(app_name='wordbase-helper-backend') cors = CORSConfig() app.debug = True dictionary = TrieBase() @app.route('/', methods=['POST'], cors=cors) def index(): request = app.current_request.json_body wb = WordBase(request['cellsString'], request['markedMap'], dictionary) return wb.get_answers()
from chalice import Chalice, NotFoundError, Response, CORSConfig, AuthResponse, AuthRoute, CognitoUserPoolAuthorizer from basicauth import decode app = Chalice(app_name='todo-app') app.debug = True cognito_authorizer = CognitoUserPoolAuthorizer( 'qa_test', header='Authorization', provider_arns=[ 'arn:aws:cognito-idp:eu-west-1:299416431288:userpool/eu-west-1_YTEukGzRd' ]) cors_config = CORSConfig(allow_origin="*") def current_user(): auth_context = app.current_request.context.get('authorizer', {}) return auth_context.get('claims', {}).get('cognito:username') @app.route('/todo', authorizer=cognito_authorizer, cors=cors_config) def todos(): print("Current user is {}".format(current_user())) user = current_user().capitalize() test = "hallo" return {'test': test, 'user': user}
def test_can_add_preflight_cors(self, sample_app, swagger_gen): @sample_app.route('/cors', methods=['GET', 'POST'], cors=CORSConfig( allow_origin='http://foo.com', allow_headers=['X-ZZ-Top', 'X-Special-Header'], expose_headers=['X-Exposed', 'X-Special'], max_age=600, allow_credentials=True)) def cors_request(): pass doc = swagger_gen.generate_swagger(sample_app) view_config = doc['paths']['/cors'] # We should add an OPTIONS preflight request automatically. assert 'options' in view_config, ( 'Preflight OPTIONS method not added to CORS view') options = view_config['options'] expected_response_params = { 'method.response.header.Access-Control-Allow-Methods': mock.ANY, 'method.response.header.Access-Control-Allow-Headers': ("'Authorization,Content-Type,X-Amz-Date,X-Amz-Security-Token," "X-Api-Key,X-Special-Header,X-ZZ-Top'"), 'method.response.header.Access-Control-Allow-Origin': ("'http://foo.com'"), 'method.response.header.Access-Control-Expose-Headers': ("'X-Exposed,X-Special'"), 'method.response.header.Access-Control-Max-Age': ("'600'"), 'method.response.header.Access-Control-Allow-Credentials': ("'true'"), } assert options == { 'consumes': ['application/json'], 'produces': ['application/json'], 'responses': { '200': { 'description': '200 response', 'schema': { '$ref': '#/definitions/Empty' }, 'headers': { 'Access-Control-Allow-Origin': { 'type': 'string' }, 'Access-Control-Allow-Methods': { 'type': 'string' }, 'Access-Control-Allow-Headers': { 'type': 'string' }, 'Access-Control-Expose-Headers': { 'type': 'string' }, 'Access-Control-Max-Age': { 'type': 'string' }, 'Access-Control-Allow-Credentials': { 'type': 'string' }, } } }, 'x-amazon-apigateway-integration': { 'responses': { 'default': { 'statusCode': '200', 'responseParameters': expected_response_params, } }, 'requestTemplates': { 'application/json': '{"statusCode": 200}' }, 'passthroughBehavior': 'when_no_match', 'type': 'mock', }, } allow_methods = self.get_access_control_methods(view_config) # Typically the header will follow the form of: # "METHOD,METHOD,...OPTIONS" # The individual assertions is needed because there is no guarantee # on the order of these methods in the string because the order is # derived from iterating through a dictionary, which is not ordered # in python 2.7. So instead assert the correct methods are present in # the string. assert 'GET' in allow_methods assert 'POST' in allow_methods assert 'OPTIONS' in allow_methods
es_indexer = None # module level settings used as flags for lazy initialisers in functions search_flow_verified = False # load the cors config cors_config = None cors = None try: with open("chalicelib/cors.json", "r") as f: cors_config = json.load(f) if cors_config.get("AllowAllCORS") == "True": cors = True else: cors = CORSConfig(**cors_config.get("custom")) except FileNotFoundError: pass # using a functools wrapper here as normal python decorators aren't compatible with the call signature of chalice def chalice_function(f): @wraps(f) def wrapper(*args, **kwargs): headers = {'Content-Type': 'text/json'} try: log.debug(f"Function: {f.__name__}") log.debug(f"ARGS: {args}") log.debug(f"KWARGS: {kwargs}") log.debug(f"Query Params: {app.current_request.query_params}") log.debug(f"Raw Body: {app.current_request.raw_body}")
import boto3, json from chalice import Chalice, CORSConfig app = Chalice(app_name='remote-control') cors_config = CORSConfig(allow_origin='*') ec2 = boto3.client('ec2') data = ec2.describe_instances() def get_ec2_instances(): return [insta['Instances'][0]['InstanceId'] for insta in data['Reservations']] def start_instances(instance_id): response = ec2.start_instances( InstanceIds=[instance_id], DryRun=False) return response def stop_instances(instance_id): response = ec2.stop_instances( InstanceIds=[instance_id], Force=True) return response @app.route('/{instance_id}', cors=True) def toggle_instance_status(instance_id): instanceMapping = {insta['Instances'][0]['InstanceId']:insta['Instances'][0]['State']['Name'] \ for insta in data['Reservations']} if instanceMapping[instance_id] == 'running': stop_instances(instance_id) else: print('need to start instance')
from chalice import Chalice, BadRequestError, CORSConfig, Response from robot import run import boto3 from botocore.exceptions import ClientError import io import json import uuid from os import environ import re app = Chalice(app_name='rf-runner') cors_config = CORSConfig(allow_origin=environ.get('FRONTEND_URL'), allow_credentials=True) FRONTEND_URL = environ.get('FRONTEND_URL') RF_REPORTS_BUCKET = environ.get('REPORT_BUCKET') ALLOWED_LIBRARIES = [ 'Builtin', 'String', 'Dialogs', 'DateTime', 'Collections', 'XML', 'RequestsLibrary' ] REPORTS = ['output.xml', 'log.html', 'report.html'] @app.middleware('http') def validation_middleware(event, get_response): libraries = re.findall("Library\s{2,}(.*)", event.raw_body.decode("utf-8")) for library in libraries: if library not in ALLOWED_LIBRARIES: response = {
def test_can_add_preflight_cors(sample_app, swagger_gen): @sample_app.route('/cors', methods=['GET', 'POST'], cors=CORSConfig( allow_origin='http://foo.com', allow_headers=['X-ZZ-Top', 'X-Special-Header'], expose_headers=['X-Exposed', 'X-Special'], max_age=600, allow_credentials=True)) def cors_request(): pass doc = swagger_gen.generate_swagger(sample_app) view_config = doc['paths']['/cors'] # We should add an OPTIONS preflight request automatically. assert 'options' in view_config, ( 'Preflight OPTIONS method not added to CORS view') options = view_config['options'] expected_response_params = { 'method.response.header.Access-Control-Allow-Methods': ("'GET,POST,OPTIONS'"), 'method.response.header.Access-Control-Allow-Headers': ("'Authorization,Content-Type,X-Amz-Date,X-Amz-Security-Token," "X-Api-Key,X-Special-Header,X-ZZ-Top'"), 'method.response.header.Access-Control-Allow-Origin': ("'http://foo.com'"), 'method.response.header.Access-Control-Expose-Headers': ("'X-Exposed,X-Special'"), 'method.response.header.Access-Control-Max-Age': ("'600'"), 'method.response.header.Access-Control-Allow-Credentials': ("'true'"), } assert options == { 'consumes': ['application/json'], 'produces': ['application/json'], 'responses': { '200': { 'description': '200 response', 'schema': { '$ref': '#/definitions/Empty' }, 'headers': { 'Access-Control-Allow-Origin': { 'type': 'string' }, 'Access-Control-Allow-Methods': { 'type': 'string' }, 'Access-Control-Allow-Headers': { 'type': 'string' }, 'Access-Control-Expose-Headers': { 'type': 'string' }, 'Access-Control-Max-Age': { 'type': 'string' }, 'Access-Control-Allow-Credentials': { 'type': 'string' }, } } }, 'x-amazon-apigateway-integration': { 'responses': { 'default': { 'statusCode': '200', 'responseParameters': expected_response_params, } }, 'requestTemplates': { 'application/json': '{"statusCode": 200}' }, 'passthroughBehavior': 'when_no_match', 'type': 'mock', }, }
from pprint import pprint from chalice import Chalice from chalice import NotFoundError from chalice import CORSConfig from chalicelib.db import db_conn, db_query from chalicelib.aws import s3, boto3 from chalicelib.models.doc import Doc from chalicelib.models.issuer import Issuer app = Chalice(app_name='sinfiltrar-input') app.log.setLevel(logging.INFO) app.debug = True cors_config = CORSConfig(allow_origin=os.environ["ALLOW_ORIGIN"], allow_headers=['X-Special-Header'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True) @app.route('/latest', cors=cors_config) def latest(): query = "SELECT * FROM docs ORDER BY issued_at DESC LIMIT 20" result = db_query(query) response = [{ "title": doc['title'], "slug": doc['slug'], "short_text": doc['short_text'], "content": doc['body_plain'], "date": doc['issued_at'].__str__(),
from chalice import CustomAuthorizer, CORSConfig import logging from boto3 import client import os log = logging.getLogger("audit-feedback") invokeLambda = client("lambda", region_name=f"{os.environ['CURRENT_REGION']}") cors_config = CORSConfig(allow_origin='*', max_age=600, expose_headers=['X-Special-Header'], allow_credentials=False) authorizer = CustomAuthorizer( 'MyCustomAuth', header='Authorization', authorizer_uri= (f"arn:aws:apigateway:{os.environ['CURRENT_REGION']}:lambda:path/2015-03-31" "/functions/arn:aws:lambda:us-east-2:886064876783:function:sessions-app-dev-jwt_auth/invocations" )) def get_authorized_session_id(current_request): log.info("current request session_id", current_request.context) return current_request.context['authorizer']['sessionId'] def get_authorized_email(current_request): log.info("current request email", current_request.context) return current_request.context['authorizer']['principalId']
from chalice import BadRequestError from chalice import NotFoundError from chalice import ChaliceViewError app = Chalice(app_name='mygame_app') app.debug = True print('Loading function') dynamodb_client = boto3.client('dynamodb') cors_config = CORSConfig( # allow_origin='http://localhost:63342', # allow_origin='http://mygame.jimhough.com.s3-website-us-east-1.amazonaws.com', allow_origin='http://mygame.jimhough.com', allow_headers=['Access-Control-Allow-Origin', 'X-Special-Header', 'User'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True) # For Authentication: # from http://chalice.readthedocs.io/en/latest/api.html#authorization #authorizer = CognitoUserPoolAuthorizer( # 'MyPool', header='Authorization', # provider_arns=['arn:aws:cognito:...:userpool/name']) #authorizer = CognitoUserPoolAuthorizer( # name='MyPool', # provider_arns=['arn:aws:cognito-idp:us-east-1:1234567890:userpool/us-east-1_SDqT99999'], # header='Authorization' # )
CORSConfig, AuthResponse, AuthRoute, ) from chalice import NotFoundError, BadRequestError # from operationsresearch.prepaid import PrepaidSolver from ortools.linear_solver import pywraplp import os app = Chalice(app_name="solver") # Configure CORS Routes # cors_allow_origin = os.getenv("CORS_ALLOW_ORIGIN", "*") cors_allow_origin = "*" cors_config = CORSConfig(allow_origin=cors_allow_origin) # Configure debug output environment = os.getenv("CHALICE_ENVIRONMENT", "development") if environment == "development": app.debug = True class PrepaidSolver: def __init__(self, tiers: dict, target: float): self.solver = pywraplp.Solver( "TierSolver", pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING ) self.tiers = tiers self.target = target
from chalice import Chalice, CORSConfig, Response from chalicelib.aws_sdk import BotoWrapper from chalicelib.youtube import youtube_cards from chalicelib.instagram import gallery cors_config = CORSConfig( allow_origin='https://fingerstyle.jongwony.com', allow_headers=['Cross-Origin-Resource-Policy'], max_age=3600, ) app = Chalice(app_name='fingerstyle') aws_api = BotoWrapper() instagram_cache_key = 'fingerstyle/instagram/gallery.json' youtube_cache_key = 'fingerstyle/youtube/playlist.json' @app.route('/', cors=cors_config) def index(): return {} @app.route('/instagram', cors=cors_config) def instagram(): return Response( body=aws_api.json_deserialize(instagram_cache_key), headers={'Cross-Origin-Resource-Policy': 'cross-origin'}, ) @app.route('/youtube', cors=cors_config)
import json from chalice import Chalice, CORSConfig from datetime import datetime, timedelta, date, time from chalicelib import data_funcs app = Chalice(app_name='data-dashboard') cors_config = CORSConfig(allow_origin='https://dashboard.transitmatters.org', max_age=3600) def destructure_date(date): date_split = date.split('-') return { 'year': int(date_split[0]), 'month': int(date_split[1]), 'day': int(date_split[2]) } @app.route("/headways/{user_date}", cors=cors_config) def headways_route(user_date): station = app.current_request.query_params.get('station') parsed_date = destructure_date(user_date) return data_funcs.headways( date(year=parsed_date['year'], month=parsed_date['month'], day=parsed_date['day']), {"stop": station}) @app.route("/dwells/{user_date}", cors=cors_config)
from chalice import Chalice, CORSConfig, CognitoUserPoolAuthorizer import boto3 from chalicelib import util app = Chalice(app_name='quickdraw-lambdas') cors_config = CORSConfig(allow_origin='https://quickdraw.ixora.io', ) authorizer = CognitoUserPoolAuthorizer( 'GoogleQuickdraw', header='Authorization', provider_arns=[('arn:aws:cognito-idp:us-east-1:386512717651:' 'userpool/us-east-1_7OESlcisr')]) dynamodb = boto3.resource( 'dynamodb', region_name='us-east-1', ) table = dynamodb.Table('GoogleQuickdraw') @app.route('/drawings/{country}/{category}/{recognized}', cors=cors_config) def get_drawings(country, category, recognized): """return all of the drawings for a country and category the country and category codes join together to form a compound partition key. the database is designed to return all of the sketches in a single partition, making this process more efficient. some filtering can be done for recognized or unrecognized drawings.
import os from chalice import Chalice, CORSConfig from chalicelib import auth, core, task, time_entry, user app = Chalice(app_name='chalicarian') app.api.cors = CORSConfig( allow_origin=os.environ.get('TASKAFARIAN_ALLOWED_ORIGIN')) core.init_app(app) auth.init_app(app) user.init_app(app) task.init_app(app) time_entry.init_app(app)
import json import os import subprocess from chalice import Chalice, Cron, CORSConfig, ConflictError, Response from datetime import date, timedelta from chalicelib import data_funcs, aggregation, s3_alerts, secrets app = Chalice(app_name="data-dashboard") # will run on localhost if TM_FRONTEND_HOST is not set in env TM_FRONTEND_HOST = os.environ.get("TM_FRONTEND_HOST", "localhost") cors_config = CORSConfig(allow_origin=f"https://{TM_FRONTEND_HOST}", max_age=3600) # Every day at 10am UTC: store alerts from the past # It's called yesterday for now but it's really two days ago!! @app.schedule(Cron(0, 10, '*', '*', '?', '*')) def store_two_days_ago_alerts(event): # Only do this on the main site if TM_FRONTEND_HOST == "dashboard.transitmatters.org": two_days_ago = date.today() - timedelta(days=2) s3_alerts.store_alerts(two_days_ago) def parse_user_date(user_date): date_split = user_date.split("-") [year, month, day] = [int(x) for x in date_split[0:3]] return date(year=year, month=month, day=day)
def lambda_login(event): body = event.json_body login_res = login(body["username"], body["password"]) # Clear out the password from the dict, to avoid accidentally logging it body["password"] = "" if IS_LOCAL: cookie = f"grapl_jwt={login_res}; HttpOnly" else: cookie = f"grapl_jwt={login_res}; Domain=.amazonaws.com; secure; HttpOnly; SameSite=None" if login_res: return cookie cors_config = CORSConfig( allow_origin=ORIGIN_OVERRIDE or ORIGIN, allow_credentials="true", ) def requires_auth(path): if not IS_LOCAL: path = "/{proxy+}" + path def route_wrapper(route_fn): @app.route(path, methods=["OPTIONS", "POST"]) def inner_route(): if app.current_request.method == "OPTIONS": return respond(None, {}) if not check_jwt(app.current_request.headers): LOGGER.warn("not logged in")
from chalice import Chalice, CORSConfig import boto3 import uuid from chalicelib import utils from secrets import token_urlsafe import time import bcrypt from dynamodb_json import json_util from urllib.parse import urlparse, parse_qs app = Chalice(app_name='file-hosting-apis') cors_config = CORSConfig( allow_origin='*', allow_headers=['Content-Type', 'Authorization', 'X-Amz-Date', 'X-Api-Key', 'X-Amz-Security-Token'], max_age=600, allow_credentials=True ) S3 = boto3.client('s3') DYNAMODB = boto3.client('dynamodb') BUCKET_NAME = 'file-hosting-app' TABLE_NAME = 'file-hosting-app' @app.route('/signed-url-upload/{key}', methods=['GET'], cors=cors_config) def upload_url(key): key = token_urlsafe(32) + key
import smtplib from chalice import Chalice, CORSConfig from chalicelib.tools import send_email, format_profile, format_slider_results, \ format_feedback, format_contact from chalicelib.utils import TEST_MESSAGE app = Chalice(app_name='lambda_survey') smtp_server = smtplib.SMTP() cors_config = CORSConfig( allow_origin="*", allow_headers=["X-Special-Header", "X-Requested-With"], max_age=600, expose_headers=["X-Special-Header"], allow_credentials=True) @app.route('/', cors=cors_config, methods=['GET']) def index(): return {'message': 'Survey notification service online'} @app.route('/notify', cors=cors_config, methods=['POST']) def post_survey(): body = app.current_request.json_body print(body) message = format_profile(body['profile']) + format_slider_results(body['results']) \ + format_feedback(body['feedback']) + format_contact(body['contact']) return send_email(smtp_server, message) @app.route('/test', cors=cors_config, methods=['POST'])
from chalice import Chalice, CORSConfig import re from datetime import datetime from requests_toolbelt.multipart import decoder from fitparse import FitFile from pprint import pprint app = Chalice(app_name='fit-convert') app.debug = True app.api.binary_types = ['multipart/form-data'] cors_config = CORSConfig(allow_origin='http://fit-converter.com', ) def semicircles_to_degrees(semicircle): # 2147483648 = 2^31 return float(semicircle) * (180.0 / 2147483648.0) def string_to_datetime(txt): # 2018-03-01 02:43:52 return datetime.strptime(txt, '%Y-%m-%d %H:%M:%S') def datetime_to_string(dt): # 2018-03-01T05:04:39.000Z return dt.isoformat() + ".000Z"
def sample_app(): demo = app.Chalice('demo-app') demo.debug = True @demo.route('/index', methods=['GET']) def index(): return {'hello': 'world'} @demo.route('/names/{name}', methods=['GET']) def name(name): return {'provided-name': name} @demo.route('/put', methods=['PUT']) def put(): return {'body': demo.current_request.json_body} @demo.route('/cors', methods=['GET', 'PUT'], cors=True) def cors(): return {'cors': True} @demo.route('/custom_cors', methods=['GET', 'PUT'], cors=CORSConfig( allow_origin='https://foo.bar', allow_headers=['Header-A', 'Header-B'], expose_headers=['Header-A', 'Header-B'], max_age=600, allow_credentials=True )) def custom_cors(): return {'cors': True} @demo.route('/options', methods=['OPTIONS']) def options(): return {'options': True} @demo.route('/delete', methods=['DELETE']) def delete(): return {'delete': True} @demo.route('/patch', methods=['PATCH']) def patch(): return {'patch': True} @demo.route('/badrequest') def badrequest(): raise BadRequestError('bad-request') @demo.route('/decimals') def decimals(): return decimal.Decimal('100') @demo.route('/query-string') def query_string(): return demo.current_request.query_params @demo.route('/custom-response') def custom_response(): return Response(body='text', status_code=200, headers={'Content-Type': 'text/plain'}) @demo.route('/binary', methods=['POST'], content_types=['application/octet-stream']) def binary_round_trip(): return Response(body=demo.current_request.raw_body, status_code=200, headers={'Content-Type': 'application/octet-stream'}) return demo
def invalidate_cache(object): client = boto3.client('cloudfront') response = client.create_invalidation( DistributionId=os.environ['PROFILE_DISTRIBUTION_NAME'], InvalidationBatch={ 'Paths': { 'Quantity': 2, 'Items': [f'/{object}', f'/{object}.html'], }, 'CallerReference': str(time()).replace(".", "") }) app = Chalice(app_name='form-service') app.api.cors = CORSConfig(allow_origin="https://uandi.cc") def write_to_cdn(pid, file): client = boto3.client('s3') client.put_object(Body=file, Bucket=os.environ['PROFILE_BUCKET_NAME'], Key=f"{pid}.html", ContentType='text/html') client.put_object(Body=file, Bucket=os.environ['PROFILE_BUCKET_NAME'], Key=f"{pid}", ContentType='text/html') invalidate_cache(pid)
from chalice import Chalice from datetime import datetime import smtplib from chalice import CORSConfig cors_config = CORSConfig( allow_origin='https://foo.example.com', allow_headers=['X-Special-Header'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True ) # APP_EMAIL = '*****@*****.**' # DEFUALT_RESPONSE='Exception sent' app = Chalice(app_name='teamsite-chalice') @app.route('/') def index(): return {'hello': 'world'} @app.route('/test/{form}', methods=['POST'], cors=cors_config) def test(form): return {'name: ':form.name} @app.route('/sendex', methods=['POST']) def sendexception(agent='Bob', supervisor="Tyler"): gmail_user = '******'
############## Chalice CONFIG ########## app = Chalice(app_name='mybooks') app.debug = True app.log.setLevel(logging.DEBUG) authorizer = CognitoUserPoolAuthorizer( config.COGNITO_USER_POOL_NAME, provider_arns=[config.COGNITO_USER_POOL_ARN]) CORS_CONFIG = CORSConfig(allow_origin="*", allow_headers=[ 'Content-Type', 'X-Amz-Date', 'Authorization', 'X-Api-Key', 'X-Amz-Security-Token' ], max_age=600, expose_headers=[ 'Content-Type', 'X-Amz-Date', 'Authorization', 'X-Api-Key', 'X-Amz-Security-Token' ], allow_credentials=True) ######################################## @app.route('/docs', methods=['GET'], authorizer=authorizer, cors=CORS_CONFIG) def show_documents(): """ Shows all available documents for the current authorized users :return: an array of document objects or an ampty array if not documents are available
from chalice import Chalice, CognitoUserPoolAuthorizer, CORSConfig, NotFoundError from os import getenv from fdbk.utils import create_db_connection from fdbk.server import ServerHandlers app = Chalice(app_name='fdbk-lambda') authorizer = CognitoUserPoolAuthorizer('FdbkPool', provider_arns=[getenv('USER_POOL_ARN')]) cors_config = CORSConfig( allow_origin=getenv('CLIENT_URL'), allow_credentials=True, ) db_connection = create_db_connection('fdbk_dynamodb_plugin', []) handlers = ServerHandlers(db_connection) @app.route('/overview', authorizer=authorizer, cors=cors_config, methods=['GET']) def overview(): data, code = handlers.get_overview( query_args=app.current_request.query_params) if code == 404: raise NotFoundError(data.get('error')) return data
@app.route('/json-only', content_types=['application/json']) def json_only(): return {'success': True} @app.route('/cors', methods=['GET', 'POST', 'PUT'], cors=True) def supports_cors(): # It doesn't really matter what we return here because # we'll be checking the response headers to verify CORS support. return {'cors': True} @app.route('/custom_cors', methods=['GET', 'POST', 'PUT'], cors=CORSConfig( allow_origin='https://foo.example.com', allow_headers=['X-Special-Header'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True)) def supports_custom_cors(): return {'cors': True} @app.route('/todict', methods=['GET']) def todict(): return app.current_request.to_dict() @app.route('/multifile') def multifile(): from chalicelib import MESSAGE return {"message": MESSAGE}
import uuid import boto3 from boto3.dynamodb.conditions import Key, Attr from chalice import Chalice from chalice import CORSConfig from chalice import Response app = Chalice(app_name='assignment_newsbytes') cors_config = CORSConfig(allow_origin='*', allow_headers=['X-Special-Header', 'Authorization'], max_age=600, expose_headers=['X-Special-Header'], allow_credentials=True) SECRET_KEY = "4f58135e-2af4-4c48-8d70-9fdbba9b7f26" # Generated using uuid dynamodb = boto3.resource('dynamodb') hashedUrlTable = dynamodb.Table('hashedUrlTable') def make_response(status, data_type, msg, data, code): response = { 'status': status, 'data_type': data_type, 'message': msg, "data": data, 'code': code } return response
def get_wallet_key_header(): wallet_key = app.current_request.headers.get('wallet_key', None) if not wallet_key: raise BadRequestError('No wallet_key provided') return wallet_key app = Chalice(app_name='contract-sv') ORIGIN_URL = os.environ.get('ORIGIN_URL', 'http://*****:*****@app.route('/', cors=cors_config) def index(): return {'hello': 'world', 'origin': ORIGIN_URL} @app.route('/documents', cors=cors_config) def get_docs(): wallet_key = get_wallet_key_header() return doc_repo.fetch_documents(wallet_key) @app.route('/document/history/{document_name}', cors=cors_config) def get_doc_history(document_name):