def test_parse_and_convert_modified_staff():
original_dict = db.get_all_staff()[0]
parsed_object = Staff.parse(original_dict) # Type: Meeting
parsed_object.name = "AASNvlaSNv aknsv laksnvlakvn"
original_dict["name"] = "AASNvlaSNv aknsv laksnvlakvn"
parsed_dict = parsed_object.to_json_dict()
assert original_dict == parsed_dict
def test_get_role_none():
meeting = Meeting.parse(db.get_meeting(mid))
all_staff_ids = set([staff["_id"] for staff in db.get_all_staff()])
non_participants = all_staff_ids.difference(set(meeting.staff))
staff = Staff.parse(db.get_staff(non_participants.pop()))
roles = get_role(staff, meeting)
assert (len(roles) == 0)
def login(address, secret):
global public_key, secret_key, staff
public_key = address
secret_key = secret
staff_dict = db.get_staff(address)
if staff_dict is None:
print("Unknown Staff!")
try:
staff = Staff.parse(staff_dict)
except Exception as e:
print("Error parsing staff!", e)
if staff is None:
print("Unknown Staff!")
print("****************************************\n"
"* C-MEET CLI (FOR TESTING) *\n"
"****************************************")
print("Connected to Meeting Server!")
print("You are logged in as ", staff.name, "!\n")
menu()
print("Bye!")
sio.disconnect()
def room_message(event_string):
"""
Main function that handles all events that enter through the web socket
"""
# Parse json as dict
try:
event_json = json.loads(event_string)
except ValueError as ve:
log.error("Error Parsing room-message as JSON!")
log.error(ve)
traceback.print_tb(ve.__traceback__)
return json.dumps(
sign(
get_error_ack(
"unknown",
"unknown",
content=AckErrorContent(
error_code=EventError.MALFORMED_EVENT,
details='Cant parse message as JSON'))).to_json_dict())
# Validate JSON dict using schema
ok, err_event = validate_schema(event_json)
if not ok:
log.error("Sending error msg")
errormsg = json.dumps(sign(err_event).to_json_dict())
log.error("======== error_msg: " + errormsg)
return errormsg
# Parse dict as event object
try:
event = Event.parse(event_json)
except KeyError as ve:
log.error("Error Parsing room-message!")
log.error(ve)
traceback.print_tb(ve.__traceback__)
return json.dumps(
sign(
get_error_ack("unknown",
"unknown",
content=AckErrorContent(
error_code=EventError.MALFORMED_EVENT,
details='Cant parse message as Event'))).
to_json_dict())
# Check timestamp
ok, err_event = validate_timestamp(event)
if not ok:
return json.dumps(sign(err_event).to_json_dict())
# Get the staff
try:
staff = Staff.parse(db.get_staff(event.by))
except KeyError as ke:
log.error(ke)
traceback.print_tb(ke.__traceback__)
return json.dumps(
sign(
get_error_ack(event.id,
event.meeting_id,
content=AckErrorContent(
error_code=EventError.STAFF_NOT_FOUND,
details=''))).to_json_dict())
except TypeError as te:
log.error(te)
traceback.print_tb(te.__traceback__)
return json.dumps(
sign(
get_error_ack(event.id,
event.meeting_id,
content=AckErrorContent(
error_code=EventError.STAFF_NOT_FOUND,
details=''))).to_json_dict())
# Get the meeting
try:
meeting = Meeting.parse(db.get_meeting(event.meeting_id))
except KeyError as ke:
log.error(ke)
traceback.print_tb(ke.__traceback__)
return json.dumps(
sign(
get_error_ack(event.id,
event.meeting_id,
content=AckErrorContent(
error_code=EventError.MEETING_NOT_FOUND,
details=''))).to_json_dict())
except TypeError as te:
log.error(te)
traceback.print_tb(te.__traceback__)
return json.dumps(
sign(
get_error_ack(event.id,
event.meeting_id,
content=AckErrorContent(
error_code=EventError.MEETING_NOT_FOUND,
details=''))).to_json_dict())
# Check signature, before trusting anything it says
if event.type in [MeetingEventType.JOIN, MeetingEventType.START
]: # We check contract for join and start
ok, err_event = validate_signature(event,
staff,
meeting,
check_contract=True)
if not ok:
return json.dumps(sign(err_event).to_json_dict())
else:
ok, err_event = validate_signature(event, staff, meeting)
if not ok:
return json.dumps(sign(err_event).to_json_dict())
# Get the roles
roles = get_role(staff, meeting)
# A preliminary authority check to see if the user can make any statements about the meeting
ok, err_event = validate_preliminary_authority(event, roles)
if not ok:
return json.dumps(sign(err_event).to_json_dict())
# Get the event type
event_type = MeetingEventType(event.type)
ack_event = None
ok = False
end_meeting = False
send_privately = False
if event_type == MeetingEventType.START:
ok, ack_event = start(event, staff, meeting, roles)
if event_type == MeetingEventType.JOIN:
ok, ack_event = join(event, staff, meeting, roles)
if event_type == MeetingEventType.LEAVE:
ok, ack_event = leave(event, staff, meeting)
if event_type == MeetingEventType.POLL:
ok, ack_event = poll(event, staff, meeting, roles)
if event_type == MeetingEventType.VOTE:
ok, ack_event = vote(event, staff, meeting, roles)
if event_type == MeetingEventType.POLL_END:
ok, ack_event = end_poll(event, staff, meeting, roles)
if event_type == MeetingEventType.COMMENT or event_type == MeetingEventType.REPLY or event_type == MeetingEventType.DISAGREEMENT:
ok, ack_event = comment_reply_disagreement(event, staff, meeting,
roles)
if event_type == MeetingEventType.DISCUSSION:
ok, ack_event = discussion(event, staff, meeting, roles)
if event_type == MeetingEventType.PATIENT_DATA_CHANGE:
ok, ack_event = patient_data_change(event, staff, meeting, roles)
if event_type == MeetingEventType.END:
ok, ack_event = end(event, staff, meeting, roles)
if ok:
end_meeting = True
if not ok: # If not ok we send the error ack event privately
return json.dumps(sign(ack_event).to_json_dict())
else:
# If an event has been referenced
check_and_remove_ref_event(meeting, event.ref_event)
# Add ack and event to unreferenced events
add_event_as_unref(meeting, event)
add_event_as_unref(meeting, ack_event)
# Sign the ack
signed_ack_event = sign(ack_event)
if not send_privately: # Only Broadcast if the send_privately is set to False
# Broadcast event
send(json.dumps(event.to_json_dict()), broadcast_room=meeting.id)
send(json.dumps(signed_ack_event.to_json_dict()),
broadcast_room=meeting.id)
record(event, meeting)
record(signed_ack_event, meeting)
if end_meeting:
end_meeting_session(meeting, event, signed_ack_event)
# Send the ack event to the user privately as well
return json.dumps(signed_ack_event.to_json_dict())
def test_parse_and_convert_staff():
original_dict = db.get_all_staff()[0]
parsed_object = Staff.parse(original_dict)
generated_dict = parsed_object.to_json_dict()
assert original_dict == generated_dict
def test_get_role_participant():
meeting = Meeting.parse(db.get_meeting(mid))
staff = Staff.parse(db.get_staff(meeting.staff[1]))
roles = get_role(staff, meeting)
assert (Role.PARTICIPANT in roles)
def test_get_role_host():
meeting = Meeting.parse(db.get_meeting(mid))
staff = Staff.parse(db.get_staff(meeting.host))
roles = get_role(staff, meeting)
assert (Role.HOST in roles) and (Role.PARTICIPANT in roles)