def grade_history(uid=None):
logged_in_user = auth.get_logged_in_user()
if uid is not None:
if logged_in_user.role != "teacher" and logged_in_user.id != uid:
return "not allowed"
else:
uid = logged_in_user.id
student = StudentRecord(uid)
try:
scores = Score.select().where(Score.user == uid)
except Score.DoesNotExist:
scores = []
try:
brownie = Brownie.get(Brownie.user == uid)
except Brownie.DoesNotExist:
brownie = None
published_pids = red.smembers("published-problems")
published_pids = sorted(int(p) for p in published_pids)
return render_template(
"problem/grade_history.html", scores=scores, brownie=brownie, student=student, published_pids=published_pids
)
def index():
logged_in_user = auth.get_logged_in_user()
user_record = StudentRecord(logged_in_user.id)
user_record.online = True
user_record.save()
# if user is running on another client, close the other.
sse.close(user_record.id)
current_channel = sse.current_channel(user_record.id) or user_record.id
all_users = auth.User.select()
online_students = StudentRecord.online_students()
listeners=[ online_students[int(i)].username \
for i in sse.listening_clients(current_channel) if int(i) in online_students ]
# notify those who can view boards that the client is online
messages = {}
for c, r in online_students.items():
if user_record.id != c and (r.is_teacher or user_record.open_board):
messages[c] = dict(cid=user_record.id, board_status=user_record.open_board)
sse.notify(messages, event='online')
problem_ids = sorted(int(i) for i in red.smembers('published-problems'))
return render_template('sandbox.html',
sum=sum, enumerate=enumerate,
current_channel = current_channel,
problem_ids=problem_ids,
user_record = user_record,
online_students = online_students,
all_users = all_users,
listeners = listeners)
def event_join(host, guest):
online_students = StudentRecord.online_students()
## Key error is possible
guest_record = online_students[int(guest)]
host_record = online_students[int(host)]
host_channel = sse.current_channel(host)
guest_channel = sse.current_channel(guest)
sse.listen_to(host, guest)
m = dict(cid=guest, host_cid=host, board_status=host_record.open_board)
if host!=guest and int(host)!=int(host_channel):
# host is elsewhere
host_of_host = online_students[int(host_channel)]
m.update(notice = "%s is visiting %s's sandbox" % (host_record.username, host_of_host.username))
if guest_record.is_teacher:
pids = sorted(int(i) for i in red.smembers('published-problems'))
scores = [ [p, host_record.scores.get(p,0)] for p in pids ]
m.update(scores=scores, brownies=host_record.brownies)
sse.notify( { guest : m } , event='join')
## Inform old channel and new channel of updated listeners list
guest_listeners = [ online_students[int(i)].username for i in sse.listening_clients(guest_channel) ]
m = dict(host_cid=guest_channel, listeners=guest_listeners)
sse.broadcast(guest_channel, m, m, event='listeners-update')
host_listeners = [ online_students[int(i)].username for i in sse.listening_clients(host) ]
m = dict(host_cid=host, listeners=host_listeners)
sse.broadcast(host, m, m, event='listeners-update')
def grade_history(uid=None):
logged_in_user = auth.get_logged_in_user()
if uid is not None:
if logged_in_user.role != 'teacher' and logged_in_user.id != uid:
return 'not allowed'
else:
uid = logged_in_user.id
student = StudentRecord(uid)
try:
scores = Score.select().where(Score.user == uid)
except Score.DoesNotExist:
scores = []
try:
brownie = Brownie.get(Brownie.user == uid)
except Brownie.DoesNotExist:
brownie = None
published_pids = red.smembers('published-problems')
published_pids = sorted(int(p) for p in published_pids)
return render_template('problem/grade_history.html',
scores=scores,
brownie=brownie,
student=student,
published_pids=published_pids)
def index():
query = Problem.select(Problem).join(ProblemTag,JOIN_LEFT_OUTER) \
.join(Tag,JOIN_LEFT_OUTER).distinct().order_by(Problem.id.desc())
probs = query.execute()
published_probs = [int(p) for p in red.smembers('published-problems')]
stats = {p.id: (p.id in published_probs) for p in probs}
tags = Tag.select()
return render_template('problem/index.html',
stats=stats,
probs=probs,
tags=tags)
def index():
query = (
Problem.select(Problem)
.join(ProblemTag, JOIN_LEFT_OUTER)
.join(Tag, JOIN_LEFT_OUTER)
.distinct()
.order_by(Problem.id.desc())
)
probs = query.execute()
published_probs = [int(p) for p in red.smembers("published-problems")]
stats = {p.id: (p.id in published_probs) for p in probs}
tags = Tag.select()
return render_template("problem/index.html", stats=stats, probs=probs, tags=tags)
def publish_toggle(pid):
if not red.sismember("published-problems", pid):
red.sadd("published-problems", pid)
else:
red.srem("published-problems", pid)
all_records = StudentRecord.online_students()
pids = sorted(int(p) for p in red.smembers("published-problems"))
messages = {}
for k, v in all_records.items():
uid = sse.current_channel(k) if v.is_teacher else k
scores = [[pid, all_records[uid].scores.get(pid, 0)] for pid in pids]
messages[k] = dict(cid=uid, scores=scores)
sse.notify(messages, event="problems-updated")
return redirect(url_for("problem.index"))
def remove_db_exist_ids(danmakuMap: MutableMapping[int, DanmakuDO],
relationMap: MutableMapping[int, DanmakuRealationDO],
cids: AbstractSet[int]):
"""
剔除数据库中已经存在的danmaku
"""
print('from redis get cids: %s' % cids.__len__())
cids_all_danmakuId: Set[int] = set()
for cid in cids:
for item in red.smembers(cid):
cids_all_danmakuId.add(int(item))
print('all danmaku len: %s' % cids_all_danmakuId.__len__())
for _id in cids_all_danmakuId:
danmakuMap.pop(_id, None)
relationMap.pop(_id, None)
def publish_toggle(pid):
if not red.sismember('published-problems', pid):
red.sadd('published-problems', pid)
else:
red.srem('published-problems', pid)
all_records = StudentRecord.online_students()
pids = sorted(int(p) for p in red.smembers('published-problems'))
messages = {}
for k, v in all_records.items():
uid = sse.current_channel(k) if v.is_teacher else k
scores = [[pid, all_records[uid].scores.get(pid, 0)] for pid in pids]
messages[k] = dict(cid=uid, scores=scores)
sse.notify(messages, event="problems-updated")
return redirect(url_for('problem.index'))
def grade():
uid = int(request.form["uid"])
tid = int(request.form["tid"])
pid = int(request.form["pid"])
score = int(request.form["score"])
# Store in redis
user_record = StudentRecord(uid)
user_record.scores[pid] = score
user_record.save()
pids = sorted(int(i) for i in red.smembers("published-problems"))
scores = [[p, user_record.scores.get(p, 0)] for p in pids]
message = dict(cid=user_record.id, scores=scores, pid=pid, score=score)
sse.notify({uid: message, tid: message}, event="scores-updated")
# Store in database
q = Score.update(points=score).where(Score.problem == pid, Score.user == uid)
if q.execute() == 0:
q = Score.create(problem=pid, user=uid, points=score)
return '<i class="icon-okay"></i>'
def event_join(host, guest):
online_students = StudentRecord.online_students()
## Key error is possible
guest_record = online_students[int(guest)]
host_record = online_students[int(host)]
host_channel = sse.current_channel(host)
guest_channel = sse.current_channel(guest)
sse.listen_to(host, guest)
m = dict(cid=guest, host_cid=host, board_status=host_record.open_board)
if host != guest and int(host) != int(host_channel):
# host is elsewhere
host_of_host = online_students[int(host_channel)]
m.update(notice="%s is visiting %s's sandbox" %
(host_record.username, host_of_host.username))
if guest_record.is_teacher:
pids = sorted(int(i) for i in red.smembers('published-problems'))
scores = [[p, host_record.scores.get(p, 0)] for p in pids]
m.update(scores=scores, brownies=host_record.brownies)
sse.notify({guest: m}, event='join')
## Inform old channel and new channel of updated listeners list
guest_listeners = [
online_students[int(i)].username
for i in sse.listening_clients(guest_channel)
]
m = dict(host_cid=guest_channel, listeners=guest_listeners)
sse.broadcast(guest_channel, m, m, event='listeners-update')
host_listeners = [
online_students[int(i)].username for i in sse.listening_clients(host)
]
m = dict(host_cid=host, listeners=host_listeners)
sse.broadcast(host, m, m, event='listeners-update')
def index():
logged_in_user = auth.get_logged_in_user()
user_record = StudentRecord(logged_in_user.id)
user_record.online = True
user_record.save()
# if user is running on another client, close the other.
sse.close(user_record.id)
current_channel = sse.current_channel(user_record.id) or user_record.id
all_users = auth.User.select()
online_students = StudentRecord.online_students()
listeners=[ online_students[int(i)].username \
for i in sse.listening_clients(current_channel) if int(i) in online_students ]
# notify those who can view boards that the client is online
messages = {}
for c, r in online_students.items():
if user_record.id != c and (r.is_teacher or user_record.open_board):
messages[c] = dict(cid=user_record.id,
board_status=user_record.open_board)
sse.notify(messages, event='online')
problem_ids = sorted(int(i) for i in red.smembers('published-problems'))
return render_template('sandbox.html',
sum=sum,
enumerate=enumerate,
current_channel=current_channel,
problem_ids=problem_ids,
user_record=user_record,
online_students=online_students,
all_users=all_users,
listeners=listeners)
def grade():
uid = int(request.form['uid'])
tid = int(request.form['tid'])
pid = int(request.form['pid'])
score = int(request.form['score'])
# Store in redis
user_record = StudentRecord(uid)
user_record.scores[pid] = score
user_record.save()
pids = sorted(int(i) for i in red.smembers('published-problems'))
scores = [[p, user_record.scores.get(p, 0)] for p in pids]
message = dict(cid=user_record.id, scores=scores, pid=pid, score=score)
sse.notify({uid: message, tid: message}, event="scores-updated")
# Store in database
q = Score.update(points=score).where(Score.problem == pid,
Score.user == uid)
if q.execute() == 0:
q = Score.create(problem=pid, user=uid, points=score)
return '<i class="icon-okay"></i>'
