def lambda_handler(event, context):
client = event['pathParameters']['id']
#verify if this client belongs from this customer (user)
token = get_token_from_headers(event['headers'])
token_decoded = utils.jwt_decode(token,
ssmutils.get_parameter_store('TOKEN_KEY'))
conn_mysql = connection()
if not verify_client_customer(conn_mysql, token_decoded['inf']['uuid'],
client):
conn_mysql.close()
return response('Cliente invalido!', 400)
#connecting to redis
conn = daoredis.connection(ssmutils.get_parameter_store('REDIS_HOST'))
#remove client from queue
clients = daoredis.remove_client(conn, client)
#add date_out in mysql
update_client(conn_mysql, client)
conn_mysql.close()
return response('ok!', 200)
def lambda_handler(event, context):
queue = event['pathParameters']['id']
#verify if this list belongs to this user
token = get_token_from_headers(event['headers'])
token_decoded = utils.jwt_decode(token,
ssmutils.get_parameter_store('TOKEN_KEY'))
conn = connection()
if not verify_user_queue(conn, token_decoded['inf']['uuid'], queue):
conn.close()
return response('Fila invalida!', 400)
#connecting to redis
conn = daoredis.connection(ssmutils.get_parameter_store('REDIS_HOST'))
#get clients from queue
clients = daoredis.get_all_queue(conn, queue)
#transform string position into integer position, after sort by position
if clients:
list = []
for client in clients:
client["pos"] = int(client["pos"])
list.append(client)
list.sort(key=operator.itemgetter("pos"))
clients = list
return utils.response(clients, 200)
def lambda_handler(event, context):
client = json.loads(event['body'])
token = get_token_from_headers(event['headers'])
#validate payload
#validate name
if 'name' not in client or not client['name']:
return response('Digite o nome!', 400)
#validate maximum qtd caracteres in name
if (len(client['name']) > int(os.environ['MAXIMUM_QTD_NAME'])):
return response('Nome nao pode conter mais que '+os.environ['MAXIMUM_QTD_NAME']+' caracteres!', 400)
#verify if email and telephone are not null together
if 'email' not in client and 'telephone' not in client:
return response('Digite e-mail ou telephone!', 400)
if 'email' in client:
if not valid_email(client['email']):
return response('E-mail invalido!', 400)
if 'telephone' in client:
if (len(client['telephone']) != int(os.environ['MAXIMUM_QTD_TEL'])):
return response('Telefone invalido!', 400)
#validate queue belong to user
token_decoded = utils.jwt_decode(token, ssmutils.get_parameter_store('TOKEN_KEY'))
conn_mysql = connection()
if not verify_user_queue(conn_mysql, token_decoded['inf']['uuid'], client['queue']):
conn_mysql.close()
return response('Fila invalida!', 400)
#generate an uuid for queue client
client['id_queue_client'] = str(uuid.uuid1())
#set date time in
client['date_in'] = str(datetime.now())
#write data into mysql
save_client(conn_mysql, client)
conn_mysql.close()
#add new client in cache position
client = {
'id_client':client['id_queue_client'],
'name':client['name'],
'date':client['date_in'],
'id_queue':client['queue']
}
conn = daoredis.connection(ssmutils.get_parameter_store('REDIS_HOST'))
daoredis.add_client(conn, client)
return response('ok!', 200)
def lambda_handler(event, context):
urlValidacao = 'http://d30b9dqnme0qm0.cloudfront.net/validate/'
customer = json.loads(event['Records'][0]['body'])
#generating uuid
id = str(uuid.uuid1())
print('uuid: ' + id)
#generate token
expiration = 3600 * 24 #one day
token = utils.jwt_encode({'uuid': id},
ssmutils.get_parameter_store('TOKEN_KEY'),
expiration)
customer['token'] = str(token, "utf-8")
#set date
customer['date_register'] = str(datetime.now())
#save-dynamo-db: pre-customer
save_pre_customer(customer, id)
#send-email
email = {
"emailTo":
customer['email'],
"subject":
"Validação da conta",
"html":
customer['name'] +
", bem vindo ao sistema de filas.<br />Clique no link para validar a conta: <a href='"
+ urlValidacao + customer['token'] + "'>Validar</a>"
}
send_to_sqs(email)
def lambda_handler(event, context):
customer_id = ''
#verify if token is in header
if not 'Authorization' in event['headers'] or not event['headers'][
'Authorization']:
return response('Token invalido', 400)
#decode token
try:
token = event['headers']['Authorization'].split()
if not (token[0].lower() == 'bearer' and token[1]):
raise Exception('Unauthorized')
token_decoded = utils.jwt_decode(
token[1], ssmutils.get_parameter_store('TOKEN_KEY'))
customer_id = token_decoded['inf']['email']
except Exception as e:
print(e)
raise Exception('Unauthorized')
#get customer
customer = get_pre_customer(customer_id)
if not customer:
return response('Usuario invalido', 400)
#remove password
customer.pop('password', None)
return utils.response(customer, 200)
def lambda_handler(event, context):
payload = json.loads(event['body'])
if 'token' not in payload or not payload['token']:
return response('Token invalido', 400)
token = payload['token']
#verify token
try:
result = utils.jwt_decode(token,
ssmutils.get_parameter_store('TOKEN_KEY'))
except Exception as e:
#token expired/invalid
print(e)
return response('Token invalido', 400)
else:
customer = get_pre_customer(result['inf']['uuid'])
if not customer:
return response('Token invalido', 400)
customer = customer['precustomer']
print(customer)
#add to customer
save_customer(customer, result['inf']['uuid'])
#remove from pre-customer
delete_pre_customer(result['inf']['uuid'])
return response('Conta validada', 200)
def lambda_handler(event, context):
client = event['pathParameters']['id']
#connecting to redis
conn = daoredis.connection(ssmutils.get_parameter_store('REDIS_HOST'))
#get client
resp = daoredis.get_all(conn, "client:" + client)
if resp:
return utils.response(resp, 200)
else:
return utils.response({"message": "Not Found"}, 404)
def lambda_handler(event, context):
if 'username' not in event['headers'] or not event['headers']['username']:
return response('Unauthorized', 401)
if 'password' not in event['headers'] or not event['headers']['password']:
return response('Unauthorized', 401)
username = event['headers']['username']
password = event['headers']['password']
#get from dynamodb: custmer
customer = get_customer(username)
if not customer:
print('user doesnot exists precustomer neither customer')
return response('Unauthorized', 401)
else:
#if user exists, but password wrong
if customer['password'] != utils.encode_password(password):
return response('Unauthorized', 401)
else:
#generate token
token_expiration = 3600 * 24 #one day expiration
token = str(
utils.jwt_encode(
{
'email': customer['email'],
'uuid': customer['UUID']
}, ssmutils.get_parameter_store('TOKEN_KEY'),
token_expiration), "utf-8")
#print login
log = {
'login-auth': {
'time': str(datetime.now()),
'user': username
}
}
print(log)
#auth ok
return utils.response(
{
"token": token,
"exp": int((time())) + token_expiration,
"type": "Bearer"
}, 200)
def lambda_handler(event, context):
#get body and token (Bearer)
queue = json.loads(event['body'])
token = get_token_from_headers(event['headers'])
#validate name
if 'name' not in queue or not queue['name']:
return response('Digite o nome da fila!', 400)
#validate maximum qtd caracteres in name
if (len(queue['name']) > int(os.environ['MAXIMUM_QTD_NAME'])):
return response(
'Nome nao pode conter mais que ' + os.environ['MAXIMUM_QTD_NAME'] +
' caracteres!', 400)
#validate maximum qtd caracteres in text and end queue
if (len(queue['text_queue']) > int(os.environ['MAXIMUM_QTD_TEXT'])):
return response(
'Texto da fila nao pode conter mais que ' +
os.environ['MAXIMUM_QTD_TEXT'] + ' caracteres!', 400)
if (len(queue['end_queue']) > int(os.environ['MAXIMUM_QTD_TEXT'])):
return response(
'Texto de chamada nao pode conter mais que ' +
os.environ['MAXIMUM_QTD_TEXT'] + ' caracteres!', 400)
#decode jwt and id_user
token_decoded = utils.jwt_decode(token,
ssmutils.get_parameter_store('TOKEN_KEY'))
#setting variables
id_queue = id = str(uuid.uuid1())
name = queue['name']
text_queue = queue['text_queue']
end_queue = queue['end_queue']
id_user = token_decoded['inf']['uuid']
#connection
conn = connection()
sql = "INSERT INTO queue(id_queue, name, text_queue, end_queue, date_register, id_user) VALUES ('" + id_queue + "', '" + name + "', '" + text_queue + "', '" + end_queue + "', NOW(),'" + id_user + "')"
mysqlutils.execute(conn, sql)
conn.close()
return response('ok', 200)
def lambda_handler(event, context):
if not 'authorizationToken' in event or not event['authorizationToken']:
return 'Unauthorized'
try:
token = event['authorizationToken'].split()
if not (token[0].lower() == 'bearer' and token[1]):
raise Exception('Unauthorized')
token_decoded = utils.jwt_decode(
token[1], ssmutils.get_parameter_store('TOKEN_KEY'))
policy = generate_policy(token_decoded['inf']['uuid'], 'Allow',
event['methodArn'])
return policy
except Exception as e:
print(e)
raise Exception('Unauthorized')
def lambda_handler(event, context):
#get customer (user_id) from token
token = get_token_from_headers(event['headers'])
token_decoded = utils.jwt_decode(token,
ssmutils.get_parameter_store('TOKEN_KEY'))
user_id = token_decoded['inf']['uuid']
#set queue_id if exists, to bring an especific queue
queue_id = False
if event['pathParameters'] != None and 'id' in event['pathParameters']:
queue_id = event['pathParameters']['id']
print('queue_id: ' + queue_id)
#get queues
conn_mysql = connection()
queues = get_user_queue(conn_mysql, user_id, queue_id)
#if the request is trying to get an especific queue, but the query not find, so its 404 (not found)
if not queues and queue_id:
return response('Not Found', 404)
else:
return utils.response(queues, 200)
def connection():
return mysqlutils.connection(
ssmutils.get_parameter_store('MYSQL_HOST'),
ssmutils.get_parameter_store('MYSQL_USER'),
ssmutils.get_parameter_store('MYSQL_PASSWORD'),
ssmutils.get_parameter_store('MYSQL_DATABASE'))
