Esempio n. 1
0
def api_leave_room(response: Response,
                   taq_session_id: Optional[str] = Cookie(None),
                   db_session: Session = Depends(get_db_session)):

    # user validation
    taq_user = crud.get_taq_user_from_taq_session_id(db_session,
                                                     taq_session_id)
    if not taq_user:
        response.status_code = status.HTTP_400_BAD_REQUEST
        return "You don't belong to a room to begin with"

    if not api_utils.complete_error(taq_user):
        # if the user is currently attending to someone, or being attended to, remove that association
        other_taq_user = crud.get_taq_user_from_user_id(
            db_session, taq_user.attending_with)
        taq_user = crud.complete(db_session,
                                 complete=schemas.Complete(
                                     taq_user=taq_user,
                                     other_taq_user=other_taq_user))
    if not api_utils.dequeue_error(taq_user):
        # if the user is currently in queue, remove from queue
        taq_user = crud.dequeue_taq_user(db_session, taq_user)
    crud.delete_taq_user(db_session, taq_user)
    response.status_code = status.HTTP_200_OK
    return "You successfully left the room"
Esempio n. 2
0
def api_dequeue_user(response: Response,
                     taq_session_id: Optional[str] = Cookie(None),
                     db_session: Session = Depends(get_db_session)):

    # user & request validation
    taq_user = crud.get_taq_user_from_taq_session_id(db_session,
                                                     taq_session_id)
    error = api_utils.dequeue_error(taq_user)
    if error:
        response.status_code = status.HTTP_400_BAD_REQUEST
        return error

    dequeued_taq_user = crud.dequeue_taq_user(db_session, taq_user)
    response.status_code = status.HTTP_200_OK
    return return_cookie_setter(db_session, response, dequeued_taq_user)
Esempio n. 3
0
def api_get_room(response: Response,
                 taq_session_id: Optional[str] = Cookie(None),
                 db_session: Session = Depends(get_db_session)):

    # user validation
    taq_user = crud.get_taq_user_from_taq_session_id(db_session,
                                                     taq_session_id)
    if not taq_user:
        response.status_code = status.HTTP_401_UNAUTHORIZED
        return "Invalid session cookie ID"

    response_data = {
        **api_utils.get_queue_response_data(db_session, taq_user, db_session),
        **api_utils.get_room_info_response_data(db_session, taq_user, db_session),
        **api_utils.get_user_info_response_data(db_session, taq_user, db_session)
    }
    response.status_code = status.HTTP_200_OK
    return response_data
Esempio n. 4
0
def api_complete_keep_user(response: Response,
                           taq_session_id: Optional[str] = Cookie(None),
                           db_session: Session = Depends(get_db_session)):

    # user & request validation
    taq_user = crud.get_taq_user_from_taq_session_id(db_session,
                                                     taq_session_id)
    error = api_utils.complete_error(taq_user)
    if error:
        response.status_code = status.HTTP_400_BAD_REQUEST
        return error

    other_taq_user = crud.get_taq_user_from_user_id(db_session,
                                                    taq_user.attending_with)
    completed_taq_user = crud.complete(db_session,
                                       complete=schemas.Complete(
                                           taq_user=taq_user,
                                           other_taq_user=other_taq_user))
    response.status_code = status.HTTP_200_OK
    return return_cookie_setter(db_session, response, completed_taq_user)
Esempio n. 5
0
def api_enqueue_user(
    response: Response,
    taq_user_enqueue_form: schemas.TaqUserEnqueueForm = Depends(),
    taq_session_id: Optional[str] = Cookie(None),
    db_session: Session = Depends(get_db_session)):

    # user & form validation
    taq_user = crud.get_taq_user_from_taq_session_id(db_session,
                                                     taq_session_id)
    error = api_utils.enqueue_error(taq_user_enqueue_form, taq_user)
    if error:
        response.status_code = status.HTTP_400_BAD_REQUEST
        return error

    enqueued_taq_user = crud.enqueue_taq_user(
        db_session,
        taq_user_enqueue=schemas.TaqUserEnqueue(
            taq_user=taq_user, **taq_user_enqueue_form.dict()))
    response.status_code = status.HTTP_200_OK
    return return_cookie_setter(db_session, response, enqueued_taq_user)
Esempio n. 6
0
def api_attend_user(response: Response,
                    attend_form: schemas.AttendForm = Depends(),
                    taq_session_id: Optional[str] = Cookie(None),
                    db_session: Session = Depends(get_db_session)):

    # user & form validation
    ta_taq_user = crud.get_taq_user_from_taq_session_id(
        db_session, taq_session_id)
    st_taq_user = crud.get_taq_user_from_user_id(db_session,
                                                 attend_form.user_id)
    error = api_utils.attend_error(ta_taq_user, st_taq_user)
    if error:
        response.status_code = status.HTTP_400_BAD_REQUEST
        return error

    attended_ta_taq_user = crud.attend(db_session,
                                       attend=schemas.Attend(
                                           ta_taq_user=ta_taq_user,
                                           st_taq_user=st_taq_user))
    response.status_code = status.HTTP_200_OK
    return return_cookie_setter(db_session, response, attended_ta_taq_user)