def on_join_jap(self, data: dict):
"""Call on message JOIN_JAP.
Emit USER_JOINED_JAP in the room 'jap_event/jap_id'. and USER_JOINED_TABLE if the user has one
Args :
data = {user_id, jap_event_id, ?table_id}
Emit :
USER_JOINED_JAP = {
"jap_event_id": int,
"new_member": asdict(new_member),
"members": list(User)
}
"""
app.logger.info("JOIN_JAP")
app.logger.info(request.sid)
session_id = request.sid
user_id = data["user_id"]
jap_event_id = data["jap_event_id"]
self.session_id_user_id[session_id] = {
"user_id": user_id,
"jap_event_id": jap_event_id,
}
jap_event = JapEventService.get_jap_event(jap_event_id)
table = TableService.get_user_table(user_id, jap_event_id)
new_member = UserService.get_user(user_id)
new_member_dict = asdict(new_member)
room = self.__get_jap_event_room(data["jap_event_id"])
if (room not in self.connected_by_jap_event
or new_member_dict not in self.connected_by_jap_event[room]):
join_room(room)
self.__add_to_event(new_member, room)
emit(
socket_messages["USER_JOINED_JAP"],
{
"jap_event_id": data["jap_event_id"],
"new_member": new_member_dict,
"members": self.connected_by_jap_event[room],
},
room=room,
)
if table:
self.on_join_table({
"user_id": user_id,
"jap_event_id": jap_event_id,
"table_id": table.id,
})
else:
# checkt that the user is not a jap creator, otherwise it must have a table.
if jap_event.creator_id == user_id:
raise (Exception(
"Error at jap creation for jap creator, not added to a table"
))
def get_all_jap_events() -> Response:
"""Get all jap events.
Returns :
list of serialized jap_event
"""
jap_events = JapEventService.get_all_jap_events()
return jsonify(jap_events)
def get_jap_event(jap_event_id: int) -> Response:
"""Get jap event for a given event id.
Returns :
{serialized jap_event}
"""
jap_event = JapEventService.get_jap_event(jap_event_id)
return jsonify(jap_event)
def get_upcoming_jap_events_for_user(user_id: int) -> Response:
"""Get all upcoming jap_events for a given user.
Args :
user_id: int
Returns :
list of serialized jap_events
"""
jap_events = JapEventService.get_upcoming_jap_events_for_user(user_id)
return jsonify(jap_events)
def get_past_jap_events_for_user(user_id: int):
"""Get past jap events for a user.
Args :
user_id
Returns :
jap_events: list
"""
jap_events = JapEventService.get_past_jap_events_for_user(user_id)
return jsonify(jap_events)
def get_tables_jap_event(jap_event_id: int) -> Response:
"""Get tables for a jap event.
Args :
jap_event_id
Returns :
list of serialized tables
"""
tables = JapEventService.get_tables_for_a_jap(jap_event_id)
return jsonify(tables)
def update_status(jap_event_id: int, status: int) -> Response:
"""Update status of a jap event.
Args :
jap_event_id, status
Returns :
serialized jap_event
"""
jap_event = JapEventService.update_status(jap_event_id, status)
return jsonify(jap_event)
def get_all_users_not_in_jap_event(jap_event_id: int):
"""Display all users that are not in the related jap event."""
users = UserService.get_all_users()
jap_event = JapEventService.get_jap_event(jap_event_id)
return jsonify(
{
"users": [
user
for user in users
if user.id not in [member.id for member in jap_event.members]
]
}
)
def add_members(jap_event_id: int) -> Response:
"""Add members to a jap event.
Args :
jap_event_id, data = {members: [ user_id, user_id2 ] }
Returns :
{ members: [User] }
"""
data = request.json
members = JapEventService.add_members_to_jap_event(
jap_event_id, list(set(data["members"])))
return jsonify(members)
def setup_class(cls):
"""Create the client and set up a test environment."""
cls.client = socketio.test_client(app)
# Check and create a user named jap_creator
cls.jap_creator = UserService.get_user_by_name("jap_creator")
if cls.jap_creator is None:
cls.jap_creator = UserService.create_user(
"jap_creator", "*****@*****.**", "0678031234", ""
)
cls.jap_creator_id = cls.jap_creator.id
# Check and create a user named TestUser
cls.user = UserService.get_user_by_name("TestUser")
if cls.user is None:
cls.user = UserService.create_user(
"TestUser", "*****@*****.**", "0678031234", ""
)
cls.user_id = cls.user.id
# Create an icon to be sure there is one
cls.icon = JapPlaceService.create_icon("")
# Create an item to be sure there is one
JapPlaceService.create_item("sushi", 300, cls.icon.id)
cls.items = Item.query.all()
cls.dict_item = asdict(cls.items[0])
# Create a menu to be sure there is one
cls.menu = JapPlaceService.create_menu(cls.items)
# Check and Create a jap_place named Oki to be sure there is one
cls.jap_place = JapPlaceService.get_jap_place_by_name("Oki")
if cls.jap_place is None:
cls.jap_place = JapPlaceService.create_jap_place(
"testJapPlace", "1 rue", "0678031234", "12h", cls.menu.id
)
cls.jap_place_id = cls.jap_place.id
# Create a jap_event named "Jap de promo" to be sure there is one
date = datetime.datetime.now() + datetime.timedelta(days=10)
cls.jap_event = JapEventService.create_jap_event(
"Jap de promo", "blabla", cls.jap_place.id, cls.jap_creator.id, date
)
cls.jap_event_id = cls.jap_event.id
# Save jap_event default table id
cls.default_table_id = cls.jap_event.tables[0].id
def create_jap_event() -> Response:
"""Create a new jap_event.
Body args :
{event_name, description, jap_place_id, creator_id, date}
Returns :
{serialized jap_event}
"""
data = request.json
if not data["event_name"]:
return json_abort(400, f"Empty string not allowed as a event_name")
jap_event = JapEventService.create_jap_event(
data["event_name"],
data["description"],
data["jap_place_id"],
data["creator_id"],
data["date"],
)
return jsonify(jap_event)
def get_table_for_user_jap_event(jap_event_id: int, user_id: int):
"""Get table for a user that is in a Jap Event.
Args :
jap_event_id
Returns :
{
jap_event: JapEvent,
table: Table (contains is_emperor field, letting you know if user is emperor or not)
}
"""
jap_event = JapEventService.get_jap_event(jap_event_id)
table = TableService.get_user_table(user_id, jap_event_id)
if table is None:
return jsonify({"table": table, "jap_event": jap_event})
is_user_emperor = table.emperor == user_id
table = asdict(table)
table["is_emperor"] = is_user_emperor
return jsonify({"table": table, "jap_event": jap_event})