def received_postback(event):
# the FB ID of the person sending the message
sender_id = event["sender"]["id"]
# recipient_id = event["recipient"]["id"] # page's facebook ID
payload = event["postback"]["payload"]
bot.send_action(sender_id, "mark_seen")
if payload == "start": # Initial welcome message for first-time users
bot.send_text_message(
sender_id, "Hello, we're going to make a 10Xer out of you!"
)
bot.send_image_url(sender_id, "https://i.imgur.com/D4JtitY.png")
db = PgInstance(PSQL_LOGIN_CMD, sender_id)
err = db.Connect()
if err == None:
err = db.Delete_user()
checklist_msg = dialog.get_checklist(db)
bot.send_text_quick_replies(
sender_id,
"To get started, we're going to need the following information:\n" + checklist_msg, quick_replies_list)
db.Disconnect()
else:
print(err)
bot.send_text_quick_replies(
sender_id, "Error connecting to db", quick_replies_list) # replace this eventually
return
else: # should never happen, should add logging for these cases
bot.send_text_quick_replies(
sender_id, "Invalid payload", quick_replies_list)
print("Invalid payload: " + payload)
def login():
db = PgInstance()
err = db.connect()
if err is not None:
print(err)
return jsonify({"error": "could not connect to database"}), 500
customer = db.get_customer_by_email(request.json["email"])
if customer == None:
db.disconnect()
return jsonify({"error": "incorrect credentials"}), 403
email = getattr(customer, "email")
password_hash = getattr(customer, "password")
correctPassword = verify_password(request.json["password"], password_hash)
role = db.get_role(email)
db.disconnect()
if role == None:
print(err)
return jsonify({"error": "incorrect credentials"}), 403
if correctPassword:
return jsonify({
"token":
"Bearer " + create_access_token(
identity=[email, role],
expires_delta=datetime.timedelta(minutes=jwt_lifespan_minutes))
}), 200
return jsonify({"error": "incorrect credentials"}), 403
def test_add_diner(client, body, error_msg, status):
print(f"*** Inside test_add_diner ***")
db = PgInstance()
err = db.connect()
assert err == None
client = app.test_client() # Redefine to get new config
url = '/api/signup/diner'
# test if existing email already exists in customer table by pre-inserting diner
if body["email"] == "*****@*****.**":
client.post(url, data=json.dumps(body), headers=headers)
res = client.post(url, data=json.dumps(body), headers=headers)
if res.json == None:
return
if "error" in res.json:
assert res.json["error"] == error_msg
else:
assert "success" in res.json
diner = db.get_diner_by_email(body["email"])
assert body["name"] == getattr(diner, 'name')
assert res.status_code == status
assert res.content_type == mimetype
db.disconnect()
def sign_up_customer():
# Create customer
errors = {}
# email sanitization
if not validate_email(request.json["email"]): # , verify=True):
errors["email"] = "must be valid"
# name sanitization
name = request.json["name"]
if len(name) < 1 or len(name) > 72:
errors["name"] = "must be between 1 and 72 characters"
# phone sanitization
phone = request.json["phone"]
if not phonenumbers.is_valid_number(
phonenumbers.parse("+1" + str(phone), None)):
errors["phone"] = "must be valid"
if len(errors) > 0:
return jsonify(errors), 400
db = PgInstance()
err = db.connect()
if err != None:
print(err)
return jsonify({"error": "could not connect to database"}), 500
err = db.create_customer(
request.json["email"].lower(), request.json["name"], [phone], False
) # by default single phone #, only restaurants should have multiple
db.disconnect()
if err != None:
return {"error": err}, 401
return get_otp(request.json["email"])
def sign_up_restaurant():
restaurant_name, address, name, email, phone = \
(request.json[field] for field in ('restaurantName', 'restaurantAddress', 'name', 'email', 'phone'))
validation_errors = []
if len(restaurant_name) < 1 or len(restaurant_name) > 72:
validation_errors.append(
"Restaurant Name must be between 1 and 72 characters")
# better address validation?
if len(name) < 1 or len(name) > 72:
validation_errors.append("Must be a valid US address")
if len(name) < 1 or len(name) > 72:
validation_errors.append("Name must be between 1 and 72 characters")
if not validate_email(email):
validation_errors.append("Invalid Email")
if not phonenumbers.is_valid_number(
phonenumbers.parse("+1" + str(phone), None)):
validation_errors.append("Invalid phone number")
if len(validation_errors) > 0:
err = " | ".join(validation_errors)
return jsonify({"error": err, "errorMessage": err}), 400
db = PgInstance()
err = db.connect()
if err != None:
print(
"ERROR: could not connect to database trying to sign up restaurant:\n",
err)
return jsonify({"error": err, "errorMessage": contact_open_meal}), 500
# create Customer
err = db.create_customer(email.lower(), name, [phone],
hash_password("password"), False)
err_source = "customer"
if not err:
# create Restaurant
err = db.create_restaurant(email, address, restaurant_name)
err_source = "restaurant"
db.disconnect()
if not err:
return jsonify({
"token":
"Bearer " + create_access_token(
identity=[email, "Business"],
expires_delta=datetime.timedelta(minutes=jwt_lifespan_minutes))
}), 201
else:
return jsonify({
"error": err + " (" + err_source + " table)",
"errorMessage": err
}), 400
def sign_up_diner():
name, email, phone, password, image_url = \
(request.json[field] for field in ('name', 'email', 'phone', 'password', 'imageURL'))
# validate data
# (already done on front end but 2nd level of safety here in case FE/BE mismatch)
validation_errors = []
if not validate_email(email): # , verify=True):
validation_errors.append("Invalid Email")
if len(name) < 1 or len(name) > 72:
validation_errors.append("Name must be between 1 and 72 characters")
if not phonenumbers.is_valid_number(
phonenumbers.parse("+1" + str(phone), None)):
validation_errors.append("Invalid phone number")
if validate_password(password) != None:
validation_errors.append("Invalid password")
if not image_url:
validation_errors.append("No image provided")
if len(validation_errors) > 0:
err = " | ".join(validation_errors)
return jsonify({"error": err, "errorMessage": err}), 400
db = PgInstance()
err = db.connect()
if err != None:
print(
"ERROR: could not connect to database trying to sign up diner:\n",
err)
return jsonify({"error": err, "errorMessage": contact_open_meal}), 500
# create Customer
err = db.create_customer(
email.lower(), name, [phone], hash_password(password)
) # by default single phone #, only restaurants should have multiple
err_source = "customer"
if not err:
# create Recipient
err = status = db.create_recipient(email, image_url)
err_source = "recipient"
db.disconnect()
if not err:
return jsonify({"success": "Diner successfully created"}), 201
#return jsonify({"token": "Bearer " + create_access_token(identity=[email, "Recipient"], expires_delta=datetime.timedelta(minutes=jwt_lifespan_minutes))}), 201
else:
return jsonify({
"error": f"{err} ({err_source} table)",
"errorMessage": err
}), 400
def get_otp(email, resetPassword=False):
otp, expiration = generate_otp()
# Create OTP
db = PgInstance()
err = db.connect()
if err is not None:
print(err)
return jsonify({"error": "could not connect to database"}), 500
db.save_verification_code(email, otp, expiration)
db.disconnect()
# Send the email
title = "Welcome to OpenMeal!"
if resetPassword:
title = "OpenMeal: Reset Password"
mail_sent = send_email(email, title, "Your one-time password is: " + otp)
if mail_sent is not None:
return jsonify(mail_sent), 535
return jsonify({"general": "otp email sent"}), 201
def received_text(event):
# the FB ID of the person sending the message
sender_id = event["sender"]["id"]
bot.send_action(sender_id, "mark_seen")
# Attempt to get text
try:
text = event["message"]["text"]
except:
bot.send_text_quick_replies(
sender_id, "I didn't quite understand.", quick_replies_list)
return
# Attempt to get payload
payload = None
try:
payload = event["message"]["quick_reply"]["payload"]
except:
pass
# If payload exists and is a quick reply
if payload != None and payload.split("_")[0] == "qr":
if payload.split("_")[1] == "set": # set commands require a text follow-up
PREVIOUS_PAYLOAD_DICT[sender_id] = payload
selected_info = payload.split("_")[2]
inquiry_msg = dialog.get_inquiry_msg(selected_info)
bot.send_text_quick_replies(
sender_id, inquiry_msg, quick_replies_list)
else:
# Connect to db
db = PgInstance(PSQL_LOGIN_CMD, sender_id)
err = db.Connect()
if err != None:
print(err)
bot.send_text_quick_replies(
sender_id, "Error connecting to db", quick_replies_list) # replace this eventually
return
db_response, user_err_msg, err = dialog.handle_quick_replies(
payload, text, db, bot.get_user_info(sender_id, ["timezone"]))
# Check for err from SQL query
if err != None:
print(err)
bot.send_text_quick_replies(
sender_id, "Error with sql query", quick_replies_list) # replace this eventually
return
# Disconnect from db
err = db.Disconnect()
if err != None:
print(err)
bot.send_text_quick_replies(
sender_id, "Error disconnecting from db", quick_replies_list) # replace this eventually
return
# Send db query response to user
if db_response != "":
bot.send_text_quick_replies(
sender_id, db_response, quick_replies_list)
elif sender_id in PREVIOUS_PAYLOAD_DICT:
previous_payload = PREVIOUS_PAYLOAD_DICT[sender_id]
del PREVIOUS_PAYLOAD_DICT[sender_id]
# Connect to db
db = PgInstance(PSQL_LOGIN_CMD, sender_id)
err = db.Connect()
if err != None: # Successful connection
print(err)
bot.send_text_quick_replies(
sender_id, "Error connecting to db", quick_replies_list) # replace this eventually
return
db_response, user_err_msg, err = dialog.handle_quick_replies(
previous_payload, text, db, bot.get_user_info(sender_id, ["timezone"]))
# Check for user_err_msg
if user_err_msg != None:
bot.send_text_quick_replies(
sender_id, user_err_msg, quick_replies_list)
# Check for err from SQL query
if err != None:
print(err)
bot.send_text_quick_replies(
sender_id, "Error with sql query", quick_replies_list) # replace this eventually
return
# Send db query response to user
if db_response != "":
bot.send_text_quick_replies(
sender_id, db_response, quick_replies_list)
# Send checklist message
checklist_msg = dialog.get_checklist(db)
bot.send_text_quick_replies(
sender_id, "Checklist status:\n" + checklist_msg, quick_replies_list)
# Disconnect from db
err = db.Disconnect()
if err != None:
print(err)
bot.send_text_quick_replies(
sender_id, "Error disconnecting from db", quick_replies_list) # replace this eventually
return
else:
bot.send_text_quick_replies(
sender_id, "Please use one of the options below to communicate with me!", quick_replies_list)
def sign_up_donor():
db = PgInstance()
err = db.connect()
if err is not None:
print(err)
return jsonify({"error": "could not connect to database"}), 500
# verify email
otp_record = db.get_otp_email(request.json["otp"])
if otp_record == None:
db.disconnect()
return jsonify({"error": "invalid email"}), 400
email = getattr(otp_record, "email")
print(otp_record)
# verify otp
valid_otp = db.verify_otp(email, request.json["otp"])
if not valid_otp:
db.disconnect()
return jsonify({"error": "invalid otp"}), 400
# create recipient
print(request.json)
err = db.create_recipient(email)
if err != None:
db.disconnect()
return jsonify({"error": err}), 400
db.disconnect()
return jsonify({
"token":
"Bearer " + create_access_token(
identity=[email, "Donor"],
expires_delta=datetime.timedelta(minutes=jwt_lifespan_minutes))
}), 201
def sign_up_recipient():
db = PgInstance()
err = db.connect()
if err is not None:
print(err)
return jsonify({
"error": "could not connect to database",
"errorMessage:": contact_open_meal
}), 500
# # verify email
# otp_record = db.get_otp_email(request.json["otp"])
# if otp_record == None:
# db.disconnect()
# return jsonify({"error": "invalid email"}), 400
# email = getattr(otp_record, "email")
# print(otp_record)
# verify otp
email = request.json["email"]
valid_otp = db.verify_otp(request.json["email"], request.json["otp"])
if not valid_otp:
db.disconnect()
return jsonify({
"error":
"invalid otp",
"errorMessage":
"Incorrect one-time password. Please try again."
}), 400
# create recipient
print(request.json)
err = db.create_recipient(email)
if err != None:
db.disconnect()
return jsonify({"error": err, "errorMessage": contact_open_meal}), 400
db.disconnect()
return jsonify({
"token":
"Bearer " + create_access_token(
identity=[email, "Recipient"],
expires_delta=datetime.timedelta(minutes=jwt_lifespan_minutes))
}), 201