def validate_email(token):
try:
token = token.replace("_", "/")
token = db_session.query(models.ValidationToken).filter(models.ValidationToken.token == token).one_or_none()
if token is None:
return False
except SQLAlchemyError as e:
print(e)
print("token not found")
return False
try:
if datetime.now() > token.created_at:
print("it has been over a day, try again")
return False
else:
user_id = token.user_id
user_query = db_session.query(models.User).filter(models.User.id == user_id).one_or_none()
user_query.email_validated = True
db_session.commit()
print("email validated")
return True
except SQLAlchemyError as e:
print(e)
print('problem retrieving user')
return False
def get_data_tree_json(self):
# Load datasets owned by current user
my_datasets = db_session.query(Dataset).filter(
Dataset.user_id == self.id)
data_tree = []
for dataset in my_datasets:
data_tree.append({
'label': dataset.name,
'id': dataset.id,
'children': []
})
# Load tasks owned by current dataset (fetch only their id & label in order to save time)
my_tasks = db_session.query(DatasetTask)\
.filter(DatasetTask.dataset_id == dataset.id)\
.options(load_only('name', 'id'))
for task in my_tasks:
data_tree[len(data_tree) - 1]['children'].append({
'label':
task.name,
'id':
task.id
})
return json.dumps(data_tree)
def cli(ctx, locality):
"""Data visualization of all covid-19 va data."""
ctx.log("Total Covid-19 Virginia Cases...")
if locality:
values = db_session.query(
func.sum(VaCovid.total_cases).label("total_cases")
).filter(VaCovid.locality == locality.upper())
for _res in values.all():
if _res[0] is None:
print(
"No available Virginia Covid-19 case data for {}".format(
locality.capitalize()
)
)
else:
print(
"Total cases for {} as of today are: {}".format(
locality.capitalize(), _res[0]
)
)
else:
values = db_session.query(func.sum(VaCovid.total_cases).label("total_cases"))
for _res in values.all():
print("Total cases as of today are: {}".format(_res[0]))
def place_order():
user_id = flask_jwt_extended.get_jwt_identity()
cart_list = db_session.query(
models.Cart).filter(models.Cart.user_id == user_id).all()
try:
address_id = request.form["address"]
created_at = datetime.datetime.now()
for cart in cart_list:
create_order = models.Orders(
order_id=address_id,
user_id=user_id,
product_id=cart.product_id,
status='pending',
created_at=created_at,
)
db_session.add(create_order)
db_session.flush()
except Exception as e:
print(e)
return redirect(url_for("view.cart"))
try:
db_session.commit()
except Exception as e:
print(e)
db_session.rollback()
return redirect(url_for("view.cart"))
return redirect(url_for("view.orders"))
def cli(ctx):
"""Data visualization of all covid-19 va data."""
ctx.log("Listing Covid-19 Virginia Cases...")
values = db_session.query(VaCovid).order_by(desc("total_cases"))
results = [[
value.report_date.upper(),
value.fips.upper(),
value.locality.upper(),
value.health_district.upper(),
value.total_cases,
] for value in values]
ctx.log("VA Covid-19 Cases:")
print(
tabulate(
results,
headers=[
"Report Data",
"FIPS",
"Locality",
"Health District",
"Total Cases",
],
))
def orders():
user_id = flask_jwt_extended.get_jwt_identity()
cart_list = db_session.query(
models.Orders, models.Product, models.ProductImages).filter(
models.Orders.product_id ==
models.Product.id).filter(models.Orders.user_id == user_id).filter(
models.ProductImages.product_id == models.Orders.product_id,
models.ProductImages.profile_img == True).all()
return render_template("orders.html", cart_list=cart_list)
def cart_remove(cart_id):
try:
cart_item = db_session.query(
models.Cart).filter(models.Cart.id == cart_id).one_or_none()
db_session.delete(cart_item)
db_session.commit()
except Exception as e:
print(e)
return redirect(url_for("view.cart"))
def reset_pass(the_token):
try:
res, id = verification_mail.update_password(the_token)
if res and id:
user = (db_session.query(
models.User).filter(models.User.id == id).one_or_none())
return render_template("reset-password.html", email=user.email)
except Exception as e:
print(e)
return render_template("forget-password.html")
def products():
try:
user_id = flask_jwt_extended.get_jwt_identity()
is_login = session.get("logged_in")
products = db_session.query(
models.Product, models.ProductImages).filter(
models.Product.id == models.ProductImages.product_id,
models.ProductImages.profile_img == True).all()
categories = db_session.query(models.Category).all()
cart_count = db_session.query(models.Cart, models.Product).filter(
models.Cart.product_id == models.Product.id).filter(
models.Cart.user_id == user_id).count()
except Exception as e:
print(e)
return render_template("shop-right-sidebar.html",
is_login=is_login,
products=products,
categories=categories,
cart_count=cart_count)
def product(id):
try:
user_id = flask_jwt_extended.get_jwt_identity()
product = db_session.query(
models.Product).filter(models.Product.id == id).one_or_none()
product_images = db_session.query(models.ProductImages).filter(
models.ProductImages.product_id == id).all()
category_name = db_session.query(models.Category.name).filter(
models.Category.id == product.category_id).one_or_none()
cart_count = db_session.query(models.Cart, models.Product).filter(
models.Cart.product_id == models.Product.id).filter(
models.Cart.user_id == user_id).count()
except Exception as e:
print(e)
return render_template("shop-single-product.html",
product=product,
product_images=product_images,
category_name=category_name[0],
cart_count=cart_count)
def load_data(self):
# Get parent dataset name
dataset = db_session.query(Dataset).filter(
Dataset.id == self.dataset_id).one()
# Construct path to images based on config file - e.g. 'static/images/d1/t1/'
folder_path_visuals = path.join(
'static', 'images', config['DATASET_FOLDER'],
config['DATASET_PREFIX'] + str(dataset.id),
config['TASK_PREFIX'] + str(self.id), '')
# Fill the data holding objects
self.load_visuals(folder_path_visuals)
def cart():
user_id = flask_jwt_extended.get_jwt_identity()
cart_list = db_session.query(
models.Cart, models.Product, models.ProductImages).filter(
models.Cart.product_id == models.Product.id).filter(
models.Cart.user_id == user_id).filter(
models.ProductImages.product_id == models.Cart.product_id,
models.ProductImages.profile_img == True).all()
address = db_session.query(models.UserAddress).filter(
models.UserAddress.user_id == user_id).all()
total = 0
for cart in cart_list:
total += int(cart[1].price)
print(total)
data = []
for add in address:
data.append({
"address_id": add.id,
"address_name": add.address_name,
"first_name": add.first_name,
"last_name": add.last_name,
"email": add.email,
"phone_number": add.phone_number,
"address": add.address,
"country": add.country,
"state": add.state,
"city": add.city,
"postal_code": add.postal_code
})
data = json.dumps(data)
return render_template("cart.html",
cart_list=cart_list,
cart_count=len(cart_list),
total=total,
address=address,
data=data)
def send_push_message(token, message, extra=None):
"""
sends push notification
requires:
token
message
"""
response = None
try:
response = PushClient().publish(
PushMessage(to=token, body=message, data=extra))
except PushServerError as error:
# Encountered some likely formatting/validation error.
error_logger.exception(f"""
error: {error}
token: {token}
message: {message}
extra: {extra}
errors: {error.errors}
response_data: {error.response_data}
""")
except (requests.exceptions.ConnectionError,
requests.exceptions.HTTPError) as error:
# Encountered some Connection or HTTP error - retry a few times in
# case it is transient.
error_logger.exception('Connection error: Retrying')
response = PushClient().publish(
PushMessage(to=token, body=message, data=extra))
try:
# We got a response back, but we don't know whether it's an error yet.
# This call raises errors so we can handle them with normal exception
# flows.
if response is not None:
response.validate_response()
except DeviceNotRegisteredError:
# Get rid of the token
user = db_session.query(
models.User).filter(models.User.expo_push_token == token).one()
user.expo_push_token = ''
db_session.commit()
except PushResponseError as error:
# Encountered some other per-notification error.
error_logger.exception(f"""
token: {token}
message: {message}
extra: {extra}
push_response: {error.push_response._asdict()}
""")
def reset_password():
try:
email = request.form["email"]
password_hash = request.form["password"]
user = (db_session.query(
models.User).filter(models.User.email == email).one_or_none())
user.password_hash = ph.hash(password_hash)
except Exception as e:
print(e)
return {"message": "Failed to get user"}
try:
db_session.commit()
session["logged_in"] = True
return redirect(url_for("view.products"))
except Exception as e:
print(e)
db_session.rollback()
return redirect(url_for("view.user"))
def forgot_password():
try:
email = request.form["email"]
user = (db_session.query(
models.User).filter(models.User.email == email).one_or_none())
if user:
res = verification_mail.send_mail(user.id,
user.name,
user.email,
email_type="reset-user")
if not res:
return render_template(
"index.html",
message=
"invalid email or server failed to send verification mail")
else:
return redirect(url_for("view.register"))
except Exception as e:
print(e)
return redirect(url_for("view.forgot_pass"))
return redirect(url_for("view.user"))
def update_password(token):
try:
token = token.replace("_", "/")
token = db_session.query(models.ValidationToken).filter(models.ValidationToken.token == token).one_or_none()
if token is None:
return False, None
except SQLAlchemyError as e:
print(e)
print("token not found")
return False, None
try:
if datetime.now() > token.created_at:
print("it has been over a day, try again")
return False, None
else:
print("valid token")
return True, token.user_id
except SQLAlchemyError as e:
print(e)
print('problem retrieving user')
return False, None
def edit_delivery_address():
address_id = request.form["address_id"]
address = db_session.query(models.UserAddress).filter(
models.UserAddress.id == int(address_id)).one_or_none()
address.address_name = request.form["address_name"]
address.first_name = request.form["first_name"]
address.last_name = request.form["last_name"]
address.email = request.form["email"]
address.phone_number = request.form["phone_number"]
address.address = request.form["address"]
address.country = request.form["country"]
address.state = request.form["state"]
address.city = request.form["city"]
address.postal_code = request.form["postal_code"]
try:
db_session.commit()
except Exception as e:
print(e)
db_session.rollback()
return redirect(url_for("view.checkout"))
return redirect(url_for("view.cart"))
def user_login():
email = request.form["email"]
password = request.form["password"]
user = (db_session.query(
models.User).filter(models.User.email == email).one_or_none())
if user is None:
return "no user found", 400
try:
if ph.verify(user.password_hash, password) and user.email_validated:
access_token = flask_jwt_extended.create_access_token(
identity=user.id)
resp = jsonify(success=True)
flask_jwt_extended.set_access_cookies(resp, access_token)
session['logged_in'] = True
return resp
except Exception as e:
print(e)
if user.user_type_id == 1:
print(user.user_type_id)
print(user.name)
return redirect(url_for("view.user"))
else:
return redirect(url_for("admin_view.admin_dashboard"))
def send_mail(id, handle, email, email_type):
try:
the_token = ph.hash(str(handle))[35:]
tomorrow = datetime.now() + timedelta(days=1)
if email_type == "new-user":
print("set new-user token")
validation_token = models.ValidationToken(token=the_token, created_at=tomorrow, user_id=id)
db_session.add(validation_token)
if email_type == "reset-user":
print("set reset-user token")
user = db_session.query(models.ValidationToken).filter(models.ValidationToken.user_id == id).one_or_none()
user.created_at = tomorrow
user.token=the_token
db_session.commit()
except Exception as e:
print(e)
print("[ ERROR ] failed to add validation_token")
return False
try:
print("sending verification email...")
the_token = the_token.replace("/", "_")
if email_type == "new-user":
pass
html = f"""
<html>
<body>
<a href="http://127.0.0.1:5000/validate_user/{the_token}">
click here
</a>
</body>
</html>"""
html = f"""
<!DOCTYPE html>
<html>
<body>
<div style="background-color:#eee;padding:10px 20px;">
<h2 style="font-family:Georgia, 'Times New Roman', Times, serif;color#454349;">FlyBuy Verification</h2>
</div>
<div style="padding:20px 0px">
<a href="http://127.0.0.1:5000/validate_user/{the_token}">
click here
</a>
</div>
</div>
</body>
</html>
"""
port = 465 # For SSL
sender_email = "*****@*****.**"
password = "******"
message = MIMEMultipart("alternative")
message["Subject"] = "User Account Validation"
message["From"] = sender_email
message["To"] = email
part2 = MIMEText(html, "html")
message.attach(part2)
context = ssl.create_default_context()
with smtplib.SMTP_SSL("smtp.gmail.com", port, context=context) as server:
server.login(sender_email, password)
server.sendmail(sender_email, email, message.as_string())
if email_type == "reset-user":
msg = MIMEText(u'<html><body><a href="127.0.0.1:5000/reset_pass/{the_token}">click here</a></body></html>','html')
body = f"""Hello, {handle} follow this link to validate your email \n {msg}"""
subject = "User Account Validation"
except Exception as e:
print(e)
print("[ ERROR ] Sending Mail failed")
return False
print("[ SUCCESS ] check your email")
return True
def delivery_address():
user_id = flask_jwt_extended.get_jwt_identity()
address_count = db_session.query(models.UserAddress).filter(
models.UserAddress.user_id == user_id).count()
return render_template("checkout.html", address_count=address_count + 1)
def edit_address(address_id):
address = db_session.query(models.UserAddress).filter(
models.UserAddress.id == int(address_id)).one_or_none()
return render_template("edit_address.html", address=address)
def register():
if session.get("logged_in"):
return redirect(url_for("view.products"))
user_types = db_session.query(models.UserType).all()
return render_template("register.html", user_types=user_types)