def update_reminders():
user_uuid = str(request.form.get("uuid", None))
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
sheets_days = request.form.get("sheets", None)
bathroom_days = request.form.get("bathroom", None)
house_days = request.form.get("house", None)
kitchen_days = request.form.get("kitchen", None)
dishes_days = request.form.get("dishes", None)
vacuum_days = request.form.get("vacuum", None)
update_dict = {
"sheets": sheets_days,
"bathroom": bathroom_days,
"house": house_days,
"kitchen": kitchen_days,
"dishes": dishes_days,
"vacuum": vacuum_days
}
return db.update_reminders(user_uuid, update_dict)
def check_key():
c_fcm_key = request.form.get("fcm_key", None)
user_uuid = request.form.get("uuid", None)
if c_fcm_key is None:
return return_json(success=False, error="No fcm_key set")
if user_uuid is None:
return return_json(success=False, error="No uuid set'")
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid uuid format")
res = user_db.get_user(uuid=user_uuid)
if not res[0]:
return return_json(success=False, error="User not found")
c_user = res[1]
if c_user.install_id == c_fcm_key:
return return_json(success=True)
c_user.install_id = c_fcm_key
user_db.update_user(c_user)
return return_json(success=True)
def update_hygiene():
user_uuid = str(request.form.get("uuid", None))
hygiene_name_to_update = request.form.get("hygiene_name", None)
hygiene_is_done = str(request.form.get("is_done", None))
if hygiene_is_done is not None:
if hygiene_is_done.lower() == "true":
hygiene_is_done = True
elif hygiene_is_done.lower() == "false":
hygiene_is_done = False
else:
return return_json(success=False,
error="Invalid delete all: true | false")
else:
hygiene_is_done = True
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
res = db.get_user_hygiene(user_uuid)
c_hygienes = hygiene.Hygiene()
c_hygienes.from_mongo(res)
res = c_hygienes.update_hygiene(hygiene_name_to_update, hygiene_is_done)
db.update_one({'user_uuid': user_uuid}, {"$set": c_hygienes.json()})
return res
def delete_expense(self, user_uuid: str, delete_all: bool, expense_uuid):
res = self.find_one({'user_uuid': user_uuid})
if not res:
return return_json(success=False, error="No expenses found")
c_expenses = expenses.Expenses()
c_expenses.from_mongo(res)
if delete_all and expense_uuid is None:
c_expenses.delete_expense(delete_all=True)
self.update_one({'user_uuid': user_uuid},
{"$set": c_expenses.json()})
return return_json(success=True,
data={'message': 'all expenses were deleted'})
elif not delete_all and expense_uuid is not None:
if not validate_uuid(expense_uuid):
return return_json(success=False, error="Invalid expense UUID")
c_expenses.delete_expense(_expense_uuid=expense_uuid)
self.update_one({'user_uuid': user_uuid},
{"$set": c_expenses.json()})
return return_json(success=True,
data={'message': 'one expense was deleted'})
else:
return return_json(
success=False,
error="delete_all & expense uuid can't both be set")
def trigger_alarm():
request_json = request.json
if request_json["arduino_uuid"] is None:
return return_json(succes=False, error="Arduino UUID is not set")
arduino_uuid = request_json["arduino_uuid"]
if not data_validation.validate_uuid(arduino_uuid):
return return_json(success=False, error="Arduino UUID is not valid")
if not data_validation.verify_arduino(arduino_uuid):
return return_json(success=False, error="Arduino is not linked")
c_user_uuid = arduino_db.get_user_uuid_by_arduino_uuid(arduino_uuid)
res = user_db.get_user(uuid=c_user_uuid)
if not res[0]:
return return_json(success=False, error="User not found")
c_user = res[1]
if c_user.alarm_enabled:
send_notification_to_user(c_user.install_id, "ALARM",
"Motion detected near your TruusPod!")
return return_json(success=True,
data={"message": "Notifications sent"})
return return_json(success=False, error="Alarm is disabled")
def update_user():
user_uuid = request.form.get("uuid", None)
name = str(request.form.get("name", None))
user_hash = Encryption.encrypt_password(
str(request.form.get("password", None)))
email = str(request.form.get("email", None))
birthdate = str(request.form.get("birthdate", None))
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if user_db.get_user(uuid=user_uuid)[0] is False:
return return_json(success=False, error="User not found")
if not data_validation.validate_email(email):
return return_json(success=False, error="Invalid email")
if not data_validation.validate_birthdate(birthdate)[0]:
return return_json(
success=False,
error=data_validation.validate_birthdate(birthdate)[1])
c_user = user_db.get_user(uuid=user_uuid)[1]
c_user.name = name
c_user.user_hash = user_hash
if c_user.email != email:
c_user.email = email
c_user.is_verified = False
c_user.birthdate = birthdate
user_db.update_user(c_user)
return return_json(
success=True, data={"message": "User {0} updated".format(c_user.uuid)})
def get_inc():
user_uuid = str(request.form.get("uuid", None))
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
return db.get_user_expenses(user_uuid)
def get_hygiene():
user_uuid = str(request.form.get("uuid", None))
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
c_hygiene = db.get_user_hygiene(user_uuid)
return return_json(success=True, data={"hygiene": c_hygiene})
def get_schedule():
user_uuid = str(request.form.get("uuid", None))
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
res = db.get_user_schedule(user_uuid).get_events()
return return_json(success=True, data={'schedule': res})
def get_schedule():
request_json = request.json
if request_json["arduino_uuid"] is None:
return return_json(succes=False, error="Arduino UUID is not set")
arduino_uuid = request_json["arduino_uuid"]
if not data_validation.validate_uuid(arduino_uuid):
return return_json(success=False, error="Arduino UUID is not valid")
# The maximum amount of events that can be returned due to limited memory
try:
max_events_amount = int(request_json["max_events_amount"])
except TypeError:
return return_json(success=False,
error="Max_event_amounts must be a number")
except KeyError:
max_events_amount = 20
if not data_validation.verify_arduino(arduino_uuid):
return return_json(success=False, error="Arduino is not linked")
c_user_uuid = arduino_db.get_user_uuid_by_arduino_uuid(arduino_uuid)
res = user_db.get_user(uuid=c_user_uuid)
if not res[0]:
return return_json(success=False, error="User not found")
c_user_uuid = res[1].uuid
c_schedule = schedule_db.get_user_schedule(c_user_uuid).get_events()
# User schedule
if len(c_schedule) > max_events_amount:
c_schedule = c_schedule[-max_events_amount:]
for idx, l_item in enumerate(c_schedule):
c_item = Event()
c_item.from_mongo(l_item)
c_schedule[idx] = {
'start': c_item.start,
'end': c_item.end,
'title': c_item.title,
'content': c_item.content,
'location': c_item.location
}
return return_json(success=True, data={'schedule': c_schedule})
def check_notifications():
request_json = request.json
if request_json["arduino_uuid"] is None:
return return_json(succes=False, error="Arduino UUID is not set")
arduino_uuid = request_json["arduino_uuid"]
if not data_validation.validate_uuid(arduino_uuid):
return return_json(success=False, error="Arduino UUID is not valid")
if not data_validation.verify_arduino(arduino_uuid):
return return_json(success=False, error="Arduino is not linked")
try:
max_events_amount = int(request_json["max_events_amount"])
except TypeError:
return return_json(success=False,
error="Max_events_amount must be a number")
except KeyError:
max_events_amount = 20
c_user_uuid = arduino_db.get_user_uuid_by_arduino_uuid(arduino_uuid)
res = user_db.get_user(uuid=c_user_uuid)
if not res[0]:
return return_json(success=False, error="User not found")
c_user = res[1]
c_schedule = schedule_db.get_user_schedule(c_user.uuid)
upcoming_events = c_schedule.check_for_upcoming_events()
total_event_count = len(upcoming_events)
return_events = []
for c_event in upcoming_events:
return_events.append(c_event.json())
if len(return_events) > max_events_amount:
return_events = return_events[-max_events_amount:]
return return_json(success=True,
data={
'event_count': total_event_count,
'upcoming_events': return_events
})
def arduinos_add():
if request.method == "GET":
return render_template('arduinos/arduinos_add.html')
arduino_uuid = str(request.form.get('arduino_uuid', None)).strip()
user_uuid = str(request.form.get('user_uuid', None)).strip()
# If arduino_uuid is set, check if it's valid. If it's not return an error
if arduino_uuid != "" and not data_validation.validate_uuid(arduino_uuid):
return render_template('arduinos/arduinos_add.html', error="Invalid arduino UUID")
if user_uuid != "" and not data_validation.validate_uuid(user_uuid):
return render_template('arduinos/arduinos_add.html', error="Invalid user UUID")
if arduino_uuid:
new_arduino = arduino.Arduino(arduino_uuid=arduino_uuid)
if user_uuid:
new_arduino.user_uuid = user_uuid
arduino_db.insert_one(new_arduino.json())
return return_message("Succes", f"Arduino created with {arduino_uuid} and linked with {user_uuid}", 2, url_for('admin_blueprint.arduinos_get'))
arduino_db.insert_one(new_arduino.json())
return return_message("Succes", f"Arduino created with {arduino_uuid}", 2, url_for('admin_blueprint.arduinos_get'))
else:
arduino_db.create_arduino()
return return_message("Succes", "Arduino created", 2, url_for('admin_blueprint.arduinos_get'))
def set_arduino_uuid():
user_uuid = request.form.get("uuid", None)
arduino_uuid = request.form.get("arduino_uuid", None)
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if not data_validation.validate_uuid(arduino_uuid):
return return_json(success=False, error="Invalid arduino UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
if arduino_db.get_user_uuid_by_arduino_uuid(arduino_uuid):
c_user_uuid = arduino_db.get_user_uuid_by_arduino_uuid(arduino_uuid)
if c_user_uuid: # If the user has an arduino linked we need to remove it from that arduino
c_arduino_mongo = arduino_db.find_one(
{'arduino_uuid': arduino_uuid})
c_arduino = arduino.Arduino.from_mongo(c_arduino_mongo)
c_arduino.user_uuid = None
arduino_db.update_one({'arduino_uuid': arduino_uuid},
{"$set": c_arduino.json()})
return arduino_db.link_arduino(arduino_uuid, user_uuid)
def toggle_notifications():
user_uuid = request.form.get("uuid", None)
r_notifications_enabled = request.form.get("notifications_enabled", None)
r_alarm_enabled = request.form.get("alarm_enabled", None)
if r_alarm_enabled is not None:
if r_alarm_enabled.lower() == "true":
r_alarm_enabled = True
elif r_alarm_enabled.lower() == "false":
r_alarm_enabled = False
else:
return return_json(
success=False,
error="Invalid alarm_enabled bool: true | false")
else:
return return_json(success=False, error="alarm_enabled must be set")
if r_notifications_enabled is not None:
if r_notifications_enabled.lower() == "true":
r_notifications_enabled = True
elif r_notifications_enabled.lower() == "false":
r_notifications_enabled = False
else:
return return_json(
success=False,
error="Invalid notifications enabled bool: true | false")
else:
return return_json(success=False,
error="notifications_enabled must be set")
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if user_db.get_user(uuid=user_uuid)[0] is False:
return return_json(success=False, error="User not found")
c_user = user_db.get_user(uuid=user_uuid)[1]
c_user.notifications_enabled = r_notifications_enabled
c_user.alarm_enabled = r_alarm_enabled
user_db.update_user(c_user)
return return_json(success=True,
data={
'notifications_enabled':
c_user.notifications_enabled,
'alarm_enabled': c_user.alarm_enabled
})
def get_schedule_by_date():
user_uuid = str(request.form.get("uuid", None))
date = str(request.form.get("date", None)).replace("-", "/")
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
if not data_validation.validate_birthdate(date):
return return_json(success=False,
error="Invalid date format: dd/mm/yyyy")
res = db.get_user_schedule_by_date(user_uuid, date)
return return_json(success=True, data={'schedule': res})
def arduino_edit(uuid):
c_arduino = arduino_db.get_arduino(uuid)
if not c_arduino:
return return_message("Error", "Arduino not found", 2, url_for("admin_blueprint.arduinos_get"))
if request.method == "GET":
return render_template('arduinos/arduinos_edit.html', arduino_list=[c_arduino], user_list=user_db.get_all_users()[1])
user_uuid = str(request.form.get('selected_user', None)).strip()
print(user_uuid)
# If arduino_uuid is set, check if it's valid. If it's not return an error
if user_uuid != "" and not data_validation.validate_uuid(user_uuid):
return render_template('arduinos/arduinos_edit.html', arduino_list=[c_arduino], user_list=user_db.get_all_users()[1], error="Invalid user UUID")
c_arduino.user_uuid = user_uuid
arduino_db.update_arduino(c_arduino)
return return_message("Succes", "Arduino editted", 2, url_for("admin_blueprint.arduinos_get"))
def get_preferences():
user_uuid = request.form.get("uuid", None)
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if user_db.get_user(uuid=user_uuid)[0] is False:
return return_json(success=False, error="User not found")
c_user = user_db.get_user(uuid=user_uuid)[1]
return return_json(success=True,
data={
"preferences": {
'notifications_enabled':
c_user.notifications_enabled,
'alarm_enabled': c_user.alarm_enabled
}
})
def user_edit(uuid):
c_user = user_db.get_user(uuid=uuid)[1]
if request.method == "GET":
c_arduino = arduino_db.get_arduino_by_user_uuid(uuid)
if c_arduino:
c_user.arduino = c_arduino.arduino_uuid
else:
c_user.arduino = None
return render_template('users/user_edit.html', user_list=[c_user])
else:
user_uuid = uuid
name = str(request.form.get("name", None))
email = str(request.form.get("email", None))
birthdate = str(request.form.get("birthdate", None))
if not data_validation.validate_uuid(user_uuid):
return render_template('users/user_edit.html', user_list=[c_user], error="Invalid user UUID")
if user_db.get_user(uuid=user_uuid)[0] is False:
return render_template('users/user_edit.html', user_list=[c_user], error="User not found")
if not data_validation.validate_email(email):
return render_template('users/user_edit.html', user_list=[c_user], error="Invalid email")
if not data_validation.validate_birthdate(birthdate)[0]:
return render_template('users/user_edit.html', user_list=[c_user], error=data_validation.validate_birthdate(birthdate)[1])
c_user = user_db.get_user(uuid=user_uuid)[1]
c_user.name = name
if c_user.email != email:
c_user.email = email
c_user.is_verified = False
name = c_user.name
token = generate_confirm_token(c_user.email)
send_mail(c_user.name, c_user.email, token)
c_user.birthdate = birthdate
user_db.update_user(c_user)
return return_message("User updated", f"{c_user.name} has been updated!", 2, url_for('admin_blueprint.get_users'))
def update_current():
user_uuid = str(request.form.get("uuid", None))
expense_uuid = request.form.get("expense_uuid", None)
amount = request.form.get("amount", None)
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
if amount is None:
return return_json(success=False, error="Amount must be set")
if not data_validation.validate_amount(amount):
return return_json(success=False,
error="Est amount must be a number or decimal")
return db.update_current_value(user_uuid, expense_uuid, amount)
def update_schedule(self,
user_uuid,
start,
end,
title,
content,
location,
remind_minutes_before,
event_uuid=None):
res = self.find_one({'user_uuid': user_uuid})
if not res:
return return_json(success=False, error="No schedule found")
c_schedule = schedule.Schedule()
c_schedule.from_mongo(res)
if event_uuid is not None:
# update reminder
if not validate_uuid(event_uuid):
return return_json(success=False, error="Invalid event UUID")
res = c_schedule.update_event(
event_uuid,
event.Event(start, end, title, content, location,
remind_minutes_before))
if res[0] is False:
return return_json(success=False, error="Reminder not found")
self.update_one({'user_uuid': c_schedule.user_uuid},
{"$set": c_schedule.json()})
return return_json(success=True)
res = c_schedule.add_event(start, end, title, content, location,
remind_minutes_before)
if res is False:
return return_json(success=False, error="Fields empty")
self.update_one({'user_uuid': c_schedule.user_uuid},
{"$set": c_schedule.json()})
return return_json(success=True)
def get_user():
user_uuid = request.form.get("uuid", None)
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if user_db.get_user(uuid=user_uuid)[0] is False:
return return_json(success=False, error="User not found")
c_user = user_db.get_user(uuid=user_uuid)[1]
result = {
'uuid': c_user.uuid,
'name': c_user.name,
'email': c_user.email,
'birthdate': c_user.birthdate,
'last_login': c_user.last_login,
'created_at': c_user.created_at
}
return return_json(success=True, data=result)
def delete_event():
user_uuid = str(request.form.get("uuid", None))
event_uuid = request.form.get("event_uuid", None)
delete_all = request.form.get("delete_all", None)
if delete_all is not None:
if delete_all.lower() == "true":
delete_all = True
elif delete_all.lower() == "false":
delete_all = False
else:
return return_json(success=False,
error="Invalid delete all: true | false")
else:
delete_all = False
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
return db.delete_event(user_uuid, event_uuid, delete_all)
def update_event():
user_uuid = str(request.form.get("uuid", None))
start = str(request.form.get("start", None)).replace(
"-", "/") # Ios datetime uses '-' instead of '/'
end = str(request.form.get("end", None)).replace("-", "/")
title = str(request.form.get("title", None))
content = str(request.form.get("content", None))
location = str(request.form.get("location", None))
remind_minutes_before = request.form.get("remind_minutes_before", None)
event_uuid = request.form.get("event_uuid", None)
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
if not data_validation.validate_datetime(start)[0]:
return return_json(success=False,
error=data_validation.validate_datetime(start)[1])
if not data_validation.validate_datetime(end)[0]:
return return_json(success=False,
error=data_validation.validate_datetime(end)[1])
time_validation = data_validation.validate_start_before_end(start, end)
if not time_validation[0]:
return return_json(success=False, error=time_validation[1])
if remind_minutes_before is None:
remind_minutes_before = 30 # Default value
else:
if not data_validation.validate_amount(remind_minutes_before):
return return_json(success=False,
error="remind_minutes_before must be a number")
remind_minutes_before = int(remind_minutes_before)
return db.update_schedule(user_uuid, start, end, title, content, location,
remind_minutes_before, event_uuid)
def update_expenses():
user_uuid = str(request.form.get("uuid", None))
expense_type = str(request.form.get("expense_type", None)).lower()
est_amount = str(request.form.get("est_amount", None))
title = str(request.form.get("title", None))
expense_uuid = request.form.get("expense_uuid", None)
if expense_type != "exp" and expense_type != "inc":
return return_json(success=False,
error="Invalid expense type: inc | exp")
if not data_validation.validate_uuid(user_uuid):
return return_json(success=False, error="Invalid user UUID")
if not data_validation.verify_user(user_uuid):
return return_json(success=False, error="User not found")
if not data_validation.validate_amount(est_amount):
return return_json(success=False,
error="Est amount must be a number or decimal")
return db.update_expense(user_uuid, expense_type, est_amount, title,
expense_uuid)
def send_notification_admin():
uuid = request.form.get("uuid", None)
title = str(request.form.get("title", None))
message = str(request.form.get("message", None))
if not data_validation.validate_uuid(uuid):
return render_template('notifications/notifications_main.html', error="Invalid UUID")
res = user_db.get_user(uuid=uuid)
if not res[0]:
return return_message("Error", "User not found", 2, url_for('admin_blueprint.notifications_main'))
c_user = res[1]
if c_user.install_id:
if c_user.notifications_enabled:
send_notification_to_user(c_user.install_id, title, message)
if res[0]:
return return_message("Succes", f"Notifcation has been sent to {c_user.name}", 2, url_for("admin_blueprint.users_main"))
return return_message("Error", res[1], 5, url_for('admin_blueprint.notifications_main'))
return return_message("Error", "User has notifications disabled", 2, url_for("admin_blueprint.users_main"))
return return_message("Error", "User has no FCM key", 2, url_for('admin_blueprint.users_main'))
def update_expense(self,
user_uuid: str,
expense_type,
est_amount,
title,
expense_uuid=None):
res = self.find_one({'user_uuid': user_uuid})
if not res:
return return_json(success=False, error="No expenses found")
c_expenses = expenses.Expenses()
c_expenses.from_mongo(res)
if expense_uuid is None:
res = c_expenses.add_expense(title, expense_type, est_amount)
if not res[0]:
return return_json(success=False, error="Fields are empty")
self.update_one({'user_uuid': user_uuid},
{"$set": c_expenses.json()})
return return_json(success=True,
data={'message': "Expense added!"})
if not validate_uuid(expense_uuid):
return return_json(success=False, error="Invalid expense UUID")
res = c_expenses.update_expense(
expense_uuid, expense.Expense(title, expense_type, est_amount))
if res[0]:
self.update_one({'user_uuid': user_uuid},
{"$set": c_expenses.json()})
return return_json(success=True,
data={'message': "Expense updated!"})
return return_json(success=False, error=res[1])
def update_recipe():
request_json = request.json
if request_json["title"] is None:
return return_json(succes=False, error="Title is not set")
if request_json["prep_time"] is None:
return return_json(succes=False, error="prep_time is not set")
if request_json["ingredients"] is None:
return return_json(succes=False, error="ingredients is not set")
if request_json["preperation"] is None:
return return_json(succes=False, error="preperation is not set")
if 'uuid' in request_json:
uuid = request_json["uuid"]
else:
uuid = None
title = request_json["title"]
prep_time = request_json["prep_time"]
ingredients = request_json["ingredients"]
preperation = request_json["preperation"]
if not data_validation.validate_amount(prep_time):
return return_json(success=False, error="prep_time must be an integer")
if type(ingredients) != list:
return return_json(success=False, error="Ingredients must be a list")
if type(preperation) != list:
return return_json(success=False, error="preperation must be a list")
if uuid is not None:
if not data_validation.validate_uuid(uuid):
return return_json(success=False, error="Invalid uuid format")
return db.update_recipe(uuid, title, prep_time, ingredients,
preperation)
return db.add_recipe(title, prep_time, ingredients, preperation)
