def monitor_chat_message(data):
if 'monitor' not in session:
socketio.emit('terminate', {}, namespace='/monitor', room=request.sid)
return
key = data.get('key', None)
#sys.stderr.write("Key is " + str(key) + "\n")
if key is None:
sys.stderr.write("No key provided\n")
return
m = re.match(r'da:session:uid:(.*):i:(.*):userid:(.*)', key)
if not m:
sys.stderr.write("Invalid key provided\n")
return
session_id = m.group(1)
yaml_filename = m.group(2)
chat_user_id = m.group(3)
key = 'da:interviewsession:uid:' + str(session_id) + ':i:' + str(yaml_filename) + ':userid:' + str(chat_user_id)
sid = rr.get(key)
if sid is None:
sys.stderr.write("No sid for monitor chat message with key " + str(key) + "\n")
return
sid = sid.decode()
secret = secrets.get(sid, None)
if secret is not None:
secret = str(secret)
#obtain_lock(session_id, yaml_filename)
try:
steps, user_dict, encrypted = fetch_user_dict(session_id, yaml_filename, secret=secret)
except Exception as err:
#release_lock(session_id, yaml_filename)
sys.stderr.write("monitor_chat_message: could not get dictionary: " + text_type(err) + "\n")
return
#release_lock(session_id, yaml_filename)
nowtime = datetime.datetime.utcnow()
if encrypted:
message = encrypt_phrase(data['data'], secret)
else:
message = pack_phrase(data['data'])
user_id = session.get('user_id', None)
if user_id is not None:
user_id = int(user_id)
person = UserModel.query.filter_by(id=user_id).first()
chat_mode = user_dict['_internal']['livehelp']['mode']
m = re.match('t([0-9]+)', chat_user_id)
if m:
temp_owner_id = m.group(1)
owner_id = None
else:
temp_owner_id = None
owner_id = chat_user_id
if chat_mode in ['peer', 'peerhelp']:
open_to_peer = True
else:
open_to_peer = False
record = ChatLog(filename=yaml_filename, key=session_id, message=message, encrypted=encrypted, modtime=nowtime, user_id=user_id, temp_owner_id=temp_owner_id, owner_id=owner_id, open_to_peer=open_to_peer)
db.session.add(record)
db.session.commit()
modtime = nice_utc_date(nowtime)
rr.publish(sid, json.dumps(dict(origin='client', messagetype='chat', sid=request.sid, yaml_filename=yaml_filename, uid=session_id, user_id=chat_user_id, message=dict(id=record.id, user_id=record.user_id, first_name=person.first_name, last_name=person.last_name, email=person.email, modtime=modtime, message=data['data'], roles=[role.name for role in person.roles], mode=chat_mode))))
def monitor_chat_message(data):
if 'monitor' not in session:
socketio.emit('terminate', {}, namespace='/monitor', room=request.sid)
return
key = data.get('key', None)
#sys.stderr.write("Key is " + str(key) + "\n")
if key is None:
sys.stderr.write("No key provided\n")
return
m = re.match(r'da:session:uid:(.*):i:(.*):userid:(.*)', key)
if not m:
sys.stderr.write("Invalid key provided\n")
return
session_id = m.group(1)
yaml_filename = m.group(2)
chat_user_id = m.group(3)
key = 'da:interviewsession:uid:' + str(session_id) + ':i:' + str(yaml_filename) + ':userid:' + str(chat_user_id)
sid = rr.get(key)
if sid is None:
sys.stderr.write("No sid for monitor chat message with key " + str(key) + "\n")
return
secret = secrets.get(sid, None)
if secret is not None:
secret = str(secret)
#obtain_lock(session_id, yaml_filename)
try:
steps, user_dict, encrypted = fetch_user_dict(session_id, yaml_filename, secret=secret)
except Exception as err:
#release_lock(session_id, yaml_filename)
sys.stderr.write("monitor_chat_message: could not get dictionary: " + unicode(err) + "\n")
return
#release_lock(session_id, yaml_filename)
nowtime = datetime.datetime.utcnow()
if encrypted:
message = encrypt_phrase(data['data'], secret)
else:
message = pack_phrase(data['data'])
user_id = session.get('user_id', None)
if user_id is not None:
user_id = int(user_id)
person = UserModel.query.filter_by(id=user_id).first()
chat_mode = user_dict['_internal']['livehelp']['mode']
m = re.match('t([0-9]+)', chat_user_id)
if m:
temp_owner_id = m.group(1)
owner_id = None
else:
temp_owner_id = None
owner_id = chat_user_id
if chat_mode in ['peer', 'peerhelp']:
open_to_peer = True
else:
open_to_peer = False
record = ChatLog(filename=yaml_filename, key=session_id, message=message, encrypted=encrypted, modtime=nowtime, user_id=user_id, temp_owner_id=temp_owner_id, owner_id=owner_id, open_to_peer=open_to_peer)
db.session.add(record)
db.session.commit()
modtime = nice_utc_date(nowtime)
rr.publish(sid, json.dumps(dict(origin='client', messagetype='chat', sid=request.sid, yaml_filename=yaml_filename, uid=session_id, user_id=chat_user_id, message=dict(id=record.id, user_id=record.user_id, first_name=person.first_name, last_name=person.last_name, email=person.email, modtime=modtime, message=data['data'], roles=[role.name for role in person.roles], mode=chat_mode))))
def get_dict_encrypt():
session_id = session.get('uid', None)
yaml_filename = session.get('i', None)
secret = request.cookies.get('secret', None)
if session_id is None or yaml_filename is None:
sys.stderr.write('Attempt to get dictionary where session not defined\n')
return None, None
try:
steps, user_dict, is_encrypted = fetch_user_dict(session_id, yaml_filename, secret=secret)
except:
return None, None
return user_dict, is_encrypted
def monitor_chat_log(data):
if 'monitor' not in session:
socketio.emit('terminate', {}, namespace='/monitor', room=request.sid)
return
key = data.get('key', None)
#sys.stderr.write("Key is " + str(key) + "\n")
if key is None:
sys.stderr.write("No key provided\n")
return
m = re.match(r'da:session:uid:(.*):i:(.*):userid:(.*)', key)
if not m:
sys.stderr.write("Invalid key provided\n")
return
session_id = m.group(1)
yaml_filename = m.group(2)
chat_user_id = m.group(3)
key = 'da:interviewsession:uid:' + str(session_id) + ':i:' + str(yaml_filename) + ':userid:' + str(chat_user_id)
sid = rr.get(key)
if sid is None:
sys.stderr.write("No sid for monitor chat message with key " + str(key) + "\n")
return
sid = sid.decode()
secret = secrets.get(sid, None)
if secret is not None:
secret = str(secret)
#obtain_lock(session_id, yaml_filename)
try:
steps, user_dict, encrypted = fetch_user_dict(session_id, yaml_filename, secret=secret)
except Exception as err:
#release_lock(session_id, yaml_filename)
sys.stderr.write("monitor_chat_log: could not get dictionary: " + text_type(err) + "\n")
return
#release_lock(session_id, yaml_filename)
chat_mode = user_dict['_internal']['livehelp']['mode']
m = re.match('t([0-9]+)', chat_user_id)
if m:
temp_user_id = m.group(1)
user_id = None
else:
temp_user_id = None
user_id = chat_user_id
self_user_id = session.get('user_id', None)
if user_id is not None:
user_id = int(user_id)
if temp_user_id is not None:
temp_user_id = int(temp_user_id)
if self_user_id is not None:
self_user_id = int(self_user_id)
messages = get_chat_log(chat_mode, yaml_filename, session_id, user_id, temp_user_id, secret, self_user_id, None)
socketio.emit('chat_log', {'uid': session_id, 'i': yaml_filename, 'userid': chat_user_id, 'mode': chat_mode, 'data': messages}, namespace='/monitor', room=request.sid)
def monitor_chat_log(data):
if 'monitor' not in session:
socketio.emit('terminate', {}, namespace='/monitor', room=request.sid)
return
key = data.get('key', None)
#sys.stderr.write("Key is " + str(key) + "\n")
if key is None:
sys.stderr.write("No key provided\n")
return
m = re.match(r'da:session:uid:(.*):i:(.*):userid:(.*)', key)
if not m:
sys.stderr.write("Invalid key provided\n")
return
session_id = m.group(1)
yaml_filename = m.group(2)
chat_user_id = m.group(3)
key = 'da:interviewsession:uid:' + str(session_id) + ':i:' + str(yaml_filename) + ':userid:' + str(chat_user_id)
sid = rr.get(key)
if sid is None:
sys.stderr.write("No sid for monitor chat message with key " + str(key) + "\n")
return
secret = secrets.get(sid, None)
if secret is not None:
secret = str(secret)
#obtain_lock(session_id, yaml_filename)
try:
steps, user_dict, encrypted = fetch_user_dict(session_id, yaml_filename, secret=secret)
except Exception as err:
#release_lock(session_id, yaml_filename)
sys.stderr.write("monitor_chat_log: could not get dictionary: " + unicode(err) + "\n")
return
#release_lock(session_id, yaml_filename)
chat_mode = user_dict['_internal']['livehelp']['mode']
m = re.match('t([0-9]+)', chat_user_id)
if m:
temp_user_id = m.group(1)
user_id = None
else:
temp_user_id = None
user_id = chat_user_id
self_user_id = session.get('user_id', None)
if user_id is not None:
user_id = int(user_id)
if temp_user_id is not None:
temp_user_id = int(temp_user_id)
if self_user_id is not None:
self_user_id = int(self_user_id)
messages = get_chat_log(chat_mode, yaml_filename, session_id, user_id, temp_user_id, secret, self_user_id, None)
socketio.emit('chat_log', {'uid': session_id, 'i': yaml_filename, 'userid': chat_user_id, 'mode': chat_mode, 'data': messages}, namespace='/monitor', room=request.sid)
def get_dict_encrypt():
session_id = session.get('uid', None)
yaml_filename = session.get('i', None)
secret = request.cookies.get('secret', None)
if secret is not None:
secret = str(secret)
if session_id is None or yaml_filename is None:
sys.stderr.write('Attempt to get dictionary where session not defined\n')
return None, None
#obtain_lock(session_id, yaml_filename)
try:
steps, user_dict, is_encrypted = fetch_user_dict(session_id, yaml_filename, secret=secret)
except Exception as err:
#release_lock(session_id, yaml_filename)
sys.stderr.write('get_dict_encrypt: attempt to get dictionary failed: ' + unicode(err) + '\n')
return None, None
#release_lock(session_id, yaml_filename)
return user_dict, is_encrypted
def get_dict_encrypt():
session_id = session.get('uid', None)
yaml_filename = session.get('i', None)
secret = request.cookies.get('secret', None)
if secret is not None:
secret = str(secret)
if session_id is None or yaml_filename is None:
sys.stderr.write('Attempt to get dictionary where session not defined\n')
return None, None
#obtain_lock(session_id, yaml_filename)
try:
steps, user_dict, is_encrypted = fetch_user_dict(session_id, yaml_filename, secret=secret)
except Exception as err:
#release_lock(session_id, yaml_filename)
sys.stderr.write('get_dict_encrypt: attempt to get dictionary failed: ' + text_type(err) + '\n')
return None, None
#release_lock(session_id, yaml_filename)
return user_dict, is_encrypted
