def remove_from_que(callee_address, waiter_address) -> bool:
"""
Removes the waiter_address from the callee que
Used when the waiter does not want or should not wait anymore for the callee
:param callee_address:
:param waiter_address:
:return:
"""
callee_id = MyUser.get_id_by_email(callee_address)
waiter_id = MyUser.get_id_by_email(waiter_address)
waiter_place = Ques.get_place_in_line(waiter_id, callee_id)
db = get_db()
try:
temp = db.execute(
"DELETE from Ques WHERE callee_id = ? AND waiter_id = ?",
(callee_id, waiter_id))
print("DELETE from Ques WHERE callee_id = %s AND waiter_id = %s",
callee_id, waiter_id)
print("temp:", temp)
except Exception as msg:
print("error:", msg)
pass
db.commit()
if Ques.get_place_in_line(waiter_id, callee_id) is None:
db.execute(
"UPDATE ques SET place_in_line = place_in_line - 1"
" WHERE place_in_line > ? AND callee_id =?",
(waiter_place, callee_id))
else:
db.rollback()
return False
db.commit()
db.close()
return Ques.get_place_in_line(waiter_id, callee_id) is None
def move_to_top(waiter_address, calle_address):
waiter_id = MyUser.get_id_by_email(waiter_address)
callee_id = MyUser.get_id_by_email(calle_address)
waiter_place = Ques.get_place_in_line(waiter_id, callee_id)
loop_start = waiter_place - 1
print("place:", waiter_place)
print("start:", loop_start)
db = get_db()
# loop to go over all the waiters in the que
# and move each one one place back
db.execute(
"UPDATE ques SET place_in_line = place_in_line + 1"
" WHERE place_in_line < ? AND callee_id =?",
(waiter_place, callee_id))
print("moved down people above")
Ques.print_table()
# move the waiter that needs to be moved to the top to the top
db.execute(
"UPDATE ques set place_in_line = 1 WHERE waiter_id = ? AND callee_id = ?",
(waiter_id, callee_id))
db.commit() # commit to finish transaction
db.close()
print("moved waiter up")
Ques.print_table()
updated_place = Ques.get_place_in_line(
waiter_id, callee_id) # waiter place after change
if updated_place == 1: # check if the waiter is actually at the top of the que
return True
return False
def create(event_id, owner_id, title, start, end):
new_event = MyEvent(event_id, owner_id, title, start, end)
db = get_db()
db.execute(
"INSERT INTO events (event_id, owner_id, title, start_time, end_time) "
"VALUES (?, ?, ?, ?, ?)",
(new_event.event_id, new_event.owner_id, new_event.title,
new_event.start, new_event.end),
)
db.commit()
print("\nADDED NEW EVENT TO DB!")
print(new_event)
DbUser.update_user_events(
new_event.owner_id) # update owner's event list
def get_notifications(user_address):
user_id = MyUser.get_id_by_email(user_address)
db = get_db()
notifications_rows = db.execute(
"SELECT * FROM ques WHERE waiter_id = ? AND place_in_line = 1",
(user_id, )).fetchall()
notifications: list[Notification] = []
for notification in notifications_rows:
callee_id = notification[0]
callee = MyUser.get(callee_id)
notifications.append(
Notification(callee.name, callee.phone, callee.email))
# print("notifications:", notifications)
return notifications
def get_user_que(owner_address):
owner_id = MyUser.get_id_by_email(owner_address)
db = get_db()
que = db.execute("SELECT * FROM ques WHERE callee_id = ?",
(owner_id, )).fetchall()
if not que:
return None
return que
def get_info():
global temp_user
cur_user = DbUser(temp_user.address, temp_user.name, temp_user.phone,
temp_user.headers)
cur_user.id = DbUser.get_id_by_email(temp_user.address)
if not cur_user.id:
DbUser.create(cur_user.email, cur_user.name, cur_user.phone,
cur_user.creds)
else:
DbUser.update_creds(cur_user.id, cur_user.creds)
session_id = session.login_user(temp_user.address)
my_logger.debug(session.users_dict)
my_logger.debug("LOGGED IN NEW USER!")
my_logger.debug("email: %s", cur_user.email)
my_logger.debug("user_id: %s", cur_user.id)
my_logger.debug("\nUser: %s", temp_user.address)
my_logger.debug(temp_user.freebusy)
# Clear all of the "old" ranges the user currently has
Range.delete_user_ranges(cur_user.id)
# Create the new ranges in our database
for c_range in temp_user.freebusy:
Range.create_range(cur_user.id, c_range['start'], c_range['end'])
# Build the HTTP response
res = flask.jsonify(freebusy=temp_user.freebusy,
name=temp_user.name,
phone=temp_user.phone,
session_id=session_id)
my_logger.debug("callback response: %s", res.get_data(as_text=True))
return res
def create_que_item(callee_address, waiter_address):
"""
:param calle_address:
:param waiter_address:
:return: if successful - place in line,
if not - 0.
"""
waiter_id = MyUser.get_id_by_email(waiter_address)
callee_id = MyUser.get_id_by_email(callee_address)
callee_que = Ques.get_user_que(callee_address)
# create a list containing all of the id's
# of the users waiting in the callee's line
# print("callee_que:", callee_que[0][0], callee_que[0][1], callee_que[0][2])
if callee_que:
print("que alive")
callee_que_waiter_ids = [item[1] for item in callee_que]
if waiter_id in callee_que_waiter_ids:
print("already in que")
return Ques.get_place_in_line(
waiter_id,
callee_id) # return value for "already in the que"
db = get_db()
place_in_line = Ques.get_que_size(callee_id) + 1
db.execute(
"INSERT INTO ques (callee_id, waiter_id, place_in_line) VALUES (?, ?, ?)",
(callee_id, waiter_id, place_in_line))
db.commit()
db.close()
else:
print("que dead")
callee_que_waiter_ids = []
db = get_db()
place_in_line = 1
db.execute(
"INSERT INTO ques (callee_id, waiter_id, place_in_line) VALUES (?, ?, ?)",
(callee_id, waiter_id, place_in_line))
db.commit()
db.close()
print(callee_que_waiter_ids)
return place_in_line
def callback():
global current_handler_instance
name, user_address, phone, pic_url, freebusy, headers =\
current_handler_instance.callback_handler()
print("user info:", name, user_address, phone, pic_url, len(freebusy))
cur_user = DbUser(user_address, name, phone, headers) # current user
cur_user.id = DbUser.get_id_by_email(user_address)
if not cur_user.id:
c_user_id = DbUser.create(cur_user.email, name, phone, headers)
else:
DbUser.update_creds(cur_user.id, headers)
session_id = session.login_user(user_address)
my_logger.debug(session.users_dict)
my_logger.debug("LOGGED IN NEW USER!")
my_logger.debug("email: %s", cur_user.email)
my_logger.debug("user_id: %s", cur_user.id)
my_logger.debug("\nUser: %s", user_address)
my_logger.debug(freebusy)
# Clear all of the "old" ranges the user currently has
Range.delete_user_ranges(cur_user.id)
# Create the new ranges in our database
for c_range in freebusy:
Range.create_range(cur_user.id, c_range['start'], c_range['end'])
# Build the HTTP response
res = flask.jsonify(freebusy=freebusy,
name=name,
phone=phone,
session_id=session_id)
my_logger.debug("callback response: %s", res.get_data(as_text=True))
return res
def get_my_que(user_address):
user_id = MyUser.get_id_by_email(user_address)
db = get_db()
que_ids = db.execute("SELECT * FROM ques WHERE callee_id = ?",
(user_id, )).fetchall()
# print(que_ids)
que: list[Waiter] = []
for waiter in que_ids:
c_id = waiter[1]
c_user = MyUser.get(c_id)
c_name = c_user.name
c_address = c_user.email
c_phone = c_user.phone
c_waiter = Waiter(email=c_address,
name=c_name,
phone=c_phone,
place=waiter[2])
que.append(c_waiter)
# print("que:", que)
# sort 'que' according to the 'place' attribute of waiter
que.sort(key=lambda x: x.place)
# print("que:", que)
return que
def get_user_schedule():
"""
Retrieve the availability of the user
return value is JSON
@rtype: object
"""
params = flask.request.args
user_address = params.get('user_address')
print("User address in get user schedule:" + user_address)
# check if 'user_address' is a valid email, if it is - treat it like one,
# if its not - treat it like a name of a user
if '@' in user_address:
print("address")
try:
# try to get the ranges of the user with the address given
user_ranges: list[tuple[
datetime, datetime]] = DbUser.get_user_ranges(user_address)
except TypeError:
print("type error")
return flask.jsonify(error="type error")
else: # its a name
print("name")
try:
user_name = user_address
user_name = user_name.title()
print(user_name)
user_address = DbUser.get_address_by_name(user_name)
user_ranges: list[tuple[
datetime, datetime]] = DbUser.get_user_ranges(user_address)
except TypeError:
print("type error")
return flask.jsonify(error="type error")
print("address:", user_address)
is_available: bool = DbUser.is_available(user_address)
next_available: datetime = DbUser.next_available(user_address)
print("next:", next_available)
new_next_available: datetime = utc_to_local(
next_available) # change TZ to local
print("new:", new_next_available)
new_next_available_s = new_next_available.isoformat().split(
"+")[0].replace("T", " ")
print("new_s:", new_next_available_s)
phone = DbUser.get_user_phone(user_address)
name = DbUser.get_user_name(user_address)
res = flask.jsonify(name=name,
ranges=user_ranges,
is_available=is_available,
next_available=new_next_available_s,
phone=phone)
return res
def join():
params = flask.request.args
session_id = params.get(SESSION_ID_HTTP_PARAM_NAME)
try:
waiter_address = session.handle_user(session_id)
except Unauthorized:
return unauthorized_resp
callee_address = params.get('user_address')
if '@' in callee_address:
print("address")
try:
place_in_line = Ques.create_que_item(callee_address,
waiter_address)
except TypeError:
print("type error")
return flask.jsonify(error="type error")
else: # its a name
print("name")
try:
user_name = callee_address
user_name = user_name.title()
print(user_name)
callee_address = DbUser.get_address_by_name(user_name)
place_in_line = Ques.create_que_item(callee_address,
waiter_address)
except TypeError:
print("type error")
return flask.jsonify(error="type error")
print("address:", callee_address)
print("adding", waiter_address, "to", callee_address + "'s que")
# place_in_line = Ques.create_que_item(callee_address, waiter_address)
success = place_in_line != 0
res = flask.jsonify(success=success, place_in_line=place_in_line)
return res
def ranges_callback():
global current_quickstart_instance
my_logger.debug("ranges callback")
freebusy, user_address, name, phone, user_credentials = current_quickstart_instance.make_requests(
)
cur_user = DbUser(user_address, name, phone,
user_credentials) # current user
my_logger.debug("cUser after constructor:")
my_logger.debug(cur_user)
cur_user.id = DbUser.get_id_by_email(user_address)
my_logger.debug("user.id in callback: %s", cur_user.id)
if not cur_user.id:
c_user_id = DbUser.create(cur_user.email, name, phone,
user_credentials)
else:
DbUser.update_creds(cur_user.id, user_credentials)
# logging in the user
session_id = session.login_user(user_address)
my_logger.debug(session.users_dict)
my_logger.debug("LOGGED IN NEW USER!")
my_logger.debug("email: %s", cur_user.email)
my_logger.debug("user_id: %s", cur_user.id)
my_logger.debug("\nUser: %s", user_address)
my_logger.debug(freebusy)
# Clear all of the "old" ranges the user currently has
Range.delete_user_ranges(cur_user.id)
# Create the new ranges in our database
for c_range in freebusy:
Range.create_range(cur_user.id, c_range['start'], c_range['end'])
# Build the HTTP response
res = flask.jsonify(freebusy=freebusy,
name=name,
phone=phone,
session_id=session_id)
my_logger.debug("callback response: %s", res.get_data(as_text=True))
return res
def get_all_creds(self):
# self.creds_dict = DbUser.get_all_creds()
self.all_tokens = DbUser.get_all_creds()
def get_user_id_by_session_id(self, session_id):
return MyUser.get_id_by_email(self.get_address_by_session_id(session_id))