def addRooms():
form = RoomForm()
if form.validate_on_submit():
if form.room_type.data == '-1':
flash("Please choose a room type.")
else:
print(form.room_id.data)
Rooms.insert(str(form.room_id.data), str(form.room_name.data), int(form.room_type.data), int(form.capacity.data))
return redirect(url_for('viewRooms'))
return render_template('addRooms.html',form=form)
def do_turn(room_id, player_id, new_board, game_ended):
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
socketio.emit("gameUpdate", {"data": 'This is not a valid room id bobo', 'status': 400}, room=request.sid)
return
room = Rooms.objects(id=room_id).first()
if not room:
socketio.emit('gameUpdate', {'data': 'No room', 'status': 404}, room=request.sid)
return
room.board = new_board
room.turn = not room.turn
room.gameEnded = game_ended
room.save()
room_json = {
"id": room_id,
"board": new_board,
"turn": room.turn,
"resultsTable": room.resultsTable,
"gameEnded": game_ended
}
socketio.emit("gameUpdate", {'data': room_json, 'status': 200}, room=room_id)
def last_update(room_id):
# TODO: send results table in getViewRoom
last_date = request.args.get('date', None)
if not last_date:
return 'Missing date parameter', 400
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
return 'Room id is not valid omer', 400
room = Rooms.objects(id=room_id).first()
if room:
resultTable = room.resultsTable
data = {
'result': room.resultsTable,
'is_uptodate': False
}
if room.lastResultUpdate:
# parse string to datetime
datetime_last_date = datetime.strptime(last_date, '%d.%m.%Y %H:%M:%S')
# check if up to date
if datetime_last_date >= room.lastResultUpdate:
data['results'] = None
data['is_uptodate'] = True
return jsonify({'data': data}), 200
else:
return 'No such room', 404
def edit_room(room_id):
form = RoomForm()
if form.validate_on_submit():
# Encode an image to the appropriate size.
room_image = room_logo(form.room_logo.data.read())
# Save to our assets directory.
path = get_room_dir(room_id) + "/f1234.img"
file = open(path, "wb")
file.write(room_image)
file.close()
room = Rooms.query.filter_by(room_id=room_id).first()
if room:
room.bgm = form.bgm.data
room.mascot = form.has_mascot.data
room.contact = form.has_contact.data
room.intro_msg = form.intro_msg.data
room.mii_msg = form.mii_msg.data
else:
room = Rooms(
room_id=room_id,
bgm=form.bgm.data,
mascot=form.has_mascot.data,
contact=form.has_contact.data,
intro_msg=form.intro_msg.data,
mii_msg=form.mii_msg.data,
logo2_id="f1234",
)
db.session.add(room)
db.session.commit()
return redirect(url_for("list_room"))
return render_template("room_edit.html", form=form)
def to_view_room(room_id):
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
socketio.emit("viewRoom", {"data": 'This is not a valid room id bobo', "status": 400}, room=request.sid)
return
room = Rooms.objects(id=room_id).first()
if room:
join_room(room_id)
if room.isOpen:
socketio.emit("viewRoom", {"data": 'Wait for game to start! tembel', "status": 202}, room=request.sid)
return
room_json = room_to_json(room)
room_json['resultsTable'] = room.resultsTable
room_json['gameEnded'] = room.gameEnded
socketio.emit("viewRoom", {"data": room_json, "status": 200}, room=request.sid)
return
else:
socketio.emit("viewRoom", {"data": 'No such room homed', "status": 404}, room=request.sid)
def save_state(self, db):
#saves all data to sqlite db
engine = create_engine('sqlite:///%s' % db)
Session = sessionmaker()
Session.configure(bind=engine)
Base.metadata.create_all(engine)
Base.metadata.bind = engine
session = Session()
for person in self.all_people:
new_person = People()
new_person.name = person.name
if isinstance(person, Staff):
new_person.role = 'staff'
if person.office is None:
new_person.office = None
else:
new_person.office = person.office.name
elif isinstance(person, Fellow):
new_person.role = 'fellow'
if person.office is None:
new_person.office = None
else:
new_person.office = person.office.name
if person.living is None:
new_person.living = None
else:
new_person.living = person.living.name
for unallocated_person in self.unallocated_office:
if unallocated_person == new_person.name:
new_person.unallocated = 'office'
for unallocated_person in self.unallocated_living:
if unallocated_person == new_person.name:
new_person.unallocated = 'living'
session.merge(new_person)
session.commit()
for room in self.offices:
new_room = Rooms()
new_room.room_name = room.name
new_room.category = "office"
session.merge(new_room)
session.commit()
for room in self.living_spaces:
new_room = Rooms()
new_room.room_name = room.name
new_room.category = "living"
session.merge(new_room)
session.commit()
print("Data saved ")
def create_room(self):
if self.room_id:
return self.room_id
else:
self.room_id = Rooms.create().id
Users.update(
room_id=self.room_id,
is_admin=True).where(Users.id == self.db_id).execute()
self.is_admin = True
return self.room_id
def rooms():
rooms = []
roomsQ = Rooms.query()
for roomQ in roomsQ.iter():
roomDict = roomQ.to_dict()
rooms.append(roomDict['url'])
logging.debug(rooms)
if 'loggedin' in session:
if(session['loggedin']==True):
return render_template('rooms.html', vars={'username':session['username'], 'rooms':rooms})
return render_template('rooms.html')
def delete(self):
key = self.request.cookies['roomlist']
roomlist = db.get(key)
#roomId = simplejson.loads(self.request.body)['id']
roomId = self.request.get("roomId")
room = Rooms.get_by_id(int(roomId))
if room.roomlist.key() == roomlist.key():
#tmp = room.toDict()
room.delete()
else:
self.error(403)
def room_mode(room_id):
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
return 'Room id is not valid omer', 400
room = Rooms.objects(id=room_id).first()
if room:
return '0' if room.isOpen else '1', 200
return '2', 404
def create_room(user_args):
# init game board
board = [[''] * 9] * 9
# get player1 from
player1 = Player(name=user_args['name'],
color=user_args['color'], sid=request.sid)
# add room to database
room = Rooms(board=board, players=[player1])
# save in db
room.save()
# add player to room session
join_room(str(room.id))
# signal room open
socketio.emit("roomOpened", {'data': str(room.id), "status": 200}, room=request.sid)
def room(roomId):
if 'loggedin' in session:
if(session['loggedin']==True):
room = Rooms.get_by_id(roomId)
if (room == None):
return render_template('message.html', vars={'title': 'eRRoR:', 'msg':'No Room by that Id.', 'link': '/', 'linkStr': 'home'})
vars = room.to_dict()
vars['id'] = room.key.id()
vars['username'] = session['username']
return render_template('room.html', vars=vars)
return render_template('message.html', vars={'title': 'eRRoR:', 'msg':'Not Signed In.', 'link': '/', 'linkStr': 'home'})
def get(self):
key = self.request.cookies['roomlist']
roomlist = db.get(key)
rooms = []
query = Rooms.all()
#query = db.GqlQuery("SELECT * FROM Rooms")
query.filter("roomlist =", roomlist.key())
for room in query:
rooms.append(room.toDict())
# rooms.append(room.to_dict())
rooms = simplejson.dumps(rooms)
#self.response.headers['Content-Type'] = 'image/jpeg'
self.response.out.write(rooms)
def set_room(self, room_id):
room = Rooms.get_or_none(id=room_id)
# если у чела уже есть комната говорим ему об этом
if self.room_id == room_id:
return 'exists'
# если комната существует
if room:
self.room_id = room_id
Users.update(
room_id=self.room_id,
is_admin=False).where(Users.id == self.db_id).execute()
return room_id
return 0
def genSchedule():
'''
Update the input.json file in algorithm folder from the database.
runScheduler
then, update the database with the new data.
'''
input_dict = {'professor':[],'subject':[],'classroom':[],'studentGroup':[]}
prof_format = {'name':'','id':0,'courseTable':{}}
subject_format = {'component':[],'pillar':0,'sessionNumber':0,'name':'','term':1,'cohortNumber':1,'totalEnrollNumber':10,'type':0,'courseId':''}
class_format = {'name':'','location':'','id':1,'roomType':0,'capacity':10}
studentGroup_format = {'pillar': 0, 'size': 0, 'subjects': [], 'name': '', 'cohort': 0, 'term': 1,'id':0}
input_dict['subject'] = Subjects.getAllSubjects()
input_dict['classroom'] = Rooms.geAllRooms()
input_dict['studentGroup'] = studentGroup.getAllGroups()
classroomlist = [i for i in range(len(input_dict['classroom']))]
for professor in Users.getAllProfessors():
input_dict['professor'].append({'name':professor.fullname,'id':professor.professor_id,'coursetable':ast.literal_eval(professor.coursetable)})
for each_professor in input_dict['professor']:
each_professor['coursetable'] = {str(k):ast.literal_eval(v) for k,v in each_professor['coursetable'].items()}
for each_subject in input_dict['subject']:
for each_component in each_subject['component']:
each_component['classroom'] = classroomlist
print(input_dict)
file_to_open = os.path.join(os.getcwd(), "input.json")
with open(file_to_open,'w+') as input_file:
print(json.dump(input_dict, input_file))
with open(file_to_open, 'r') as data_file:
data = json.load(data_file)
print(data)
"""
file_to_open2 = os.path.join(os.getcwd(),"algorithm/input.json")
with open(file_to_open2,'w') as input_file:
print(json.dump(input_dict, input_file))
input_file.close()
with open(file_to_open2, 'r') as data_file:
data = json.load(data_file)
print(data)
data_file.close()
"""
runScheduler()
timetablePath = os.path.join(os.getcwd(), "timetable.json")
with open(timetablePath, 'r') as data_file:
data = json.load(data_file)
Timetable.replace_all(data)
return redirect(url_for('home'))
def roomCreate():
if 'loggedin' in session:
if(session['loggedin']==True):
roomId = ''
while True:
roomId = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(8))
room = Rooms.get_by_id(roomId)
if (room == None):
break
roomKey = Rooms(id = roomId, url = roomId, canvas = '{"objects":[],"background":""}', canvasVersion = 0, chatHistory = ['{"username": "******", "date": "'+datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S")+'", "chatMessage": "Hello and welcome to Brainstorm. You can start drawing in the pane to the left and share it with the people who are here, or message them directly by typing a message below."}']).put()
return redirect('/room/' + roomId)
return render_template('message.html', vars={'title': 'eRRoR:', 'msg':'Not Signed In.', 'link': '/', 'linkStr': 'home'})
def handle_disconnect():
room_to_close = Rooms.objects(players__match={'sid': request.sid}).only('id').first()
# player was not in a room
if not room_to_close:
return
room_id = str(room_to_close['id'])
socketio.emit("roomClosed", {"data": 'Player exits room', "status": 200}, room=room_id)
close_room(room_id)
room_to_close.delete()
def add_room():
"""
Adds a room in the database.
A room has a name, a comment and a status field (light on/off).
This method is designed to be called by an HTML form.
"""
room = request.form['name']
desc = request.form['comment']
pin = request.form['gpio']
rooms = Rooms.query.all()
if rooms == []:
new_room = Rooms(name=room, comment=desc, gpio=pin)
db.session.add(new_room)
#leds[pin] = LED("BOARD"+str(pin))
else:
for r in rooms:
if r.toList()[0] == room:
return "Room %s already exists." % (room)
else:
new_room = Rooms(name=room, comment=desc, gpio=pin)
db.session.add(new_room)
#leds[pin] = LED("BOARD"+str(pin))
db.session.commit()
return "Room %s created !" % (room)
def new_offer_response(room_id, response):
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
socketio.emit("offerResult", {"data": 'This is not a valid room id bobo', 'status': 400}, room=request.sid)
return
room = Rooms.objects(id=room_id).first()
if not room:
socketio.emit('offerResult', {'data': 'No room', 'status': 404}, room=request.sid)
return
if response:
room.gameEnded = False
socketio.emit('offerResult', {'data': response, 'status': 200}, room=room_id)
def put(self):
key = self.request.cookies['roomlist']
roomlist = db.get(key)
roomId = simplejson.loads(self.request.body)['id']
room = Rooms.get_by_id(int(roomId))
#room = Rooms.get_by_id(int(2))
if room.roomlist.key() == roomlist.key():
inputData = simplejson.loads(self.request.body)
# room.content = inputData['content']
# room.done = inputData['done']
# room.put()
# room = simplejson.dumps(room.toDict())
temp = room.updateRoom(inputData)
room = simplejson.dumps(temp)
self.response.out.write(room)
else:
self.error(403)
def close_the_room(room_id, reason):
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
socketio.emit("roomClosed", {"data": 'This is not a valid room id bobo', "status": 404}, room=request.sid)
return
room = Rooms.objects(id=room_id).first()
if not room:
socketio.emit("roomClosed", {"data": 'No such room', "status": 404}, room=request.sid)
return
socketio.emit("roomClosed", {"data": reason, "status": 200}, room=room_id)
# This is not my function, its a function of Socketio that implements rooms of sid
close_room(room_id)
# Delete room from data base
room.delete()
def roomPoll():
inData = request.form
room = Rooms.get_by_id(inData['id'])
if (room == None):
return json.dumps({'code': -1, 'reason': 'eRRoR: No room by that id'})
hereData = room.to_dict()
inMessages = json.loads(inData['messages'])
newMessages = []
for msgPlace in xrange(int(inData['chatHistoryLength']) - len(inMessages), len(hereData['chatHistory'])):
newMessages.append(hereData['chatHistory'][msgPlace])
for msg in inMessages:
msgWithName = {}
msgWithName['chatMessage'] = msg
msgWithName['username'] = session['username']
msgWithName['date'] = datetime.utcnow().strftime("%a, %d %b %Y %H:%M:%S")
room.chatHistory.append(json.dumps(msgWithName))
room.put()
#codes: -1: error - 0: no changes - 1: changes on server - 2: changes on client - 3: changes on server and client
if (inData['canvasChanged'] == 'false'):
if (int(inData['canvasVersion']) == hereData['canvasVersion']):
return json.dumps({'code': 0, 'messages': newMessages})
else:
hereData['code'] = 1
hereData['messages'] = newMessages
return json.dumps(hereData)
else:
if (int(inData['canvasVersion']) == hereData['canvasVersion']):
room.canvas = inData['canvas']
room.canvasVersion = int(inData['canvasVersion']) + 1
room.put()
return json.dumps({'code': 2, 'canvasVersion': int(inData['canvasVersion']) + 1, 'messages': newMessages})
else:
# todo - diff
hereData['code'] = 3
hereData['messages'] = newMessages
return json.dumps(hereData)
def join_game_room(room_id, user_args):
# valide room
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
socketio.emit("startGame", {"data": 'This is not a valid room id bobo', "status": 400}, room=request.sid)
return
# get room from db
room = Rooms.objects(id=room_id).first()
if room:
# if room not open
if not room.isOpen:
# signal game start
socketio.emit('startGame', {'data': 'Game in progress', "status": 410}, room=request.sid)
app.logger.info('progress')
return
# check if player2 chose same color as player1
if user_args['color'] == room.players[0]['color']:
socketio.emit('startGame', {"data": 'Same color motek!', "status": 409}, room=request.sid)
app.logger.info('color')
return
# add player to db
player = Player(name=user_args['name'],
color=user_args['color'], sid=request.sid)
room.players.append(player)
room.isOpen = False
room.save()
# add players to room session
join_room(room_id)
room_json = room_to_json(room)
# signal game start
socketio.emit("startGame", {'data': room_json, "status": 200}, room=room_id)
else:
socketio.emit("startGame", {'data': 'No such room', "status": 404}, room=request.sid)
def method_name(room_id):
if str(request.method) != 'POST':
return 'NOT OPTIONS', 400
data = json.loads(request.get_data().decode())
if 'newBoard' not in data:
return 'Missing data parameter', 401
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
return 'Room id is not valid omer', 402
room = Rooms.objects(id=room_id).first()
if not room:
return 'No such room', 404
# All good:
room.resultsTable = data['newBoard']
room.save()
return 'goods', 200
def offer_name_game(room_id):
is_valid = ObjectId.is_valid(room_id)
if not is_valid:
socketio.emit("newGameOffer", {"data": 'This is not a valid room id bobo', 'status': 400}, room=request.sid)
return
room = Rooms.objects(id=room_id).first()
if not room:
socketio.emit('newGameOffer', {'data': 'No room', 'status': 404}, room=request.sid)
return
if not room.gameEnded:
socketio.emit('newGameOffer', {'data': 'Game didnt end yet', 'status': 401}, room=request.sid)
return
# default
sid_target = room.players[0].sid
# check if the first player is the asker, if he is, set the other player as target
if request.sid == room.players[0].sid:
sid_target = room.players[1].sid
socketio.emit('newGameOffer', {'status': 200} ,room=sid_target)
def setUp(self):
super().setUp()
self.mongo_model = Rooms(self.db, 'rooms')
def viewStudentSchedule():
"""
A schedule contains the following information per specific class:
subject id
subject name
type of session(cohort based learning, lecture, lab)
start time to end time
location of session(room id)
professors teaching
"""
input_dict = {'professor':[],'subject':[],'classroom':[],'studentGroup':[]}
prof_format = {'name':'','id':0,'courseTable':{}}
subject_format = {'component':[],'pillar':0,'sessionNumber':0,'name':'','term':1,'cohortNumber':1,'totalEnrollNumber':10,'type':0,'courseId':''}
class_format = {'name':'','location':'','id':1,'roomType':0,'capacity':10}
studentGroup_format = {'pillar': 0, 'size': 0, 'subjects': [], 'name': '', 'cohort': 0, 'term': 1,'id':0}
for professor in Users.getAllProfessors():
input_dict['professor'].append({'name':professor.fullname,'id':professor.professor_id,'coursetable':ast.literal_eval(professor.coursetable)})
for each_professor in input_dict['professor']:
each_professor['coursetable'] = {str(k):ast.literal_eval(v) for k,v in each_professor['coursetable'].items()}
input_dict['subject'] = Subjects.getAllSubjects()
input_dict['classroom'] = Rooms.geAllRooms()
input_dict['studentGroup'] = studentGroup.getAllGroups()
Session = {'Lab':2,'Cohort Based Learning':0,'Lecture':1}
student_schedule = [['Monday','Tuesday','Wedneday','Thursday','Friday'],
['08:30-09:00',None,None,None,None,None],
['09:00-09:30',None,None,None,None,None],
['09:30-10:00',None,None,None,None,None],
['10:00-10:30',None,None,None,None,None],
['10:30-11:00',None,None,None,None,None],
['11:00-11:30',None,None,None,None,None],
['11:30-12:00',None,None,None,None,None],
['12:00-12:30',None,None,None,None,None],
['12:30-13:00',None,None,None,None,None],
['13:00-13:30',None,None,None,None,None],
['13:30-14:00',None,None,None,None,None],
['14:00-14:30',None,None,None,None,None],
['14:30-15:00',None,None,None,None,None],
['15:00-15:30',None,None,None,None,None],
['15:30-16:00',None,None,None,None,None],
['16:00-16:30',None,None,None,None,None],
['16:30-17:00',None,None,None,None,None],
['17:00-17:30',None,None,None,None,None],
['17:30-18:00',None,None,None,None,None],
['18:00-18:30',None,None,None,None,None],
['18:30-19:00',None,None,None,None,None]]
if current_user.user_group == 'student':
subject_cohort_dict = {}
for each_student_group in input_dict['studentGroup']:
if each_student_group['name'] == current_user.student_group:
for subject in each_student_group['subjects']:
subject_cohort_dict[str(subject)] = int(each_student_group['cohort'])
break
print(subject_cohort_dict)
user_timetable = Timetable.find_Timetable(subject_cohort_dict)
for specific_class in user_timetable['user_timetable']:
class_info = []
subject_id = str(specific_class['subject'])
subject_name = ''
for each_subject in input_dict['subject']:
if each_subject['courseId'] == specific_class['subject']:
subject_name = each_subject['name']
break
session_type = 'Lecture' if len(ast.literal_eval(specific_class['cohort'])) > 1 else 'Cohort Based Learning'
start_to_end = student_schedule[int(specific_class['startTime'])+1][0][0:6] +\
student_schedule[int(float(specific_class['duration'])*2)+int(specific_class['startTime'])][0][6:]
location = specific_class['classroom']
professors_teaching = ''
for professor in input_dict['professor']:
if subject_id in list(professor['coursetable'].keys()):
professors_teaching += professor['name'] + ","
professors_teaching = professors_teaching[:len(professors_teaching)-1]
input_specific_class = subject_id + "<br>"\
+ subject_name + "<br>"\
+ session_type + "<br>"\
+ start_to_end + "<br>"\
+ location + "<br>"\
+ professors_teaching
class_info.append(int(float(specific_class['duration'])*2))
class_info.append(input_specific_class)
student_schedule[int(specific_class['startTime'])+1][int(specific_class['weekday'])+1] = class_info
print(student_schedule)
#redirect(url_for('home'))
return render_template("viewStudentSchedule.html",student_schedule=student_schedule)
from diksha import db from models import Rooms # hostel 1: 20 Non AC, 10 AC for i in range(25): rooms = Rooms( availability="YES", cost_per_day=300, ac="NONAC", hostel_number=1 ) db.session.add(rooms) db.session.commit() for i in range(10): rooms = Rooms( availability="YES", cost_per_day=500, ac="AC", hostel_number=1 ) db.session.add(rooms) db.session.commit() # hostel 2: 5 Non AC, 3 AC for i in range(5): rooms = Rooms( availability="YES", cost_per_day=300, ac="NONAC",
def on_message(self, message):
logger = logging.getLogger()
answer = None
data = helper.is_json(message)
logger.warning(data)
if data == False:
self.write_message('malformed JSON')
log(fh, 1, 'Out: '+'malformed JSON')
return
obj = msg_type = sid = None
if "MSG_TYPE" not in data:
answer = helper.build_json_answer(
data["ID"], "INVALID", json.dumps("PLEASE ENTER MESSAGE TYPE"))
self.write_message(answer)
return
MSG_TYPE = data["MSG_TYPE"]
if MSG_TYPE == "SAVE_ROOM_TO_DATABASE":
room = Rooms()
room.name = data["ROOM_NAME"]
room.data = data["ROOM_DATA"]
logger.warning(data["ROOM_DATA"])
try:
session.add(room)
session.commit()
except:
session.rollback()
answer = helper.build_json_answer(
data["ID"], "SUCCESS", json.dumps(room.name + " erfolgreich hinzugefügt"))
elif MSG_TYPE == "GET_ROOM_FROM_DATABASE":
room = session.query(Rooms).get(data["ROOM_NAME"])
logger.warning(room)
answer = helper.build_json_answer(
data["ID"], MSG_TYPE, json.dumps(room.data))
elif MSG_TYPE == "SHOW_ALL_ROOMS":
result = session.query(Rooms).all()
room_names = []
for room in result:
logger.warning(room)
room_names.append(room.name)
answer = helper.build_json_answer(
data["ID"], MSG_TYPE, json.dumps(room_names))
# elif MSG_TYPE == "GET_SENSORDATA_FROM_DATABASE":
# sensor = session.query(Sensor_Data).get(data["DATA_TYPE"])
# logger.warning(sensor)
# answer = helper.build_json_answer(
# data["ID"], MSG_TYPE, json.dumps(sensor.data))
elif MSG_TYPE == "SHOW_ALL_SENSOR_DATA":
result = session.query(Sensor_Data).all()
csuids = []
panids = []
tmps = []
hums = []
co2s = []
vocs = []
bats = []
times = []
dates = []
sensor = [csuids, panids, tmps, hums,
co2s, vocs, bats, times, dates]
for sensDat in result:
logger.warning(sensDat)
csuids.append(sensDat.csUID)
panids.append(sensDat.panID)
tmps.append(sensDat.tmp)
hums.append(sensDat.hum)
co2s.append(sensDat.co2)
vocs.append(sensDat.voc)
bats.append(sensDat.bat)
times.append(sensDat.time)
dates.append(sensDat.date)
answer = helper.build_json_answer(
data["ID"], MSG_TYPE, json.dumps(sensor))
elif MSG_TYPE == "GET_ALL_SETTINGS":
result = session.query(Settings).all()
settings = []
for setting in result:
settings.append({RULE: setting.rule, VALUE: setting.value})
answer = helper.build_json_answer(
data["ID"], MSG_TYPE, json.dumps(settings))
logger.warning(result)
elif MSG_TYPE == "LOGIN":
result = {"STATUS": "FAIL"}
user = session.query(User).get(data["EMAIL"])
if user:
if (pbkdf2_sha256.verify(data["PASSWORD"], user.password) == True):
result = {
"STATUS": "SUCCESS",
"EMAIL": user.email,
"USERNAME": user.username,
"LAST_LOGIN": user.last_login
}
answer = helper.build_json_answer(
data["ID"], MSG_TYPE, json.dumps(result, default=str))
elif MSG_TYPE == "REGISTER":
hashed_password = pbkdf2_sha256.encrypt(
data["PASSWORD"], rounds=12000, salt_size=16)
user = User()
user.email = data["EMAIL"]
user.password = hashed_password
user.username = data["USERNAME"]
user.last_login = time()
try:
session.add(user)
session.commit()
except Exception as e:
logger.error('Error at %s', 'division', exc_info=e)
session.rollback()
self.write_message(helper.build_json_answer(
data["ID"], MSG_TYPE, json.dumps({"STATUS": "DUPLICATE"})))
return
result = session.query(User).get(data["EMAIL"])
result = {
"EMAIL": result.email,
"PASSWORD": result.password
}
answer = helper.build_json_answer(
data["ID"], MSG_TYPE, json.dumps(result))
else:
answer = helper.build_json_answer(
data["ID"], "INVALID", json.dumps("INVALID MESSAGE TYPE"))
if answer:
logger.warning(answer)
self.write_message(answer)
def room_shuffled(self):
Rooms.update(shuffled=True).where(Rooms.id == self.room_id).execute()
async def rooms(req):
rooms = []
async for room in Rooms(req.db).collection.find({}, {'_id': 1}):
rooms.append(room.get('_id'))
print(rooms)
return {'rooms': rooms}
def get_room_shuffled(self):
if self.room_id:
return Rooms.get_or_none(id=self.room_id).shuffled
