def set_user_offline(user_id, current_sid):
try:
if not utils.is_valid_id(user_id):
logger.warning(
'got invalid id on disconnect for act: {}'.format(
str(activity.id)))
# TODO: sentry
return
environ.env.db.remove_sid_for_user(user_id, current_sid)
all_sids = utils.get_sids_for_user_id(user_id)
# if the user still has another session up we don't set the user as offline
if all_sids is not None and len(all_sids) > 0:
logger.debug(
'when setting user offline, found other sids: [%s]' %
','.join(all_sids))
return
if utils.get_user_status(user_id) == UserKeys.STATUS_INVISIBLE:
environ.env.cache.remove_from_multicast_on_disconnect(
user_id)
else:
environ.env.db.set_user_offline(user_id)
except Exception as e:
logger.error('could not set user offline: %s' % str(e))
logger.debug('request for failed set_user_offline(): %s' %
str(data))
logger.exception(traceback.format_exc())
def set_status(arg: tuple) -> None:
data, activity = arg
user_id = activity.actor.id
user_name = environ.env.session.get(SessionKeys.user_name.value, None)
image = environ.env.session.get(SessionKeys.image.value, '')
status = activity.verb
if user_name is None:
try:
user_name = utils.get_user_name_for(user_id)
except NoSuchUserException:
user_name = str(user_id)
if not utils.is_valid_id(user_id):
OnStatusHooks.logger.warning(
'got invalid user id for activity: {}'.format(str(data)))
return
if utils.is_super_user(user_id) or utils.is_global_moderator(user_id):
OnStatusHooks.log_admin_activity(user_id, user_name, status)
if status == 'online':
OnStatusHooks.set_online(user_id, user_name, image)
elif status == 'invisible':
OnStatusHooks.set_invisible(user_id, user_name)
elif status == 'visible':
OnStatusHooks.set_visible(user_id, user_name)
elif status == 'offline':
OnStatusHooks.set_offline(user_id, user_name)
environ.env.publish(data, external=True)
def handle_ban(self, activity: Activity):
banner_id = activity.actor.id
if banner_id == '0' or banner_id is None:
banner_id = '0'
banner_name = 'admin'
else:
try:
banner_name = utils.get_user_name_for(banner_id)
except NoSuchUserException:
# if banning from rest api the user might not exist
logger.error('no such user when banning: %s' % banner_id)
return
banned_id = activity.object.id
if not utils.is_valid_id(banned_id):
logger.warning('got invalid id on ban activity: {}'.format(
str(activity.id)))
# TODO: sentry
return
banned_name = utils.get_user_name_for(banned_id)
banned_sids = utils.get_sids_for_user_id(banned_id)
namespace = activity.target.url or '/ws'
target_type = activity.target.object_type
if target_type == 'room':
target_id = activity.target.id
target_name = utils.get_room_name(target_id)
elif target_type == 'channel':
target_id = activity.target.id
target_name = utils.get_channel_name(target_id)
else:
target_id = ''
target_name = ''
if len(banned_sids) == 0 or banned_sids == [None
] or banned_sids[0] == '':
logger.warning('no sid(s) found for user id %s' % banned_id)
return
reason = None
if hasattr(activity.object, 'content'):
reason = activity.object.content
activity_json = utils.activity_for_user_banned(banner_id, banner_name,
banned_id, banned_name,
target_id, target_name,
reason)
try:
ban_activity = self.get_ban_activity(activity, target_type)
self.env.out_of_scope_emit('gn_banned',
ban_activity,
json=True,
namespace=namespace,
room=banned_id)
if target_id is None or target_id == '':
rooms_for_user = self.env.db.rooms_for_user(banned_id)
logger.info(
'user %s is in these rooms (will ban from all): %s' %
(banned_id, str(rooms_for_user)))
self.ban_globally(activity_json, activity, rooms_for_user,
banned_id, banned_sids, namespace)
if utils.get_user_status(
banned_id) == UserKeys.STATUS_INVISIBLE:
environ.env.cache.remove_from_multicast_on_disconnect(
banned_id)
else:
environ.env.db.set_user_offline(banned_id)
disconnect_activity = utils.activity_for_disconnect(
banned_id, banned_name)
self.env.publish(disconnect_activity, external=True)
elif target_type == 'channel':
rooms_in_channel = self.env.db.rooms_for_channel(target_id)
self.ban_channel(activity_json, activity, rooms_in_channel,
target_id, banned_id, banned_sids, namespace)
else:
self.ban_room(activity_json, activity, target_id, banned_id,
banned_sids, namespace)
except KeyError as ke:
logger.error('could not ban: %s' % str(ke))
logger.exception(traceback.format_exc())
self.env.capture_exception(sys.exc_info())